v1.1.0 model poms

asie-api/pom.xml

@@ -6,20 +6,20 @@
 	<parent>
 		<groupId>com.inteligr8.alfresco</groupId>
 		<artifactId>asie-platform-module-parent</artifactId>
-		<version>1.1.0</version>
+		<version>1.2.2</version>
 		<relativePath>../</relativePath>
 	</parent>
 
 	<groupId>com.inteligr8.alfresco</groupId>
 	<artifactId>asie-api</artifactId>
-	<version>1.0.0-asie2</version>
+	<version>1.1.0-asie2</version>
 	<packaging>jar</packaging>
 	
-	<name>ASIE JAX-RS API</name>
-	<description>Alfresco Search &amp; Insight Engine JAX-RS API</description>
+	<name>ASIE Jakarta RS API</name>
+	<description>Alfresco Search &amp; Insight Engine Jakarta RS API</description>
 	
 	<properties>
-		<alfresco.platform.version>6.0.0</alfresco.platform.version>
+		<alfresco.platform.version>23.2.0</alfresco.platform.version>
 	</properties>
 
 	<dependencyManagement>
@@ -38,11 +38,45 @@
 		<dependency>
 			<groupId>com.inteligr8</groupId>
 			<artifactId>solr-api</artifactId>
-			<version>1.0.0-solr6</version>
+			<version>1.1.0-solr6</version>
 		</dependency>
 		<dependency>
 			<groupId>org.alfresco</groupId>
-			<artifactId>alfresco-repository</artifactId>
+			<artifactId>alfresco-data-model</artifactId>
+			<exclusions>
+				<exclusion>
+					<groupId>*</groupId>
+					<artifactId>*</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.commons</groupId>
+			<artifactId>commons-lang3</artifactId>
+			<version>3.17.0</version>
+		</dependency>
+		<dependency>
+			<groupId>org.apache.logging.log4j</groupId>
+			<artifactId>log4j-slf4j2-impl</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>com.inteligr8</groupId>
+			<artifactId>common-rest-client</artifactId>
+			<version>3.0.2-jersey</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.glassfish.jersey.inject</groupId>
+			<artifactId>jersey-hk2</artifactId>
+			<version>3.1.10</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter-api</artifactId>
+			<version>5.11.2</version>
+			<scope>test</scope>
 		</dependency>
 	</dependencies>
 	

asie-api/src/main/java/com/inteligr8/alfresco/asie/api/CoreAdminApi.java

@@ -1,12 +1,12 @@
 package com.inteligr8.alfresco.asie.api;
 
-import com.inteligr8.alfresco.asie.model.ActionResponse;
+import com.inteligr8.alfresco.asie.model.ActionCoreResponse;
 import com.inteligr8.alfresco.asie.model.EmptyResponse;
 import com.inteligr8.alfresco.asie.model.core.CheckRequest;
 import com.inteligr8.alfresco.asie.model.core.DisableIndexingRequest;
 import com.inteligr8.alfresco.asie.model.core.EnableIndexingRequest;
+import com.inteligr8.alfresco.asie.model.core.FixAction;
 import com.inteligr8.alfresco.asie.model.core.FixRequest;
-import com.inteligr8.alfresco.asie.model.core.FixResponseAction;
 import com.inteligr8.alfresco.asie.model.core.IndexingStatusAction;
 import com.inteligr8.alfresco.asie.model.core.NewCoreRequest;
 import com.inteligr8.alfresco.asie.model.core.NewDefaultIndexRequest;
@@ -14,14 +14,15 @@ import com.inteligr8.alfresco.asie.model.core.PurgeRequest;
 import com.inteligr8.alfresco.asie.model.core.ReindexRequest;
 import com.inteligr8.alfresco.asie.model.core.ReportRequest;
 import com.inteligr8.alfresco.asie.model.core.ReportResponse;
+import com.inteligr8.alfresco.asie.model.core.RetryAction;
 import com.inteligr8.alfresco.asie.model.core.RetryRequest;
-import com.inteligr8.alfresco.asie.model.core.RetryResponseAction;
 import com.inteligr8.alfresco.asie.model.core.SummaryRequest;
 import com.inteligr8.alfresco.asie.model.core.SummaryResponse;
 import com.inteligr8.alfresco.asie.model.core.UpdateCoreRequest;
 import com.inteligr8.alfresco.asie.model.core.UpdateLog4jRequest;
 import com.inteligr8.alfresco.asie.model.core.UpdateSharedRequest;
-import com.inteligr8.solr.model.ResponseAction;
+import com.inteligr8.solr.model.Action;
+import com.inteligr8.solr.model.ActionResponse;
 
 import jakarta.ws.rs.BeanParam;
 import jakarta.ws.rs.GET;
@@ -42,43 +43,43 @@ public interface CoreAdminApi extends com.inteligr8.solr.api.CoreAdminApi {
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
-	ActionResponse<ResponseAction> updateCore(@BeanParam UpdateCoreRequest request);
+	ActionResponse<Action> updateCore(@BeanParam UpdateCoreRequest request);
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
-	ActionResponse<ResponseAction> check(@BeanParam CheckRequest request);
+	ActionResponse<Action> check(@BeanParam CheckRequest request);
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
-	ActionResponse<ResponseAction> updateShared(@BeanParam UpdateSharedRequest request);
+	ActionResponse<Action> updateShared(@BeanParam UpdateSharedRequest request);
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
-	ActionResponse<ResponseAction> updateLog4j(@BeanParam UpdateLog4jRequest request);
+	ActionResponse<Action> updateLog4j(@BeanParam UpdateLog4jRequest request);
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
-	ActionResponse<ResponseAction> purge(@BeanParam PurgeRequest request);
+	ActionCoreResponse<Action> purge(@BeanParam PurgeRequest request);
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
-	ActionResponse<ResponseAction> reindex(@BeanParam ReindexRequest request);
+	ActionCoreResponse<Action> reindex(@BeanParam ReindexRequest request);
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
-	ActionResponse<RetryResponseAction> retry(@BeanParam RetryRequest request);
+	ActionCoreResponse<RetryAction> retry(@BeanParam RetryRequest request);
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
-	ActionResponse<FixResponseAction> fix(@BeanParam FixRequest request);
+	ActionCoreResponse<FixAction> fix(@BeanParam FixRequest request);
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
-	ActionResponse<IndexingStatusAction> enableIndexing(@BeanParam EnableIndexingRequest request);
+	ActionCoreResponse<IndexingStatusAction> enableIndexing(@BeanParam EnableIndexingRequest request);
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)
-	ActionResponse<IndexingStatusAction> disableIndexing(@BeanParam DisableIndexingRequest request);
+	ActionCoreResponse<IndexingStatusAction> disableIndexing(@BeanParam DisableIndexingRequest request);
 
 	@GET
 	@Produces(MediaType.APPLICATION_JSON)

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/ActionCoreResponse.java

@@ -0,0 +1,18 @@
+package com.inteligr8.alfresco.asie.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.inteligr8.solr.model.Action;
+import com.inteligr8.solr.model.Cores;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class ActionCoreResponse<T extends Action> extends BaseResponse {
+	
+	@JsonProperty(value = "action")
+	private Cores<T> cores;
+	
+	public Cores<T> getCores() {
+		return cores;
+	}
+
+}

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/ActionResponse.java

@@ -1,22 +0,0 @@
-package com.inteligr8.alfresco.asie.model;
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonProperty.Access;
-import com.inteligr8.solr.model.ResponseAction;
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-public class ActionResponse<T extends ResponseAction> extends BaseResponse {
-	
-	@JsonProperty(access = Access.READ_ONLY)
-	private T action;
-	
-	public T getAction() {
-		return action;
-	}
-	
-	protected void setAction(T action) {
-		this.action = action;
-	}
-
-}

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/BaseResponse.java

@@ -1,41 +1,28 @@
 package com.inteligr8.alfresco.asie.model;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonProperty.Access;
 
 public class BaseResponse extends com.inteligr8.solr.model.BaseResponse {
 	
-	@JsonProperty(value = "STATUS", access = Access.READ_ONLY)
+	@JsonProperty(value = "STATUS")
 	private String reason;
 	
-	@JsonProperty(value = "exception", access = Access.READ_ONLY)
+	@JsonProperty(value = "exception")
 	private String exception;
 	
-	@JsonProperty(value = "msg", access = Access.READ_ONLY)
+	@JsonProperty(value = "msg")
 	private String message;
 	
 	public String getReason() {
 		return reason;
 	}
 	
-	protected void setReason(String reason) {
-		this.reason = reason;
-	}
-	
 	public String getException() {
 		return exception;
 	}
 	
-	protected void setException(String exception) {
-		this.exception = exception;
-	}
-	
 	public String getMessage() {
 		return message;
 	}
-	
-	protected void setMessage(String message) {
-		this.message = message;
-	}
 
 }

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/FixAction.java

@@ -0,0 +1,25 @@
+package com.inteligr8.alfresco.asie.model.core;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.inteligr8.solr.model.Action;
+import com.inteligr8.solr.model.TransactionStatus;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class FixAction extends Action {
+	
+	@JsonProperty(value = "txToReindex")
+	private TransactionStatus transactionStatus;
+	
+	@JsonProperty(value = "aclChangeSetToReindex")
+	private TransactionStatus aclStatus;
+	
+	public TransactionStatus getTransactionStatus() {
+		return transactionStatus;
+	}
+	
+	public TransactionStatus getAclStatus() {
+		return aclStatus;
+	}
+
+}

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/FixResponseAction.java

@@ -1,34 +0,0 @@
-package com.inteligr8.alfresco.asie.model.core;
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonProperty.Access;
-import com.inteligr8.solr.model.ResponseAction;
-import com.inteligr8.solr.model.TransactionResponseStatus;
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-public class FixResponseAction extends ResponseAction {
-	
-	@JsonProperty(value = "txToReindex", access = Access.READ_ONLY)
-	private TransactionResponseStatus transactionStatus;
-	
-	@JsonProperty(value = "aclChangeSetToReindex", access = Access.READ_ONLY)
-	private TransactionResponseStatus aclStatus;
-	
-	public TransactionResponseStatus getTransactionStatus() {
-		return transactionStatus;
-	}
-	
-	protected void setTransactionStatus(TransactionResponseStatus transactionStatus) {
-		this.transactionStatus = transactionStatus;
-	}
-	
-	public TransactionResponseStatus getAclStatus() {
-		return aclStatus;
-	}
-	
-	protected void setAclStatus(TransactionResponseStatus aclStatus) {
-		this.aclStatus = aclStatus;
-	}
-
-}

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/IndexingStatusAction.java

@@ -1,25 +1,43 @@
 package com.inteligr8.alfresco.asie.model.core;
 
-import java.util.Map;
-
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.inteligr8.solr.model.ResponseAction;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.inteligr8.solr.model.Action;
 
 @JsonIgnoreProperties(ignoreUnknown = true)
-public class IndexingStatusAction extends ResponseAction {
+public class IndexingStatusAction extends Action {
 	
-	private Map<String, IndexingStatusMetadata> cores;
-
-	@JsonAnyGetter
-	public Map<String, IndexingStatusMetadata> getCores() {
-		return cores;
+	@JsonProperty(value = "ACL")
+	private Boolean aclIndexed;
+	
+	@JsonProperty(value = "CONTENT")
+	private Boolean contentIndexed;
+	
+	@JsonProperty(value = "METADATA")
+	private Boolean metadataIndexed;
+	
+	public boolean isAclIndexed() {
+		return Boolean.TRUE.equals(this.aclIndexed);
 	}
 	
-	@JsonAnySetter
-	public void setCores(Map<String, IndexingStatusMetadata> cores) {
-		this.cores = cores;
+	public Boolean getAclIndexed() {
+		return aclIndexed;
+	}
+	
+	public boolean isContentIndexed() {
+		return Boolean.TRUE.equals(this.contentIndexed);
+	}
+	
+	public Boolean getContentIndexed() {
+		return contentIndexed;
+	}
+	
+	public boolean isMetadataIndexed() {
+		return Boolean.TRUE.equals(this.metadataIndexed);
+	}
+	
+	public Boolean getMetadataIndexed() {
+		return metadataIndexed;
 	}
 
 }

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/IndexingStatusMetadata.java

@@ -1,56 +0,0 @@
-package com.inteligr8.alfresco.asie.model.core;
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonProperty.Access;
-import com.inteligr8.solr.model.ResponseAction;
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-public class IndexingStatusMetadata extends ResponseAction {
-	
-	@JsonProperty(value = "ACL", access = Access.READ_ONLY)
-	private Boolean aclIndexed;
-	
-	@JsonProperty(value = "CONTENT", access = Access.READ_ONLY)
-	private Boolean contentIndexed;
-	
-	@JsonProperty(value = "METADATA", access = Access.READ_ONLY)
-	private Boolean metadataIndexed;
-	
-	public boolean isAclIndexed() {
-		return Boolean.TRUE.equals(this.aclIndexed);
-	}
-	
-	public Boolean getAclIndexed() {
-		return aclIndexed;
-	}
-	
-	protected void setAclIndexed(Boolean aclIndexed) {
-		this.aclIndexed = aclIndexed;
-	}
-	
-	public boolean isContentIndexed() {
-		return Boolean.TRUE.equals(this.contentIndexed);
-	}
-	
-	public Boolean getContentIndexed() {
-		return contentIndexed;
-	}
-	
-	protected void setContentIndexed(Boolean contentIndexed) {
-		this.contentIndexed = contentIndexed;
-	}
-	
-	public boolean isMetadataIndexed() {
-		return Boolean.TRUE.equals(this.metadataIndexed);
-	}
-	
-	public Boolean getMetadataIndexed() {
-		return metadataIndexed;
-	}
-	
-	protected void setMetadataIndexed(Boolean metadataIndexed) {
-		this.metadataIndexed = metadataIndexed;
-	}
-
-}

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/PurgeRequest.java

@@ -19,16 +19,16 @@ public class PurgeRequest extends JsonFormattedResponseRequest<PurgeRequest> {
 	private String core;
 	
 	@QueryParam("txid")
-	private Integer transactionId;
+	private Long transactionId;
 	
 	@QueryParam("acltxid")
-	private Integer aclTransactionId;
+	private Long aclTransactionId;
 	
 	@QueryParam("nodeId")
-	private Integer nodeId;
+	private Long nodeId;
 	
 	@QueryParam("aclid")
-	private Integer aclId;
+	private Long aclId;
 	
 	public String getAction() {
 		return action;
@@ -51,54 +51,54 @@ public class PurgeRequest extends JsonFormattedResponseRequest<PurgeRequest> {
 		return this;
 	}
 	
-	public Integer getTransactionId() {
+	public Long getTransactionId() {
 		return transactionId;
 	}
 	
-	public void setTransactionId(Integer transactionId) {
+	public void setTransactionId(Long transactionId) {
 		this.transactionId = transactionId;
 	}
 	
-	public PurgeRequest withTransactionId(Integer transactionId) {
+	public PurgeRequest withTransactionId(Long transactionId) {
 		this.transactionId = transactionId;
 		return this;
 	}
 	
-	public Integer getAclTransactionId() {
+	public Long getAclTransactionId() {
 		return aclTransactionId;
 	}
 	
-	public void setAclTransactionId(Integer aclTransactionId) {
+	public void setAclTransactionId(Long aclTransactionId) {
 		this.aclTransactionId = aclTransactionId;
 	}
 	
-	public PurgeRequest withAclTransactionId(Integer aclTransactionId) {
+	public PurgeRequest withAclTransactionId(Long aclTransactionId) {
 		this.aclTransactionId = aclTransactionId;
 		return this;
 	}
 	
-	public Integer getNodeId() {
+	public Long getNodeId() {
 		return nodeId;
 	}
 	
-	public void setNodeId(Integer nodeId) {
+	public void setNodeId(Long nodeId) {
 		this.nodeId = nodeId;
 	}
 	
-	public PurgeRequest withNodeId(Integer nodeId) {
+	public PurgeRequest withNodeId(Long nodeId) {
 		this.nodeId = nodeId;
 		return this;
 	}
 	
-	public Integer getAclId() {
+	public Long getAclId() {
 		return aclId;
 	}
 	
-	public void setAclId(Integer aclId) {
+	public void setAclId(Long aclId) {
 		this.aclId = aclId;
 	}
 	
-	public PurgeRequest withAclId(Integer aclId) {
+	public PurgeRequest withAclId(Long aclId) {
 		this.aclId = aclId;
 		return this;
 	}

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/ReindexRequest.java

@@ -19,16 +19,16 @@ public class ReindexRequest extends JsonFormattedResponseRequest<ReindexRequest>
 	private String core;
 	
 	@QueryParam("txid")
-	private Integer transactionId;
+	private Long transactionId;
 	
 	@QueryParam("acltxid")
-	private Integer aclTransactionId;
+	private Long aclTransactionId;
 	
 	@QueryParam("nodeId")
-	private Integer nodeId;
+	private Long nodeId;
 	
 	@QueryParam("aclid")
-	private Integer aclId;
+	private Long aclId;
 	
 	@QueryParam("query")
 	private String query;
@@ -54,54 +54,54 @@ public class ReindexRequest extends JsonFormattedResponseRequest<ReindexRequest>
 		return this;
 	}
 	
-	public Integer getTransactionId() {
+	public Long getTransactionId() {
 		return transactionId;
 	}
 	
-	public void setTransactionId(Integer transactionId) {
+	public void setTransactionId(Long transactionId) {
 		this.transactionId = transactionId;
 	}
 	
-	public ReindexRequest withTransactionId(Integer transactionId) {
+	public ReindexRequest withTransactionId(Long transactionId) {
 		this.transactionId = transactionId;
 		return this;
 	}
 	
-	public Integer getAclTransactionId() {
+	public Long getAclTransactionId() {
 		return aclTransactionId;
 	}
 	
-	public void setAclTransactionId(Integer aclTransactionId) {
+	public void setAclTransactionId(Long aclTransactionId) {
 		this.aclTransactionId = aclTransactionId;
 	}
 	
-	public ReindexRequest withAclTransactionId(Integer aclTransactionId) {
+	public ReindexRequest withAclTransactionId(Long aclTransactionId) {
 		this.aclTransactionId = aclTransactionId;
 		return this;
 	}
 	
-	public Integer getNodeId() {
+	public Long getNodeId() {
 		return nodeId;
 	}
 	
-	public void setNodeId(Integer nodeId) {
+	public void setNodeId(Long nodeId) {
 		this.nodeId = nodeId;
 	}
 	
-	public ReindexRequest withNodeId(Integer nodeId) {
+	public ReindexRequest withNodeId(Long nodeId) {
 		this.nodeId = nodeId;
 		return this;
 	}
 	
-	public Integer getAclId() {
+	public Long getAclId() {
 		return aclId;
 	}
 	
-	public void setAclId(Integer aclId) {
+	public void setAclId(Long aclId) {
 		this.aclId = aclId;
 	}
 	
-	public ReindexRequest withAclId(Integer aclId) {
+	public ReindexRequest withAclId(Long aclId) {
 		this.aclId = aclId;
 		return this;
 	}

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/Report.java

@@ -1,24 +1,9 @@
 package com.inteligr8.alfresco.asie.model.core;
 
-import java.util.Map;
-
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.inteligr8.solr.model.Metadata;
 
 @JsonIgnoreProperties(ignoreUnknown = true)
-public class Report {
-	
-	private Map<String, Map<String, Object>> report;
-	
-	@JsonAnyGetter
-	public Map<String, Map<String, Object>> getReport() {
-		return report;
-	}
-	
-	@JsonAnySetter
-	protected void setReport(Map<String, Map<String, Object>> report) {
-		this.report = report;
-	}
+public class Report extends Metadata {
 
 }

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/ReportRequest.java

@@ -25,10 +25,10 @@ public class ReportRequest extends JsonFormattedResponseRequest<ReportRequest> {
 	private Long toTime;
 	
 	@QueryParam("fromTx")
-	private Integer fromTransactionId;
+	private Long fromTransactionId;
 	
 	@QueryParam("toTx")
-	private Integer toTransactionId;
+	private Long toTransactionId;
 	
 	public String getAction() {
 		return action;
@@ -77,28 +77,28 @@ public class ReportRequest extends JsonFormattedResponseRequest<ReportRequest> {
 		return this;
 	}
 	
-	public Integer getFromTransactionId() {
+	public Long getFromTransactionId() {
 		return fromTransactionId;
 	}
 	
-	public void setFromTransactionId(Integer fromTransactionId) {
+	public void setFromTransactionId(Long fromTransactionId) {
 		this.fromTransactionId = fromTransactionId;
 	}
 	
-	public ReportRequest fromTransactionId(Integer fromTransactionId) {
+	public ReportRequest fromTransactionId(Long fromTransactionId) {
 		this.fromTransactionId = fromTransactionId;
 		return this;
 	}
 	
-	public Integer getToTransactionId() {
+	public Long getToTransactionId() {
 		return toTransactionId;
 	}
 	
-	public void setToTransactionId(Integer toTransactionId) {
+	public void setToTransactionId(Long toTransactionId) {
 		this.toTransactionId = toTransactionId;
 	}
 	
-	public ReportRequest toTransactionId(Integer toTransactionId) {
+	public ReportRequest toTransactionId(Long toTransactionId) {
 		this.toTransactionId = toTransactionId;
 		return this;
 	}

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/ReportResponse.java

@@ -2,21 +2,17 @@ package com.inteligr8.alfresco.asie.model.core;
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonProperty.Access;
 import com.inteligr8.alfresco.asie.model.BaseResponse;
+import com.inteligr8.solr.model.Cores;
 
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class ReportResponse extends BaseResponse {
 	
-	@JsonProperty(access = Access.READ_ONLY)
-	private Report report;
+	@JsonProperty(required = true)
+	private Cores<Report> cores;
 	
-	public Report getReport() {
-		return report;
-	}
-	
-	protected void setReport(Report report) {
-		this.report = report;
+	public Cores<Report> getCores() {
+		return cores;
 	}
 
 }

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/RetryAction.java

@@ -0,0 +1,17 @@
+package com.inteligr8.alfresco.asie.model.core;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.inteligr8.solr.model.Action;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class RetryAction extends Action {
+	
+	@JsonProperty(value = "alfresco")
+	private int[] nodeIds;
+	
+	public int[] getNodeIds() {
+		return nodeIds;
+	}
+
+}

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/RetryResponseAction.java

@@ -1,22 +0,0 @@
-package com.inteligr8.alfresco.asie.model.core;
-
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonProperty.Access;
-import com.inteligr8.solr.model.ResponseAction;
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-public class RetryResponseAction extends ResponseAction {
-	
-	@JsonProperty(value = "alfresco", access = Access.READ_ONLY)
-	private int[] nodeIds;
-	
-	public int[] getNodeIds() {
-		return nodeIds;
-	}
-	
-	public void setNodeIds(int[] nodeIds) {
-		this.nodeIds = nodeIds;
-	}
-
-}

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/Summary.java

@@ -1,24 +1,7 @@
 package com.inteligr8.alfresco.asie.model.core;
 
-import java.util.Map;
+import com.inteligr8.solr.model.Metadata;
 
-import com.fasterxml.jackson.annotation.JsonAnyGetter;
-import com.fasterxml.jackson.annotation.JsonAnySetter;
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-
-@JsonIgnoreProperties(ignoreUnknown = true)
-public class Summary {
-	
-	private Map<String, Object> summary;
-	
-	@JsonAnyGetter
-	public Map<String, Object> getSummary() {
-		return summary;
-	}
-	
-	@JsonAnySetter
-	public void setSummary(Map<String, Object> summary) {
-		this.summary = summary;
-	}
+public class Summary extends Metadata {
 
 }

asie-api/src/main/java/com/inteligr8/alfresco/asie/model/core/SummaryResponse.java

@@ -2,21 +2,17 @@ package com.inteligr8.alfresco.asie.model.core;
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonProperty.Access;
 import com.inteligr8.alfresco.asie.model.BaseResponse;
+import com.inteligr8.solr.model.Cores;
 
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class SummaryResponse extends BaseResponse {
 	
-	@JsonProperty(value = "Summary", access = Access.READ_ONLY)
-	private Summary summary;
+	@JsonProperty(value = "Summary", required = true)
+	private Cores<Summary> cores;
 	
-	public Summary getSummary() {
-		return summary;
-	}
-	
-	public void setSummary(Summary summary) {
-		this.summary = summary;
+	public Cores<Summary> getCores() {
+		return cores;
 	}
 
 }

asie-api/src/test/java/com/inteligr8/alfresco/asie/AsieClient.java

@@ -0,0 +1,24 @@
+package com.inteligr8.alfresco.asie;
+
+import java.net.URL;
+
+import com.inteligr8.alfresco.asie.api.CoreAdminApi;
+import com.inteligr8.rs.ClientJerseyImpl;
+
+public class AsieClient extends ClientJerseyImpl {
+	
+	public AsieClient(String hostname) {
+		super(new AsieClientConfiguration().withHostname(hostname));
+		this.register();
+	}
+	
+	public AsieClient(URL baseUrl) {
+		super(new AsieClientConfiguration().withBaseUrl(baseUrl.toString()));
+		this.register();
+	}
+	
+	public CoreAdminApi getCoreAdminApi() {
+		return this.getApi(this.getConfig().createAuthorizationFilter(), CoreAdminApi.class);
+	}
+
+}

asie-api/src/test/java/com/inteligr8/alfresco/asie/AsieClientConfiguration.java

@@ -0,0 +1,54 @@
+package com.inteligr8.alfresco.asie;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.inteligr8.rs.AuthorizationFilter;
+import com.inteligr8.rs.ClientJerseyConfiguration;
+
+import jakarta.ws.rs.client.ClientRequestContext;
+
+public class AsieClientConfiguration implements ClientJerseyConfiguration {
+	
+	private Logger logger = LoggerFactory.getLogger(AsieClientConfiguration.class);
+	private String baseUrl = "http://locahost:8983/solr";
+	private String searchSecret = "alfresco-secret";
+	
+	@Override
+	public String getBaseUrl() {
+		return this.baseUrl;
+	}
+	
+	public AsieClientConfiguration withBaseUrl(String baseUrl) {
+		this.baseUrl = baseUrl;
+		return this;
+	}
+	
+	public AsieClientConfiguration withHostname(String hostname) {
+		this.baseUrl = "http://" + hostname + ":8983/solr";
+		return this;
+	}
+	
+	public AsieClientConfiguration withSearchSecret(String searchSecret) {
+		this.searchSecret = searchSecret;
+		return this;
+	}
+	
+	@Override
+	public AuthorizationFilter createAuthorizationFilter() {
+		if (this.searchSecret == null)
+			return null;
+		
+		return new AuthorizationFilter() {
+			@Override
+			public void filter(ClientRequestContext requestContext) throws IOException {
+				logger.trace("Adding ASIE secret for authorization ...");
+				requestContext.getHeaders().addAll("X-Alfresco-Search-Secret", Arrays.asList(searchSecret));
+			}
+		};
+	}
+
+}

asie-api/src/test/java/com/inteligr8/alfresco/asie/AssertionUtil.java

@@ -0,0 +1,27 @@
+package com.inteligr8.alfresco.asie;
+
+import org.junit.jupiter.api.Assertions;
+
+public class AssertionUtil {
+	
+	public static <T> T assertNotNull(T obj) {
+		Assertions.assertNotNull(obj);
+		return obj;
+	}
+	
+	public static <T> T assertNotNull(T obj, String message) {
+		Assertions.assertNotNull(obj, message);
+		return obj;
+	}
+	
+	public static void assertType(Object obj, Class<?> type) {
+		Assertions.assertNotNull(obj);
+		Assertions.assertEquals(type, obj.getClass());
+	}
+	
+	public static void assertType(Object obj, Class<?> type, String message) {
+		Assertions.assertNotNull(obj, message);
+		Assertions.assertEquals(type, obj.getClass(), message);
+	}
+
+}

asie-api/src/test/java/com/inteligr8/alfresco/asie/api/AbstractApiUnitTest.java

@@ -0,0 +1,23 @@
+package com.inteligr8.alfresco.asie.api;
+
+import java.net.MalformedURLException;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.inteligr8.alfresco.asie.AsieClient;
+
+public class AbstractApiUnitTest {
+	
+	protected Logger logger = LoggerFactory.getLogger(this.getClass());
+	
+	protected static AsieClient client;
+	protected static String defaultCore = "alfresco";
+	
+	@BeforeAll
+	private static void init() throws MalformedURLException {
+		client = new AsieClient("localhost");
+	}
+
+}

asie-api/src/test/java/com/inteligr8/alfresco/asie/api/CoreAdminReindexUnitTest.java

@@ -0,0 +1,34 @@
+package com.inteligr8.alfresco.asie.api;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import com.inteligr8.alfresco.asie.AssertionUtil;
+import com.inteligr8.alfresco.asie.model.ActionCoreResponse;
+import com.inteligr8.alfresco.asie.model.core.ReindexRequest;
+import com.inteligr8.solr.model.Action;
+import com.inteligr8.solr.model.Action.Status;
+import com.inteligr8.solr.model.Cores;
+import com.inteligr8.solr.model.ResponseHeader;
+
+public class CoreAdminReindexUnitTest extends AbstractApiUnitTest {
+	
+	@Test
+	public void reindex() {
+		CoreAdminApi api = client.getCoreAdminApi();
+		
+		ActionCoreResponse<Action> response = api.reindex(
+				new ReindexRequest()
+						.withCore(defaultCore));
+		Assertions.assertNotNull(response);
+		
+		ResponseHeader responseHeader = AssertionUtil.assertNotNull(response.getResponseHeader());
+		Assertions.assertEquals(0, responseHeader.getStatus());
+
+		Cores<Action> cores = AssertionUtil.assertNotNull(response.getCores());
+		Action action = AssertionUtil.assertNotNull(cores.getByCore(defaultCore));
+		
+		Assertions.assertEquals(Status.Scheduled, action.getStatus());
+	}
+
+}

asie-api/src/test/java/com/inteligr8/alfresco/asie/api/CoreAdminStatusUnitTest.java

@@ -0,0 +1,96 @@
+package com.inteligr8.alfresco.asie.api;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import com.inteligr8.alfresco.asie.AsieClient;
+import com.inteligr8.alfresco.asie.AssertionUtil;
+import com.inteligr8.alfresco.asie.model.core.Report;
+import com.inteligr8.alfresco.asie.model.core.ReportRequest;
+import com.inteligr8.alfresco.asie.model.core.ReportResponse;
+import com.inteligr8.alfresco.asie.model.core.Summary;
+import com.inteligr8.alfresco.asie.model.core.SummaryRequest;
+import com.inteligr8.alfresco.asie.model.core.SummaryResponse;
+import com.inteligr8.solr.model.CoreMetadata;
+import com.inteligr8.solr.model.Cores;
+import com.inteligr8.solr.model.ResponseHeader;
+import com.inteligr8.solr.model.core.StatusRequest;
+import com.inteligr8.solr.model.core.StatusResponse;
+
+import jakarta.ws.rs.ProcessingException;
+
+public class CoreAdminStatusUnitTest extends AbstractApiUnitTest {
+	
+	@Test
+	public void noHost() {
+		AsieClient client = new AsieClient("doesnotexist");
+		CoreAdminApi api = client.getCoreAdminApi();
+		
+		Assertions.assertThrows(ProcessingException.class, () -> {
+			api.getStatus(
+					new StatusRequest()
+							.withCore(defaultCore));
+		});
+	}
+	
+	@Test
+	public void summary() {
+		CoreAdminApi api = client.getCoreAdminApi();
+		
+		SummaryResponse response = api.getSummary(
+				new SummaryRequest()
+						.withCore(defaultCore));
+		Assertions.assertNotNull(response);
+		
+		ResponseHeader responseHeader = AssertionUtil.assertNotNull(response.getResponseHeader());
+		Assertions.assertEquals(0, responseHeader.getStatus());
+
+		Cores<Summary> cores = AssertionUtil.assertNotNull(response.getCores());
+		Summary summary = AssertionUtil.assertNotNull(cores.getByCore(defaultCore));
+		
+		AssertionUtil.assertType(summary.getByField("Active"), Boolean.class);
+		AssertionUtil.assertType(summary.getByField("Number of Searchers"), Integer.class);
+		AssertionUtil.assertType(summary.getByField("Last Index TX Commit Time"), Long.class);
+		AssertionUtil.assertType(summary.getByField("Last Index TX Commit Date"), String.class);
+	}
+	
+	@Test
+	public void status() {
+		CoreAdminApi api = client.getCoreAdminApi();
+		
+		StatusResponse response = api.getStatus(
+				new StatusRequest()
+						.withCore(defaultCore));
+		Assertions.assertNotNull(response);
+		
+		ResponseHeader responseHeader = AssertionUtil.assertNotNull(response.getResponseHeader());
+		Assertions.assertEquals(0, responseHeader.getStatus());
+
+		Cores<CoreMetadata> cores = AssertionUtil.assertNotNull(response.getCores());
+		CoreMetadata core = AssertionUtil.assertNotNull(cores.getByCore(defaultCore));
+		
+		Assertions.assertEquals(core, core.getName());
+		Assertions.assertNotNull(core.getStartDateTime());
+	}
+	
+	@Test
+	public void report() {
+		CoreAdminApi api = client.getCoreAdminApi();
+		
+		ReportResponse response = api.getReport(
+				new ReportRequest()
+						.withCore(defaultCore));
+		Assertions.assertNotNull(response);
+		
+		ResponseHeader responseHeader = AssertionUtil.assertNotNull(response.getResponseHeader());
+		Assertions.assertEquals(0, responseHeader.getStatus());
+
+		Cores<Report> cores = AssertionUtil.assertNotNull(response.getCores());
+		Report report = AssertionUtil.assertNotNull(cores.getByCore(defaultCore));
+		
+		AssertionUtil.assertType(report.getByField("Index error count"), Integer.class);
+		AssertionUtil.assertType(report.getByField("Last indexed transaction commit time"), Long.class);
+		AssertionUtil.assertType(report.getByField("Last indexed transaction commit date"), String.class);
+	}
+
+}

asie-api/src/test/resources/log4j2-test.properties

@@ -0,0 +1,23 @@
+rootLogger.level=trace
+rootLogger.appenderRef.stdout.ref=STDOUT
+
+logger.inteligr8-rs-request.name=jaxrs.request
+logger.inteligr8-rs-request.level=trace
+logger.inteligr8-rs-response.name=jaxrs.response
+logger.inteligr8-rs-response.level=off
+
+logger.this.name=com.inteligr8.alfresco.asie
+logger.this.level=trace
+
+# hide framework
+logger.apache-http.name=org.apache.http
+logger.apache-http.level=debug
+logger.jersey.name=org.glassfish.jersey
+logger.jersey.level=trace
+logger.jersey-client.name=org.glassfish.jersey.client
+logger.jersey-client.level=trace
+
+appender.stdout.type=Console
+appender.stdout.name=STDOUT
+appender.stdout.layout.type=PatternLayout
+appender.stdout.layout.pattern=%d{ABSOLUTE_MICROS} %level{length=1} %c{1}: %m%n

community-module/.gitignore

@@ -0,0 +1,12 @@
+# Maven
+target
+pom.xml.versionsBackup
+
+# Eclipse
+.project
+.classpath
+.settings
+.vscode
+
+# IDEA
+/.idea/

community-module/README.md

@@ -0,0 +1 @@
+# ASIE Platform Module Library

community-module/pom.xml

@@ -0,0 +1,106 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	
+	<parent>
+		<groupId>com.inteligr8.alfresco</groupId>
+		<artifactId>asie-platform-module-parent</artifactId>
+		<version>1.2.2</version>
+		<relativePath>../</relativePath>
+	</parent>
+
+	<artifactId>asie-community-platform-module</artifactId>
+	<packaging>jar</packaging>
+	
+	<name>ASIE Platform Module for ACS Community</name>
+
+	<properties>
+		<alfresco.sdk.version>4.9.0</alfresco.sdk.version>
+		<alfresco.platform.version>23.3.0</alfresco.platform.version>
+		<alfresco.platform.war.version>23.3.0.98</alfresco.platform.war.version>
+		<tomcat-rad.version>10-2.1</tomcat-rad.version>
+		
+		<beedk.rad.acs-search.enabled>true</beedk.rad.acs-search.enabled>
+	</properties>
+
+	<dependencyManagement>
+		<dependencies>
+			<dependency>
+				<groupId>org.alfresco</groupId>
+				<artifactId>acs-community-packaging</artifactId>
+				<version>${alfresco.platform.version}</version>
+				<type>pom</type>
+				<scope>import</scope>
+			</dependency>
+		</dependencies>
+	</dependencyManagement>
+
+	<dependencies>
+		<dependency>
+			<groupId>com.inteligr8.alfresco</groupId>
+			<artifactId>cachext-platform-module</artifactId>
+			<version>1.0-SNAPSHOT</version>
+		</dependency>
+		<dependency>
+			<groupId>com.inteligr8.alfresco</groupId>
+			<artifactId>asie-shared</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+		
+		<!-- Needed by this module, but provided by ACS -->
+		<dependency>
+			<groupId>org.alfresco</groupId>
+			<artifactId>alfresco-repository</artifactId>
+			<scope>provided</scope>
+		</dependency>
+		
+		<!-- Alfresco Modules required to use this module -->
+		<dependency>
+			<groupId>com.inteligr8.alfresco</groupId>
+			<artifactId>cxf-jaxrs-platform-module</artifactId>
+			<version>1.3.1-acs-v23.3</version>
+			<type>amp</type>
+		</dependency>
+
+		<!-- Including for testing purposes only -->
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.mockito</groupId>
+			<artifactId>mockito-core</artifactId>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>io.repaint.maven</groupId>
+				<artifactId>tiles-maven-plugin</artifactId>
+				<version>2.40</version>
+				<extensions>true</extensions>
+				<configuration>
+					<tiles>
+						<!-- Documentation: https://bitbucket.org/inteligr8/ootbee-beedk/src/stable/beedk-acs-search-rad-tile -->
+						<tile>com.inteligr8.ootbee:beedk-acs-search-rad-tile:[1.1.6,2.0.0)</tile>
+						<!-- Documentation: https://bitbucket.org/inteligr8/ootbee-beedk/src/stable/beedk-acs-platform-self-rad-tile -->
+						<tile>com.inteligr8.ootbee:beedk-acs-platform-self-rad-tile:[1.1.6,2.0.0)</tile>
+						<!-- Documentation: https://bitbucket.org/inteligr8/ootbee-beedk/src/stable/beedk-acs-platform-module-tile -->
+						<tile>com.inteligr8.ootbee:beedk-acs-platform-module-tile:[1.1.6,2.0.0)</tile>
+					</tiles>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+	
+	<repositories>
+		<repository>
+			<id>alfresco-public</id>
+			<url>https://artifacts.alfresco.com/nexus/content/groups/public</url>
+		</repository>
+	</repositories>
+</project>

community-module/rad.ps1

@@ -0,0 +1,74 @@
+
+function discoverArtifactId {
+	$script:ARTIFACT_ID=(mvn -q -Dexpression=project"."artifactId -DforceStdout help:evaluate)
+}
+
+function rebuild {
+	echo "Rebuilding project ..."
+	mvn process-classes
+}
+
+function start_ {
+	echo "Rebuilding project and starting Docker containers to support rapid application development ..."
+	mvn -Drad process-classes
+}
+
+function start_log {
+	echo "Rebuilding project and starting Docker containers to support rapid application development ..."
+	mvn -Drad "-Ddocker.showLogs" process-classes
+}
+
+function stop_ {
+	discoverArtifactId
+	echo "Stopping Docker containers that supported rapid application development ..."
+	docker container ls --filter name=${ARTIFACT_ID}-*
+	echo "Stopping containers ..."
+	docker container stop (docker container ls -q --filter name=${ARTIFACT_ID}-*)
+	echo "Removing containers ..."
+	docker container rm (docker container ls -aq --filter name=${ARTIFACT_ID}-*)
+}
+
+function tail_logs {
+	param (
+		$container
+	)
+	
+	discoverArtifactId
+	docker container logs -f (docker container ls -q --filter name=${ARTIFACT_ID}-${container})
+}
+
+function list {
+	discoverArtifactId
+	docker container ls --filter name=${ARTIFACT_ID}-*
+}
+
+switch ($args[0]) {
+	"start" {
+		start_
+	}
+	"start_log" {
+		start_log
+	}
+	"stop" {
+		stop_
+	}
+	"restart" {
+		stop_
+		start_
+	}
+	"rebuild" {
+		rebuild
+	}
+	"tail" {
+		tail_logs $args[1]
+	}
+	"containers" {
+		list
+	}
+	default {
+		echo "Usage: .\rad.ps1 [ start | start_log | stop | restart | rebuild | tail {container} | containers ]"
+	}
+}
+
+echo "Completed!"
+

community-module/rad.sh

@@ -0,0 +1,71 @@
+#!/bin/sh
+
+discoverArtifactId() {
+	ARTIFACT_ID=`mvn -q -Dexpression=project.artifactId -DforceStdout help:evaluate | sed 's/\x1B\[[0-9;]\{1,\}[A-Za-z]//g'`
+}
+
+rebuild() {
+	echo "Rebuilding project ..."
+	mvn process-test-classes
+}
+
+start() {
+	echo "Rebuilding project and starting Docker containers to support rapid application development ..."
+	mvn -Drad process-test-classes
+}
+
+start_log() {
+	echo "Rebuilding project and starting Docker containers to support rapid application development ..."
+	mvn -Drad -Ddocker.showLogs process-test-classes
+}
+
+stop() {
+	discoverArtifactId
+	echo "Stopping Docker containers that supported rapid application development ..."
+	docker container ls --filter name=${ARTIFACT_ID}-*
+	echo "Stopping containers ..."
+	docker container stop `docker container ls -q --filter name=${ARTIFACT_ID}-*`
+	echo "Removing containers ..."
+	docker container rm `docker container ls -aq --filter name=${ARTIFACT_ID}-*`
+}
+
+tail_logs() {
+	discoverArtifactId
+	docker container logs -f `docker container ls -q --filter name=${ARTIFACT_ID}-$1`
+}
+
+list() {
+	discoverArtifactId
+	docker container ls --filter name=${ARTIFACT_ID}-*
+}
+
+case "$1" in
+	start)
+		start
+		;;
+	start_log)
+		start_log
+		;;
+	stop)
+		stop
+		;;
+	restart)
+		stop
+		start
+		;;
+	rebuild)
+		rebuild
+		;;
+	tail)
+		tail_logs $2
+		;;
+	containers)
+		list
+		;;
+	*)
+		echo "Usage: ./rad.sh [ start | start_log | stop | restart | rebuild | tail {container} | containers ]"
+		exit 1
+esac
+
+echo "Completed!"
+

community-module/src/main/java/com/inteligr8/alfresco/asie/CommunityConstants.java

@@ -0,0 +1,23 @@
+package com.inteligr8.alfresco.asie;
+
+public interface CommunityConstants extends Constants {
+
+	static final String BEAN_SHARDSETS_CACHE = "asieShardsetsCache";
+	static final String BEAN_NODES_CACHE = "asieNodesCache";
+	static final String BEAN_SHARD_NODES_CACHE = "asieShardNodesCache";
+	static final String BEAN_SHARDINST_STATE_CACHE = "asieShardInstanceStateCache";
+	static final String BEAN_NODE_DISABLE_CACHE = "asieNodeDisabledCache";
+	static final String BEAN_NODE_UNAVAIL_CACHE = "asieNodeUnavailableCache";
+	static final String BEAN_SHARDINST_DISABLE_CACHE = "asieShardInstanceDisabledCache";
+	static final String BEAN_SHARDINST_UNAVAIL_CACHE = "asieShardInstanceUnavailableCache";
+	static final String BEAN_CORE_EXPLICIT_CACHE = "asieCoreExplicitCache";
+
+	static final String ATTR_ASIE_SHARDSET = "inteligr8.asie.shardSet";
+	static final String ATTR_ASIE_NODE = "inteligr8.asie.node";
+	static final String ATTR_ASIE_SHARD_NODES = "inteligr8.asie.shard.nodes";
+	static final String ATTR_ASIE_SHARD_NODE = "inteligr8.asie.shard.node";
+	static final String ATTR_OBJECT = "object";
+	static final String ATTR_DISABLE = "disabled";
+	static final String ATTR_NODES = "nodes";
+
+}

community-module/src/main/java/com/inteligr8/alfresco/asie/compute/CmisQueryInspector.java

@@ -0,0 +1,50 @@
+package com.inteligr8.alfresco.asie.compute;
+
+import java.util.List;
+import java.util.Set;
+
+import org.alfresco.repo.search.impl.parsers.CMISLexer;
+import org.alfresco.repo.search.impl.parsers.CMISParser;
+import org.alfresco.service.cmr.search.SearchParameters.Operator;
+import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
+import org.alfresco.service.cmr.search.SearchService;
+import org.alfresco.service.namespace.QName;
+import org.antlr.runtime.ANTLRStringStream;
+import org.antlr.runtime.CharStream;
+import org.antlr.runtime.CommonTokenStream;
+import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.tree.CommonTree;
+import org.antlr.runtime.tree.Tree;
+import org.apache.commons.collections4.SetUtils;
+import org.springframework.stereotype.Component;
+
+@Component
+public class CmisQueryInspector implements QueryInspector {
+	
+	private Set<String> supportedLanguages = SetUtils.unmodifiableSet(
+			SearchService.LANGUAGE_CMIS_ALFRESCO,
+			SearchService.LANGUAGE_CMIS_STRICT,
+			SearchService.LANGUAGE_INDEX_CMIS,
+			SearchService.LANGUAGE_SOLR_CMIS);
+	
+	@Override
+	public Set<String> getSupportedLanguages() {
+		return this.supportedLanguages;
+	}
+	
+	@Override
+	public List<QueryValue> findRequiredPropertyValues(String query, Operator defaultOperator, QName property, DataTypeDefinition dataTypeDef) throws RecognitionException {
+		Tree tree = this.parseCmis(query, defaultOperator);
+		throw new UnsupportedOperationException();
+	}
+	
+	protected Tree parseCmis(String cmisQuery, Operator defaultOperator) throws RecognitionException {
+	    CharStream cs = new ANTLRStringStream(cmisQuery);
+	    CMISLexer lexer = new CMISLexer(cs);
+	    CommonTokenStream tokens = new CommonTokenStream(lexer);
+	    CMISParser parser = new CMISParser(tokens);
+	    CommonTree tree = (CommonTree) parser.query().getTree();
+	    return tree;
+	}
+
+}

community-module/src/main/java/com/inteligr8/alfresco/asie/compute/FtsQueryInspector.java

@@ -0,0 +1,290 @@
+package com.inteligr8.alfresco.asie.compute;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.Period;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+import org.alfresco.repo.search.impl.parsers.FTSLexer;
+import org.alfresco.repo.search.impl.parsers.FTSParser;
+import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
+import org.alfresco.service.cmr.repository.AssociationRef;
+import org.alfresco.service.cmr.repository.ChildAssociationRef;
+import org.alfresco.service.cmr.repository.NodeRef;
+import org.alfresco.service.cmr.search.SearchParameters.Operator;
+import org.alfresco.service.cmr.search.SearchService;
+import org.alfresco.service.namespace.NamespaceService;
+import org.alfresco.service.namespace.QName;
+import org.antlr.runtime.ANTLRStringStream;
+import org.antlr.runtime.CharStream;
+import org.antlr.runtime.CommonTokenStream;
+import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.tree.CommonTree;
+import org.antlr.runtime.tree.Tree;
+import org.apache.commons.collections4.SetUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class FtsQueryInspector implements QueryInspector {
+	
+	private final Logger logger = LoggerFactory.getLogger(FtsQueryInspector.class);
+	
+	private final Set<String> supportedLanguages = SetUtils.unmodifiableSet(
+			SearchService.LANGUAGE_FTS_ALFRESCO,
+			SearchService.LANGUAGE_INDEX_FTS_ALFRESCO,
+			SearchService.LANGUAGE_SOLR_FTS_ALFRESCO,
+			SearchService.LANGUAGE_LUCENE);
+	
+	@Autowired
+	private NamespaceService namespaceService;
+	
+	@Override
+	public Set<String> getSupportedLanguages() {
+		return this.supportedLanguages;
+	}
+	
+	@Override
+	public List<QueryValue> findRequiredPropertyValues(String ftsQuery, Operator defaultOperator, QName property, DataTypeDefinition dataTypeDef) throws RecognitionException {
+		Tree tree = this.parseFts(ftsQuery, defaultOperator);
+		tree = this.bypassSingleTermDisjunctions(tree);
+		if (tree == null)
+			return null;
+		
+		Collection<Tree> trees = this.extractRequiredTerms(tree);
+		this.logger.trace("Found {} required terms in query: {}", trees.size(), ftsQuery);
+		this.filterPropertyTerms(trees, property);
+		this.logger.trace("Found {} required terms for property {} in query: {}", trees.size(), property, ftsQuery);
+		this.filterOutFuzzyTerms(trees);
+		this.logger.trace("Found {} required definitive terms for property {} in query: {}", trees.size(), property, ftsQuery);
+
+		List<QueryValue> values = new ArrayList<>(trees.size());
+		for (Tree t : trees)
+			values.add(this.extractValue(t, dataTypeDef));
+		return values;
+	}
+	
+	protected Tree parseFts(String ftsQuery, Operator defaultOperator) throws RecognitionException {
+	    CharStream cs = new ANTLRStringStream(ftsQuery);
+	    FTSLexer lexer = new FTSLexer(cs);
+	    CommonTokenStream tokens = new CommonTokenStream(lexer);
+	    FTSParser parser = new FTSParser(tokens);
+	    parser.setDefaultFieldConjunction(defaultOperator.equals(Operator.AND));
+	    parser.setMode(defaultOperator.equals(Operator.AND) ? FTSParser.Mode.DEFAULT_CONJUNCTION : FTSParser.Mode.DEFAULT_DISJUNCTION);
+	    CommonTree tree = (CommonTree) parser.ftsQuery().getTree();
+	    return tree;
+	}
+	
+	protected Tree bypassSingleTermDisjunctions(Tree tree) {
+		while ("DISJUNCTION".equals(tree.getText()) && tree.getChildCount() == 1)
+			tree = tree.getChild(0);
+		if ("DISJUNCTION".equals(tree.getText()))
+			return null;
+		return tree;
+	}
+	
+	protected Collection<Tree> extractRequiredTerms(Tree tree) {
+		while ("DISJUNCTION".equals(tree.getText()) && tree.getChildCount() == 1)
+			tree = tree.getChild(0);
+
+		List<Tree> terms = new LinkedList<>();
+		
+		switch (tree.getText()) {
+			case "DISJUNCTION":
+				break;
+			case "CONJUNCTION":
+				for (int c = 0; c < tree.getChildCount(); c++) {
+					Collection<Tree> subtrees = this.extractRequiredTerms(tree.getChild(c));
+					if (subtrees == null || subtrees.isEmpty())
+						continue;
+					terms.addAll(subtrees);
+				}
+				break;
+			case "DEFAULT":
+				terms.add(tree);
+				break;
+			default:
+				this.logger.warn("Unexpected/unsupported tree: {}", tree.getText());
+		}
+		
+		return terms;
+	}
+	
+	protected Collection<Tree> filterPropertyTerms(Collection<Tree> trees, QName property) {
+		if (trees.isEmpty())
+			return trees;
+		
+		Set<String> prefixes = new HashSet<>(this.namespaceService.getPrefixes(property.getNamespaceURI()));
+		if (prefixes.isEmpty()) {
+			this.logger.warn("Unexpected/unsupported namespace: {}", property.getNamespaceURI());
+			trees.clear();
+			return trees;
+		}
+		
+		Iterator<Tree> i = trees.iterator();
+		
+		while (i.hasNext()) {
+			Tree tree = i.next();
+			
+			if ("DEFAULT".equals(tree.getText()))
+				tree = tree.getChild(0);
+			
+			int skip = -1;
+			switch (tree.getText()) {
+				case "TERM":
+				case "PHRASE":
+				case "EXACT_TERM":
+				case "EXACT_PHRASE":
+					skip = 1; // skip the value child
+					break;
+				case "RANGE":
+					skip = 4; // skip the inclusive, start, end, inclusive children
+					break;
+				default:
+			}
+			
+			if (skip >= 0) {
+				Tree fieldRef = tree.getChild(skip);
+				if (!"FIELD_REF".equals(fieldRef.getText())) {
+					this.logger.warn("Unexpected/unsupported tree: {}", tree.getText());
+				} else if (!fieldRef.getChild(0).getText().equals(property.getLocalName())) {
+					this.logger.trace("Found but ignoring property: {}", fieldRef.getChild(0).getText());
+				} else {
+					Tree prefix = fieldRef.getChild(1);
+					if (!"PREFIX".equals(prefix.getText())) {
+						this.logger.warn("Unexpected/unsupported tree: {}", tree.getText());
+					} else if (!prefixes.contains(prefix.getChild(0).getText())) {
+						this.logger.trace("Found but ignoring property: {}:{}", prefix.getChild(0).getText(), property.getLocalName());
+					} else {
+						// this will skip the remove()
+						continue;
+					}
+				}
+			}
+
+			i.remove();
+		}
+		
+		return trees;
+	}
+	
+	protected Collection<Tree> filterOutFuzzyTerms(Collection<Tree> trees) {
+		if (trees.isEmpty())
+			return trees;
+		
+		Iterator<Tree> i = trees.iterator();
+		
+		while (i.hasNext()) {
+			Tree tree = i.next();
+			
+			if ("DEFAULT".equals(tree.getText()))
+				tree = tree.getChild(0);
+			
+			switch (tree.getText()) {
+				case "EXACT_TERM":
+				case "EXACT_PHRASE":
+				case "RANGE":
+					break;
+				default:
+					i.remove();
+			}
+		}
+		
+		return trees;
+	}
+	
+	protected QueryValue extractValue(Tree tree, DataTypeDefinition dataTypeDef) {
+		if ("DEFAULT".equals(tree.getText()))
+			tree = tree.getChild(0);
+
+		switch (tree.getText()) {
+			case "RANGE":
+				return this.extractRangeValue(tree, dataTypeDef);
+			default:
+		}
+
+		String value = this.unquote(tree.getChild(0).getText());
+
+		switch (dataTypeDef.getName().getLocalName()) {
+			case "boolean":
+				return new QuerySingleValue<Boolean>(Boolean.parseBoolean(value));
+			case "double":
+				return new QuerySingleValue<Double>(Double.parseDouble(value));
+			case "float":
+				return new QuerySingleValue<Float>(Float.parseFloat(value));
+			case "int":
+				return new QuerySingleValue<Integer>(Integer.parseInt(value));
+			case "long":
+				return new QuerySingleValue<Long>(Long.parseLong(value));
+			case "date":
+				return new QuerySingleValue<LocalDate>(this.evaluateAsDate(value));
+			case "datetime":
+				return new QuerySingleValue<LocalDateTime>(this.evaluateAsDateTime(value));
+			case "period":
+				return new QuerySingleValue<Period>(Period.parse(value));
+			case "qname":
+				return new QuerySingleValue<QName>(QName.createQName(value, this.namespaceService));
+			case "noderef":
+				return new QuerySingleValue<NodeRef>(new NodeRef(value));
+			case "childassocref":
+				return new QuerySingleValue<ChildAssociationRef>(new ChildAssociationRef(value));
+			case "assocref":
+				return new QuerySingleValue<AssociationRef>(new AssociationRef(value));
+			case "locale":
+				return new QuerySingleValue<Locale>(new Locale(value));
+			default:
+				return new QuerySingleValue<String>(value);
+		}
+	}
+	
+	protected QueryRangeValue<?> extractRangeValue(Tree tree, DataTypeDefinition dataTypeDef) {
+		boolean includeStart = "INCLUSIVE".equals(tree.getChild(0).getText());
+		String start = this.unquote(tree.getChild(1).getText());
+		String end = this.unquote(tree.getChild(2).getText());
+		boolean includeEnd = "INCLUSIVE".equals(tree.getChild(3).getText());
+		
+		switch (dataTypeDef.getName().getLocalName()) {
+			case "double":
+				return new QueryRangeValue<Double>(includeStart, Double.parseDouble(start), includeEnd, Double.parseDouble(end));
+			case "float":
+				return new QueryRangeValue<Float>(includeStart, Float.parseFloat(start), includeEnd, Float.parseFloat(end));
+			case "int":
+				return new QueryRangeValue<Integer>(includeStart, Integer.parseInt(start), includeEnd, Integer.parseInt(end));
+			case "long":
+				return new QueryRangeValue<Long>(includeStart, Long.parseLong(start), includeEnd, Long.parseLong(end));
+			case "date":
+				return new QueryRangeValue<LocalDate>(includeStart, this.evaluateAsDate(start), includeEnd, this.evaluateAsDate(end));
+			case "datetime":
+				return new QueryRangeValue<LocalDateTime>(includeStart, this.evaluateAsDateTime(start), includeEnd, this.evaluateAsDateTime(end));
+			default:
+				throw new UnsupportedOperationException("The data type does not make sense for range evaluation: " + dataTypeDef.getName());
+		}
+	}
+	
+	protected LocalDate evaluateAsDate(String str) {
+		if ("now".equalsIgnoreCase(str)) return LocalDate.now();
+		else return LocalDate.parse(str);
+	}
+	
+	protected LocalDateTime evaluateAsDateTime(String str) {
+		if ("now".equalsIgnoreCase(str)) return LocalDateTime.now();
+		else return LocalDateTime.parse(str);
+	}
+	
+	protected String unquote(String str) {
+		if (str.length() < 2) return str;
+		else if (str.charAt(0) == '\'' && str.charAt(str.length()-1) == '\'') return str.substring(1, str.length()-1);
+		else if (str.charAt(0) == '\"' && str.charAt(str.length()-1) == '\"') return str.substring(1, str.length()-1);
+		else return str;
+	}
+
+}

community-module/src/main/java/com/inteligr8/alfresco/asie/compute/QueryInspector.java

@@ -0,0 +1,74 @@
+package com.inteligr8.alfresco.asie.compute;
+
+import java.util.List;
+import java.util.Set;
+
+import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
+import org.alfresco.service.cmr.search.SearchParameters.Operator;
+import org.alfresco.service.namespace.QName;
+import org.antlr.runtime.RecognitionException;
+
+public interface QueryInspector {
+	
+	Set<String> getSupportedLanguages();
+	
+	List<QueryValue> findRequiredPropertyValues(String query, Operator defaultOperator, QName property, DataTypeDefinition dataTypeDef) throws RecognitionException;
+	
+	
+	
+	public interface QueryValue {
+		
+	}
+	
+	public class QuerySingleValue<T> implements QueryValue {
+		
+		private T value;
+		
+		public QuerySingleValue(T value) {
+			this.value = value;
+		}
+		
+		public T getValue() {
+			return value;
+		}
+		
+		@Override
+		public String toString() {
+			return this.value.toString();
+		}
+		
+	}
+	
+	public class QueryRangeValue<T> implements QueryValue {
+		
+		private boolean includeStart;
+		private T start;
+		private boolean includeEnd;
+		private T end;
+		
+		public QueryRangeValue(boolean includeStart, T start, boolean includeEnd, T end) {
+			this.includeStart = includeStart;
+			this.start = start;
+			this.includeEnd = includeEnd;
+			this.end = end;
+		}
+		
+		public boolean isIncludeStart() {
+			return includeStart;
+		}
+		
+		public boolean isIncludeEnd() {
+			return includeEnd;
+		}
+		
+		public T getStart() {
+			return start;
+		}
+		
+		public T getEnd() {
+			return end;
+		}
+		
+	}
+
+}

community-module/src/main/java/com/inteligr8/alfresco/asie/compute/QueryInspectorFactory.java

@@ -0,0 +1,32 @@
+package com.inteligr8.alfresco.asie.compute;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.alfresco.service.cmr.search.SearchParameters;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class QueryInspectorFactory implements InitializingBean {
+	
+	@Autowired
+	private List<QueryInspector> inspectors;
+	
+	private Map<String, QueryInspector> languageInspectorMap = new HashMap<>();
+	
+	@Override
+	public void afterPropertiesSet() throws Exception {
+		for (QueryInspector inspector : this.inspectors) {
+			for (String language : inspector.getSupportedLanguages())
+				this.languageInspectorMap.put(language, inspector);
+		}
+	}
+	
+	public QueryInspector selectQueryInspector(SearchParameters searchParams) {
+		return this.languageInspectorMap.get(searchParams.getLanguage());
+	}
+
+}

community-module/src/main/java/com/inteligr8/alfresco/asie/provider/ShardRegistryProvider.java

@@ -0,0 +1,28 @@
+package com.inteligr8.alfresco.asie.provider;
+
+import org.alfresco.repo.index.shard.ShardRegistry;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Scope;
+
+import com.inteligr8.alfresco.asie.Constants;
+
+@Configuration
+public class ShardRegistryProvider extends AbstractProvider<ShardRegistry> {
+	
+	/**
+	 * This allows for the selection of the primary or first ShardRegistry
+	 * registered in the Spring BeanFactory.
+	 * 
+	 * @return A ShardRegistry.
+	 */
+	@Bean(Constants.BEAN_SHARD_REGISTRY)
+	@Qualifier(Constants.QUALIFIER_ASIE)
+	@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
+	public ShardRegistry selectBean() {
+		return this.getPrimary(ShardRegistry.class);
+	}
+
+}

community-module/src/main/java/com/inteligr8/alfresco/asie/service/ShardDiscoveryService.java

@@ -0,0 +1,240 @@
+package com.inteligr8.alfresco.asie.service;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.alfresco.repo.cache.SimpleCache;
+import org.alfresco.repo.index.shard.ShardMethodEnum;
+import org.alfresco.service.namespace.QName;
+import org.alfresco.util.Pair;
+import org.alfresco.util.collections.CollectionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+
+import com.inteligr8.alfresco.asie.CommunityConstants;
+import com.inteligr8.alfresco.asie.model.Shard;
+import com.inteligr8.alfresco.asie.model.ShardInstance;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.cachext.CollectionCache;
+import com.inteligr8.alfresco.cachext.MultiValueCache;
+
+@Component
+public class ShardDiscoveryService implements com.inteligr8.alfresco.asie.spi.ShardDiscoveryService {
+	
+	private final Logger logger = LoggerFactory.getLogger(this.getClass());
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_SHARDSETS_CACHE)
+	private SimpleCache<String, ShardSet> shardsetsCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_NODES_CACHE)
+	private SimpleCache<String, SolrHost> nodesCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_SHARD_NODES_CACHE)
+	private MultiValueCache<Shard, SolrHost> shardNodesCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_SHARDINST_STATE_CACHE)
+	private SimpleCache<ShardInstance, ShardInstanceState> shardInstanceStatesCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_NODE_UNAVAIL_CACHE)
+	private CollectionCache<SolrHost, HashSet<SolrHost>> nodeUnavailableCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_NODE_DISABLE_CACHE)
+	private CollectionCache<SolrHost, HashSet<SolrHost>> nodeDisableCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_SHARDINST_UNAVAIL_CACHE)
+	private CollectionCache<ShardInstance, HashSet<ShardInstance>> shardInstanceUnavailableCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_SHARDINST_DISABLE_CACHE)
+	private CollectionCache<ShardInstance, HashSet<ShardInstance>> shardInstanceDisableCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_CORE_EXPLICIT_CACHE)
+	private SimpleCache<String, QName> coreExplicitIdCache;
+	
+	@Override
+	public ShardSet findSetByCore(String core) {
+		return this.shardsetsCache.get(core);
+	}
+	
+	@Override
+	public SolrHost findNode(String nodeHostname, int nodePort) {
+    	Map<String, InetAddress> resolvedAddresses = new HashMap<>();
+    	
+		for (String nodeSpec : this.nodesCache.getKeys()) {
+			SolrHost node = this.nodesCache.get(nodeSpec);
+
+			if (!nodeHostname.equalsIgnoreCase(node.getHostname())) {
+				if (!resolvedAddresses.containsKey(nodeHostname))
+					resolvedAddresses.put(nodeHostname, this.resolve(nodeHostname));
+				InetAddress nodeAddress = resolvedAddresses.get(nodeHostname);
+		    	this.logger.trace("Resolved: {} => {}", nodeHostname, nodeAddress);
+				if (nodeAddress == null)
+					continue;
+
+				if (!resolvedAddresses.containsKey(node.getHostname()))
+					resolvedAddresses.put(node.getHostname(), this.resolve(node.getHostname()));
+				InetAddress shardInstanceAddress = resolvedAddresses.get(node.getHostname());
+		    	this.logger.trace("Resolved: {} => {}", node.getHostname(), shardInstanceAddress);
+				if (!nodeAddress.equals(shardInstanceAddress))
+					continue;
+			}
+
+			if (nodePort == node.getPort()) {
+		    	this.logger.debug("Found node: {}", node);
+				return node;
+			}
+		}
+		
+		return null;
+	}
+    
+    private InetAddress resolve(String hostname) {
+    	try {
+    		return InetAddress.getByName(hostname);
+    	} catch (UnknownHostException uhe) {
+    		return null;
+    	}
+    }
+	
+	@Override
+	public Map<ShardSet, Map<Integer, ShardInstanceState>> findByNode(SolrHost node) {
+		Map<ShardSet, Map<Integer, ShardInstanceState>> response = new HashMap<>();
+		
+		for (Shard shard : this.shardNodesCache.getKeys()) {
+			ShardSet shardSet = this.shardsetsCache.get(shard.extractShardSetCore());
+			
+			if (this.shardNodesCache.contains(shard, node)) {
+				ShardInstance shardNode = ShardInstance.from(shard, node);
+				ShardInstanceState state = this.shardInstanceStatesCache.get(shardNode);
+
+				Map<Integer, ShardInstanceState> shards = response.get(shardSet);
+				if (shards == null)
+					response.put(shardSet, shards = new HashMap<>());
+				shards.put(shard.extractShardId(), state);
+			}
+		}
+		
+		return response;
+	}
+	
+	@Override
+	public Set<ShardSet> findSetsByShardMethod(ShardMethodEnum... shardMethods) {
+		Set<ShardSet> shardSets = new HashSet<>();
+		
+		Set<ShardMethodEnum> methods = CollectionUtils.asSet(shardMethods);
+		for (String core : this.shardsetsCache.getKeys()) {
+			ShardSet shardSet = this.shardsetsCache.get(core);
+			if (methods.contains(shardSet.getMethod()))
+				shardSets.add(shardSet);
+		}
+		
+		return shardSets;
+	}
+	
+	@Override
+	public Set<SolrHost> findNodes(ShardSet shardSet) {
+		Set<SolrHost> nodes = new HashSet<>();
+		
+		for (Shard shard : this.shardNodesCache.getKeys()) {
+			if (shardSet.getCore().equals(shard.extractShardSetCore()))
+				nodes.addAll(this.shardNodesCache.get(shard));
+		}
+		
+		return nodes;
+	}
+	
+	@Override
+	public Set<SolrHost> findNodesByShard(ShardSet shardSet, int shardId) {
+		Set<SolrHost> nodes = new HashSet<>();
+		
+		for (Shard shard : this.shardNodesCache.getKeys()) {
+			if (shardSet.getCore().equals(shard.extractShardSetCore()) && shardId == shard.extractShardId())
+				nodes.addAll(this.shardNodesCache.get(shard));
+		}
+		
+		return nodes;
+	}
+	
+	@Override
+	public Map<Integer, Pair<SolrHost, ShardInstanceState>> findLatestNodeStates(ShardSet shardSet) {
+		Map<Integer, Pair<SolrHost, ShardInstanceState>> response = new HashMap<>();
+		
+		for (Shard shard : this.shardNodesCache.getKeys()) {
+			if (!shardSet.getCore().equals(shard.extractShardSetCore()))
+				continue;
+			
+			SolrHost latestNode = null;
+			ShardInstanceState latestState = null;
+			
+			for (SolrHost node : this.shardNodesCache.get(shard)) {
+				ShardInstance shardNode = ShardInstance.from(shard, node);
+				ShardInstanceState state = this.shardInstanceStatesCache.get(shardNode);
+				if (latestState == null || state.compareTo(latestState) < 0) {
+					latestState = state;
+					latestNode = node;
+				}
+			}
+
+			if (latestNode != null)
+				response.put(shard.extractShardId(), new Pair<>(latestNode, latestState));
+		}
+		
+		return response;
+	}
+	
+	@Override
+	public List<Pair<SolrHost, ShardInstanceState>> findNodeStatesByShard(ShardSet shardSet, int shardId) {
+		List<Pair<SolrHost, ShardInstanceState>> response = new LinkedList<>();
+		
+		for (Shard shard : this.shardNodesCache.getKeys()) {
+			if (!shardSet.getCore().equals(shard.extractShardSetCore()))
+				continue;
+			
+			for (SolrHost node : this.shardNodesCache.get(shard)) {
+				ShardInstance shardNode = ShardInstance.from(shard, node);
+				ShardInstanceState state = this.shardInstanceStatesCache.get(shardNode);
+				response.add(new Pair<>(node, state));
+			}
+		}
+		
+		return response;
+	}
+	
+	@Override
+	public Set<Integer> findIdsByNode(ShardSet shardSet, SolrHost node) {
+		Set<Integer> shardIds = new HashSet<>();
+		
+		for (Shard shard : this.shardNodesCache.getKeys()) {
+			if (shardSet.getCore().equals(shard.extractShardSetCore()) && this.shardNodesCache.contains(shard, node))
+				shardIds.add(shard.extractShardId());
+		}
+		
+		return shardIds;
+	}
+	
+	@Override
+	public Map<Integer, ShardInstanceState> findStatesByNode(ShardSet shardSet, SolrHost node) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+}

community-module/src/main/java/com/inteligr8/alfresco/asie/service/ShardStateService.java

@@ -0,0 +1,25 @@
+package com.inteligr8.alfresco.asie.service;
+
+import org.alfresco.service.cmr.attributes.AttributeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+
+import com.inteligr8.alfresco.asie.Constants;
+
+@Component
+public class ShardStateService implements com.inteligr8.alfresco.asie.spi.ShardStateService {
+	
+	@Autowired
+	@Qualifier(Constants.QUALIFIER_ASIE)
+	private AttributeService attrService;
+	
+	@Autowired
+	private SolrShardRegistry shardRegistry;
+	
+	@Override
+	public void clear() {
+		this.shardRegistry.purge();
+	}
+
+}

community-module/src/main/java/com/inteligr8/alfresco/asie/service/SolrShardRegistry.java

@@ -0,0 +1,628 @@
+package com.inteligr8.alfresco.asie.service;
+
+import java.io.Serializable;
+import java.time.OffsetDateTime;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.OptionalInt;
+import java.util.Random;
+import java.util.Set;
+
+import org.alfresco.repo.cache.SimpleCache;
+import org.alfresco.repo.index.shard.Floc;
+import org.alfresco.repo.index.shard.ShardState;
+import org.alfresco.repo.lock.JobLockService;
+import org.alfresco.service.cmr.attributes.AttributeService;
+import org.alfresco.service.cmr.attributes.AttributeService.AttributeQueryCallback;
+import org.alfresco.service.cmr.dictionary.DataTypeDefinition;
+import org.alfresco.service.cmr.dictionary.DictionaryService;
+import org.alfresco.service.cmr.search.SearchParameters;
+import org.alfresco.service.namespace.NamespaceService;
+import org.alfresco.service.namespace.QName;
+import org.antlr.runtime.RecognitionException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.ApplicationEvent;
+import org.springframework.context.annotation.Primary;
+import org.springframework.extensions.surf.util.AbstractLifecycleBean;
+import org.springframework.stereotype.Component;
+
+import com.inteligr8.alfresco.asie.CommunityConstants;
+import com.inteligr8.alfresco.asie.Constants;
+import com.inteligr8.alfresco.asie.compute.QueryInspector;
+import com.inteligr8.alfresco.asie.compute.QueryInspector.QueryRangeValue;
+import com.inteligr8.alfresco.asie.compute.QueryInspector.QuerySingleValue;
+import com.inteligr8.alfresco.asie.compute.QueryInspector.QueryValue;
+import com.inteligr8.alfresco.asie.compute.QueryInspectorFactory;
+import com.inteligr8.alfresco.asie.model.Shard;
+import com.inteligr8.alfresco.asie.model.ShardInstance;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.spi.ShardRegistry;
+import com.inteligr8.alfresco.cachext.CollectionCache;
+import com.inteligr8.alfresco.cachext.MultiValueCache;
+
+@Component
+@Primary
+public class SolrShardRegistry extends AbstractLifecycleBean implements ShardRegistry {
+	
+	private final Logger logger = LoggerFactory.getLogger(this.getClass());
+	private final Random random = new Random();
+	private final QName shardLock = QName.createQName(Constants.NAMESPACE_ASIE, "shardLock");
+	
+	@Autowired
+	@Qualifier(Constants.QUALIFIER_ASIE)
+	private AttributeService attrService;
+	
+	@Autowired
+	private NamespaceService namespaceService;
+	
+	@Autowired
+	private DictionaryService dictionaryService;
+	
+	@Autowired
+	private QueryInspectorFactory queryInspectorFactory;
+	
+	@Autowired
+	private JobLockService jobLockService;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_SHARDSETS_CACHE)
+	private SimpleCache<String, ShardSet> shardsetsCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_NODES_CACHE)
+	private SimpleCache<String, SolrHost> nodesCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_SHARD_NODES_CACHE)
+	private MultiValueCache<Shard, SolrHost> shardNodesCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_SHARDINST_STATE_CACHE)
+	private SimpleCache<ShardInstance, ShardInstanceState> shardInstanceStatesCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_NODE_UNAVAIL_CACHE)
+	private CollectionCache<SolrHost, HashSet<SolrHost>> nodeUnavailableCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_NODE_DISABLE_CACHE)
+	private CollectionCache<SolrHost, HashSet<SolrHost>> nodeDisableCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_SHARDINST_UNAVAIL_CACHE)
+	private CollectionCache<ShardInstance, HashSet<ShardInstance>> shardInstanceUnavailableCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_SHARDINST_DISABLE_CACHE)
+	private CollectionCache<ShardInstance, HashSet<ShardInstance>> shardInstanceDisableCache;
+	
+	@Autowired
+	@Qualifier(CommunityConstants.BEAN_CORE_EXPLICIT_CACHE)
+	private SimpleCache<String, QName> coreExplicitIdCache;
+	
+	@Value("${inteligr8.asie.registerUnknownShardDisabled}")
+	private boolean registerDisabled;
+	
+	@Value("${inteligr8.asie.offlineIdleShardInSeconds}")
+	private int offlineIdleShardInSeconds;
+	
+	@Value("${inteligr8.asie.forgetOfflineShardInSeconds}")
+	private int forgetOfflineShardInSeconds;
+	
+	@Override
+	protected void onBootstrap(ApplicationEvent event) {
+		this.loadPersistedToCache();
+	}
+	
+	@Override
+	protected void onShutdown(ApplicationEvent event) {
+	}
+
+	protected void loadPersistedToCache() {
+		String lockId = this.jobLockService.getLock(this.shardLock, 2500L, 500L, 10);
+		try {
+			this.attrService.getAttributes(new AttributeQueryCallback() {
+				@Override
+				public boolean handleAttribute(Long id, Serializable value, Serializable[] keys) {
+					String core = (String) keys[1];
+					if (!shardsetsCache.contains(core)) {
+						ShardSet shardSet = (ShardSet) value;
+						shardsetsCache.put(core, shardSet);
+						
+						switch (shardSet.getMethod()) {
+							case EXPLICIT_ID:
+								cacheExplicitShard(shardSet, false);
+								break;
+							default:
+						}
+					}
+					return true;
+				}
+			}, CommunityConstants.ATTR_ASIE_SHARDSET);
+
+			this.attrService.getAttributes(new AttributeQueryCallback() {
+				@Override
+				public boolean handleAttribute(Long id, Serializable value, Serializable[] keys) {
+					String nodeSpec = (String) keys[2];
+					SolrHost node = (SolrHost) value;
+					if (!nodesCache.contains(nodeSpec))
+						nodesCache.put(nodeSpec, node);
+					if (Boolean.TRUE.equals(attrService.getAttribute(CommunityConstants.ATTR_ASIE_NODE, CommunityConstants.ATTR_DISABLE, nodeSpec))) {
+						if (!nodeDisableCache.contains(node))
+							nodeDisableCache.add(node);
+					} else if (nodeDisableCache.contains(node)) {
+						nodeDisableCache.remove(node);
+					}
+					return true;
+				}
+			}, CommunityConstants.ATTR_ASIE_NODE, CommunityConstants.ATTR_OBJECT);
+
+			this.attrService.getAttributes(new AttributeQueryCallback() {
+				@Override
+				public boolean handleAttribute(Long id, Serializable value, Serializable[] keys) {
+					Shard shard = (Shard) keys[1];
+					SolrHost node = (SolrHost) keys[2];
+					if (!shardNodesCache.contains(shard, node))
+						shardNodesCache.add(shard, node);
+					return true;
+				}
+			}, CommunityConstants.ATTR_ASIE_SHARD_NODES);
+
+			this.attrService.getAttributes(new AttributeQueryCallback() {
+				@Override
+				public boolean handleAttribute(Long id, Serializable value, Serializable[] keys) {
+					ShardInstance shardNode = (ShardInstance) keys[2];
+					ShardInstanceState state = (ShardInstanceState) value;
+					if (!shardInstanceStatesCache.contains(shardNode))
+						shardInstanceStatesCache.put(shardNode, state);
+					if (Boolean.TRUE.equals(attrService.getAttribute(CommunityConstants.ATTR_ASIE_SHARD_NODE, CommunityConstants.ATTR_DISABLE, shardNode))) {
+						if (!shardInstanceDisableCache.contains(shardNode))
+							shardInstanceDisableCache.add(shardNode);
+					} else if (shardInstanceDisableCache.contains(shardNode)) {
+						shardInstanceDisableCache.remove(shardNode);
+					}
+					return true;
+				}
+			}, CommunityConstants.ATTR_ASIE_NODE, CommunityConstants.ATTR_OBJECT);
+		} finally {
+			this.jobLockService.releaseLock(lockId, this.shardLock);
+		}
+	}
+	
+	private void cacheExplicitShard(ShardSet shardSet, boolean overwrite) {
+		if (overwrite || !this.coreExplicitIdCache.contains(shardSet.getCore())) {
+			String property = shardSet.getPrefixedProperty();
+			QName propertyQName = QName.createQName(property, namespaceService);
+
+			this.logger.debug("Mapping core to explicit ID: {} => {}", shardSet.getCore(), propertyQName);
+			this.coreExplicitIdCache.put(shardSet.getCore(), propertyQName);
+		}
+	}
+	
+	protected void persistCache() {
+		String lockId = this.jobLockService.getLock(this.shardLock, 2500L, 100L, 50);
+		try {
+			this.persistShardSetCache();
+			this.persistNodeCache();
+			this.persistShardNodesCache();
+			this.persistShardInstanceCache();
+		} finally {
+			this.jobLockService.releaseLock(lockId, this.shardLock);
+		}
+	}
+	
+	private void persistShardSetCache() {
+		// add anything missing
+		// update anything changed
+		for (String core : this.shardsetsCache.getKeys()) {
+			ShardSet shardSet = this.shardsetsCache.get(core);
+			this.checkSetAttribute(shardSet, CommunityConstants.ATTR_ASIE_SHARDSET, core);
+		}
+		
+		// we are not removing anything removed from the cache, as it might have expired
+		// it will just recache on the next load
+	}
+	
+	private void persistNodeCache() {
+		// add anything missing
+		// update anything changed
+		for (String nodeSpec : this.nodesCache.getKeys()) {
+			SolrHost node = this.nodesCache.get(nodeSpec);
+			this.checkSetAttribute(node, CommunityConstants.ATTR_ASIE_NODE, CommunityConstants.ATTR_OBJECT, nodeSpec);
+		}
+		
+		// we are not removing anything removed from the cache, as it might have expired
+		// it will just recache on the next load
+
+		// add anything disabled
+		for (SolrHost node : this.nodeDisableCache.values())
+			this.checkSetAttribute(Boolean.TRUE, CommunityConstants.ATTR_ASIE_NODE, CommunityConstants.ATTR_DISABLE, node.getSpec());
+		
+		// remove anything not disabled
+		this.attrService.getAttributes(new AttributeQueryCallback() {
+			@Override
+			public boolean handleAttribute(Long id, Serializable value, Serializable[] keys) {
+				SolrHost node = SolrHost.from((String) keys[2]);
+				if (!nodeDisableCache.contains(node))
+					attrService.removeAttribute(keys);
+				return true;
+			}
+		}, CommunityConstants.ATTR_ASIE_NODE, CommunityConstants.ATTR_DISABLE);
+	}
+	
+	private void persistShardNodesCache() {
+		// add anything missing
+		// update anything changed
+		for (Shard shard : this.shardNodesCache.getKeys()) {
+			Collection<SolrHost> nodes = this.shardNodesCache.get(shard);
+			for (SolrHost node : nodes) {
+				this.checkSetAttribute(node, CommunityConstants.ATTR_ASIE_SHARD_NODES, shard, node.getSpec());
+			}
+		}
+		
+		// we are not removing anything removed from the cache, as it might have expired
+		// it will just recache on the next load
+	}
+	
+	private void persistShardInstanceCache() {
+		// add anything missing
+		// update anything changed
+		for (ShardInstance shardNode : this.shardInstanceStatesCache.getKeys()) {
+			ShardInstanceState state = this.shardInstanceStatesCache.get(shardNode);
+			this.checkSetAttribute(state, shardNode);
+		}
+		
+		// we are not removing anything removed from the cache, as it might have expired
+		// it will just recache on the next load
+		
+		// add anything disabled
+		for (ShardInstance shardNode : this.shardInstanceDisableCache.values())
+			this.checkSetAttribute(Boolean.TRUE, CommunityConstants.ATTR_ASIE_SHARD_NODE, CommunityConstants.ATTR_DISABLE, shardNode);
+		
+		// remove anything not disabled
+		this.attrService.getAttributes(new AttributeQueryCallback() {
+			@Override
+			public boolean handleAttribute(Long id, Serializable value, Serializable[] keys) {
+				ShardInstance shardNode = (ShardInstance) keys[2];
+				if (!shardInstanceDisableCache.contains(shardNode))
+					attrService.removeAttribute(keys);
+				return true;
+			}
+		}, CommunityConstants.ATTR_ASIE_SHARD_NODE, CommunityConstants.ATTR_DISABLE);
+	}
+	
+	private void checkSetAttribute(ShardInstanceState state, ShardInstance shardNode) {
+		ShardInstanceState currentState = (ShardInstanceState) this.attrService.getAttribute(CommunityConstants.ATTR_ASIE_SHARD_NODE, CommunityConstants.ATTR_OBJECT, shardNode);
+		if (currentState != null) {
+			if (currentState.compareTo(state) >= 0) {
+				// current state is older (greater; further down the list)
+				// do nothing
+			} else {
+				this.logger.debug("The persisted state was old; updating: {}: {} => {}", shardNode, currentState, state);
+				this.attrService.setAttribute(state, CommunityConstants.ATTR_ASIE_SHARD_NODE, CommunityConstants.ATTR_OBJECT, shardNode);
+			}
+		} else {
+			this.attrService.setAttribute(state, CommunityConstants.ATTR_ASIE_SHARD_NODE, CommunityConstants.ATTR_OBJECT, shardNode);
+		}
+	}
+	
+	private void checkSetAttribute(Serializable value, Serializable... keys) {
+		Serializable currentValue = this.attrService.getAttribute(keys);
+		if (currentValue != null) {
+			if (currentValue.equals(value))
+				return;
+			this.logger.warn("The attribute value unexpectedly changed: {}: {} => {}", keys, currentValue, value);
+		}
+		
+		this.attrService.setAttribute(value, keys);
+	}
+	
+	@Override
+	public void registerShardState(ShardState shardNodeState) {
+		ShardSet shardSet = ShardSet.from(shardNodeState.getShardInstance().getShard().getFloc(), shardNodeState);
+		Shard shard = Shard.from(shardSet, shardNodeState.getShardInstance().getShard().getInstance());
+		SolrHost node = SolrHost.from(shardNodeState.getShardInstance());
+		ShardInstance shardNode = ShardInstance.from(shard, node);
+		ShardInstanceState state = ShardInstanceState.from(shardNodeState);
+		
+		String lockId = this.jobLockService.getLock(this.shardLock, 2500L, 500L, 10);
+		try {
+			if (!this.shardsetsCache.contains(shardSet.getCore()))
+				this.shardsetsCache.put(shardSet.getCore(), shardSet);
+			this.checkSetAttribute(shardSet, CommunityConstants.ATTR_ASIE_SHARDSET, shardSet.getCore());
+			
+			if (!this.nodesCache.contains(node.getSpec()))
+				this.nodesCache.put(node.getSpec(), node);
+			this.checkSetAttribute(node, CommunityConstants.ATTR_ASIE_NODE, CommunityConstants.ATTR_OBJECT, node.getSpec());
+			if (!this.shardNodesCache.contains(shard, node))
+				this.shardNodesCache.add(shard, node);
+			this.checkSetAttribute(node, CommunityConstants.ATTR_ASIE_SHARD_NODES, shard, node.getSpec());
+			
+			ShardInstanceState currentState = this.shardInstanceStatesCache.get(shardNode);
+			if (currentState == null || currentState.compareTo(state) > 0)
+				this.shardInstanceStatesCache.put(shardNode, state);
+			this.checkSetAttribute(state, shardNode);
+			if (this.registerDisabled && !this.shardInstanceDisableCache.contains(shardNode))
+				this.shardInstanceDisableCache.add(shardNode);
+		} finally {
+			this.jobLockService.releaseLock(lockId, this.shardLock);
+		}
+	}
+	
+	@Override
+	public void unregisterShardInstance(org.alfresco.repo.index.shard.ShardInstance shardInstance) {
+		ShardSet shardSet = ShardSet.from(shardInstance.getShard().getFloc(), null);
+		Shard shard = Shard.from(shardSet, shardInstance.getShard().getInstance());
+		SolrHost node = SolrHost.from(shardInstance);
+		ShardInstance shardNode = ShardInstance.from(shard, node);
+
+		String lockId = this.jobLockService.getLock(this.shardLock, 2500L, 500L, 10);
+		try {
+			this.shardInstanceStatesCache.remove(shardNode);
+			this.shardInstanceDisableCache.remove(shardNode);
+			this.shardInstanceUnavailableCache.remove(shardNode);
+			this.nodeDisableCache.remove(node);
+			this.nodeUnavailableCache.remove(node);
+			this.attrService.removeAttribute(CommunityConstants.ATTR_ASIE_SHARD_NODES, shard, node.getSpec());
+		} finally {
+			this.jobLockService.releaseLock(lockId, this.shardLock);
+		}
+	}
+	
+	@Override
+	public Map<Floc, Map<org.alfresco.repo.index.shard.Shard, Set<ShardState>>> getFlocs() {
+		Map<String, Floc> flocs = new HashMap<>();
+		Map<Floc, Map<org.alfresco.repo.index.shard.Shard, Set<ShardState>>> response = new HashMap<>();
+		
+		for (Shard shard : this.shardNodesCache.getKeys()) {
+			String core = shard.extractShardSetCore();
+			ShardSet shardSet = this.shardsetsCache.get(core);
+
+			Map<org.alfresco.repo.index.shard.Shard, Set<ShardState>> shards;
+			Floc floc = flocs.get(core);
+			if (floc != null) {
+				floc = shardSet.toAlfrescoModel();
+				shards = new HashMap<>();
+			} else {
+				shards = response.get(floc);
+			}
+			
+			org.alfresco.repo.index.shard.Shard shard_ = shard.toAlfrescoModel(floc);
+			Set<ShardState> states = shards.get(shard_);
+			if (states == null)
+				states = new HashSet<>();
+			
+			for (SolrHost node : this.shardNodesCache.get(shard)) {
+				if (this.nodeDisableCache.contains(node) || this.nodeUnavailableCache.contains(node)) {
+					this.logger.debug("Excluding node as it is disabled or considered unavailable: {}", node);
+					continue;
+				}
+				
+				ShardInstance shardNode = ShardInstance.from(shard, node);
+				if (this.shardInstanceDisableCache.contains(shardNode) || this.shardInstanceUnavailableCache.contains(shardNode)) {
+					this.logger.debug("Excluding shard node as it is disabled or considered unavailable: {}", shardNode);
+					continue;
+				}
+				
+				ShardInstanceState shardNodeState = this.shardInstanceStatesCache.get(shardNode);
+				states.add(shardNodeState.toAlfrescoModel(shardNode.toAlfrescoModel(shard_)));
+			}
+			
+			if (!states.isEmpty())
+				shards.put(shard_, states);
+			if (!shards.isEmpty())
+				response.put(floc, shards);
+		}
+		
+		return response;
+	}
+	
+	@Override
+	public void purge() {
+		String lockId = this.jobLockService.getLock(this.shardLock, 2500L, 100L, 50);
+		try {
+			this.logger.info("Removing all nodes/shards from the shard registry");
+			this.shardsetsCache.clear();
+			this.attrService.removeAttributes(CommunityConstants.ATTR_ASIE_SHARDSET);
+			
+			this.nodesCache.clear();
+			this.nodeDisableCache.clear();
+			this.nodeUnavailableCache.clear();
+			this.attrService.removeAttributes(CommunityConstants.ATTR_ASIE_NODE);
+			
+			this.shardNodesCache.clear();
+			this.attrService.removeAttributes(CommunityConstants.ATTR_ASIE_SHARD_NODES);
+			
+			this.shardInstanceStatesCache.clear();
+			this.shardInstanceDisableCache.clear();
+			this.shardInstanceUnavailableCache.clear();
+			this.attrService.removeAttributes(CommunityConstants.ATTR_ASIE_SHARD_NODE);
+			
+			this.coreExplicitIdCache.clear();
+		} finally {
+			this.jobLockService.releaseLock(lockId, this.shardLock);
+		}
+	}
+	
+	@Override
+	public void purgeAgedOutShards() {
+		OffsetDateTime onlineExpired = OffsetDateTime.now().minusSeconds(this.offlineIdleShardInSeconds);
+		OffsetDateTime offlineExpired = OffsetDateTime.now().minusSeconds(this.forgetOfflineShardInSeconds);
+		
+		for (ShardInstance shardNode : this.shardInstanceStatesCache.getKeys()) {
+			ShardInstanceState state = this.shardInstanceStatesCache.get(shardNode);
+			SolrHost node = shardNode.extractNode();
+			
+			if (this.shardInstanceDisableCache.contains(shardNode)) {
+				this.logger.debug("Ignoring disabled shard instance during purgeAgedOutShards()");
+			} else if (this.nodeDisableCache.contains(node)) {
+				this.logger.debug("Ignoring disabled node during purgeAgedOutShards()");
+			} else if (state.getLastUpdated().isBefore(offlineExpired)) {
+				this.shardInstanceStatesCache.remove(shardNode);
+				if (this.shardInstanceUnavailableCache.remove(shardNode)) {
+					this.logger.info("Forgetting about already offline shard: {}", shardNode);
+				} else if (this.nodeUnavailableCache.remove(node)) {
+					this.logger.info("Forgetting about already offline shard: {}", shardNode);
+				} else {
+					this.logger.warn("Forgetting about online shard: {}", shardNode);
+				}
+			} else if (state.getLastUpdated().isBefore(onlineExpired)) {
+				this.logger.warn("Taking shard offline: {}", shardNode);
+				this.shardInstanceUnavailableCache.add(shardNode);
+			}
+		}
+	}
+	
+	@Override
+	public QName getExplicitIdProperty(String coreName) {
+		return this.coreExplicitIdCache.get(coreName);
+	}
+	
+	@Override
+	public Set<Integer> getShardInstanceList(String coreName) {
+		Set<Integer> shardIds = new HashSet<>();
+		
+		ShardSet shardSet = this.shardsetsCache.get(coreName);
+		if (shardSet == null)
+			return Collections.emptySet();
+		
+		
+		for (Shard shard : this.shardNodesCache.getKeys()) {
+			if (shardSet.getCore().equals(shard.extractShardSetCore())) {
+				shardIds.add(shard.extractShardId());
+			}
+		}
+		
+		return shardIds;
+	}
+	
+	@Override
+	public OptionalInt getShardInstanceByTransactionTimestamp(String coreId, long txnTimestamp) {
+		throw new UnsupportedOperationException();
+	}
+	
+	@Override
+	public List<org.alfresco.repo.index.shard.ShardInstance> getIndexSlice(SearchParameters searchParameters) {
+		if (searchParameters.getQuery() == null)
+			return Collections.emptyList();
+		
+		List<org.alfresco.repo.index.shard.ShardInstance> bestShards = null;
+		
+		for (String shardSetSpec : this.shardsetsCache.getKeys()) {
+			ShardSet shardSet = this.shardsetsCache.get(shardSetSpec);
+			
+			Set<Integer> shardIds = this.getIndexSlice(searchParameters, shardSet);
+			if (shardIds == null)
+				continue;
+			
+			List<org.alfresco.repo.index.shard.ShardInstance> shards = this.selectRandomNodes(shardSet, shardIds);
+			
+			if (!shards.isEmpty() && (bestShards == null || shards.size() < bestShards.size()))
+				bestShards = shards;
+			if (bestShards != null && bestShards.size() == 1)
+				break;
+		}
+		
+		return bestShards;
+	}
+	
+	protected Set<Integer> getIndexSlice(SearchParameters searchParameters, ShardSet shardSet) {
+		try {
+			switch (shardSet.getMethod()) {
+				case EXPLICIT_ID:
+					return this.getExplicitIdIndexSlice(searchParameters, shardSet);
+				default:
+					// no optimization available
+					return null;
+			}
+		} catch (RecognitionException re) {
+			this.logger.debug("Failed to parse the query: " + searchParameters.getQuery(), re);
+			// no optimization available
+			return null;
+		}
+	}
+	
+	protected Set<Integer> getExplicitIdIndexSlice(SearchParameters searchParameters, ShardSet shardSet) throws RecognitionException {
+		this.logger.trace("Found {} shard set, which is the highest priority", shardSet.getMethod());
+		
+		QueryInspector inspector = this.queryInspectorFactory.selectQueryInspector(searchParameters);
+		if (inspector == null) {
+			this.logger.debug("The search is using an unsupported query language; unable to optimize for {}: {}", shardSet.getMethod(), searchParameters.getLanguage());
+			return null;
+		}
+		
+		String property = shardSet.getPrefixedProperty();
+		QName propertyQName = QName.createQName(property, this.namespaceService);
+		this.logger.trace("Will attempt to see if search has a required constraint on explicit shard ID property: {}", propertyQName);
+		DataTypeDefinition dtdef = this.dictionaryService.getProperty(propertyQName).getDataType();
+		
+		Set<Integer> shardIds = new HashSet<>();
+		List<QueryValue> values = inspector.findRequiredPropertyValues(searchParameters.getQuery(), searchParameters.getDefaultOperator(), propertyQName, dtdef);
+		this.logger.trace("Found {} matching terms query: {}: {}", values.size(), propertyQName, searchParameters.getQuery());
+		for (QueryValue value : values) {
+			if (value instanceof QuerySingleValue<?>) {
+				@SuppressWarnings("unchecked")
+				Number num = ((QuerySingleValue<? extends Number>) value).getValue();
+				shardIds.add(num.intValue());
+			} else if (value instanceof QueryRangeValue<?>) {
+				@SuppressWarnings("unchecked")
+				QueryRangeValue<? extends Number> num = (QueryRangeValue<? extends Number>) value;
+				int start = num.getStart().intValue();
+				if (!num.isIncludeStart())
+					start++;
+				int end = num.getStart().intValue();
+				if (!num.isIncludeEnd())
+					end--;
+				for (int shardId = start; shardId <= end; shardId++)
+					shardIds.add(shardId);
+			}
+		}
+
+		if (shardIds.isEmpty()) {
+			this.logger.trace("The {} shard set cannot not be used to optimize the query", shardSet.getMethod());
+			return null;
+		}
+		this.logger.debug("The {} shard set was used to optimize the query to use only shards: {}", shardSet.getMethod(), shardIds);
+		
+		return shardIds;
+	}
+	
+	protected List<org.alfresco.repo.index.shard.ShardInstance> selectRandomNodes(ShardSet shardSet, Collection<Integer> shardIds) {
+		List<org.alfresco.repo.index.shard.ShardInstance> shardNodes = new LinkedList<>();
+		
+		for (Integer shardId : shardIds) {
+			Shard shard = Shard.from(shardSet, shardId);
+			
+			Collection<SolrHost> nodes = this.shardNodesCache.get(shard);
+			List<SolrHost> availableNodes = new LinkedList<>();
+			for (SolrHost node : nodes) {
+				if (this.nodeDisableCache.contains(node) || this.nodeUnavailableCache.contains(node))
+					continue;
+				
+				ShardInstance shardNode = ShardInstance.from(shard, node);
+				if (this.shardInstanceDisableCache.contains(shardNode) || this.shardInstanceUnavailableCache.contains(shardNode))
+					continue;
+				
+				availableNodes.add(node);
+			}
+			
+			SolrHost randomNode = availableNodes.get(this.random.nextInt(availableNodes.size()));
+			
+			shardNodes.add(ShardInstance.from(shard, randomNode).toAlfrescoModel(shard.toAlfrescoModel(shardSet.toAlfrescoModel())));
+		}
+		
+		return shardNodes;
+	}
+
+}

community-module/src/main/java/com/inteligr8/alfresco/asie/util/ShardSetSearchComparator.java

@@ -0,0 +1,79 @@
+package com.inteligr8.alfresco.asie.util;
+
+import java.util.Comparator;
+
+import org.alfresco.repo.index.shard.ShardMethodEnum;
+
+import com.inteligr8.alfresco.asie.model.ShardSet;
+
+public class ShardSetSearchComparator implements Comparator<ShardSet> {
+	
+	@Override
+	public int compare(ShardSet ss1, ShardSet ss2) {
+		int compare = this.compare(ss1.getMethod(), ss2.getMethod());
+		if (compare != 0)
+			return compare;
+		
+		return this.compare(ss1.getShards(), ss2.getShards());
+	}
+	
+	private int compare(ShardMethodEnum method1, ShardMethodEnum method2) {
+		if (method1.equals(method2))
+			return 0;
+		
+		switch (method1) {
+			case EXPLICIT_ID:
+			case EXPLICIT_ID_FALLBACK_LRIS:
+				return -1;
+			case PROPERTY:
+			case DATE:
+				switch (method2) {
+					case EXPLICIT_ID:
+					case EXPLICIT_ID_FALLBACK_LRIS:
+						return 1;
+					default:
+						return -1;
+				}
+			case ACL_ID:
+			case MOD_ACL_ID:
+				switch (method2) {
+					case EXPLICIT_ID:
+					case EXPLICIT_ID_FALLBACK_LRIS:
+					case PROPERTY:
+					case DATE:
+						return 1;
+					default:
+						return -1;
+				}
+			default:
+				switch (method2) {
+					case EXPLICIT_ID:
+					case EXPLICIT_ID_FALLBACK_LRIS:
+					case PROPERTY:
+					case DATE:
+					case ACL_ID:
+					case MOD_ACL_ID:
+						return 1;
+					default:
+			}
+		}
+		
+		return 0;
+	}
+	
+	private int compare(Short shards1, Short shards2) {
+		// the larger the shard count, the more shards that may need to be queried
+		// so prefer smaller shard counts
+		// no shard count (DB_ID_RANGE) should be treated as the worst (unlimited) 
+		if (shards1 == null && shards2 == null) {
+			return 0;
+		} else if (shards1 == null) {
+			return 1;
+		} else if (shards2 == null) {
+			return -1;
+		} else {
+			return shards1.compareTo(shards2);
+		}
+	}
+
+}

community-module/src/main/resources/alfresco/module/com_inteligr8_alfresco_asie-community-platform-module/alfresco-global.properties

@@ -0,0 +1,109 @@
+
+inteligr8.asie.registerUnknownShardDisabled=false
+inteligr8.asie.offlineIdleShardInSeconds=120
+inteligr8.asie.forgetOfflineShardInSeconds=86400
+
+
+
+# we don't want items expiring out of the following caches
+# an evicition policy of NONE disables the maxItems limits
+
+# Overrides of alfresco-repository.jar/alfresco/caches.properties
+cache.asieShardsetsSharedCache.tx.maxItems=65536
+cache.asieShardsetsSharedCache.tx.statsEnabled=${caches.tx.statsEnabled}
+cache.asieShardsetsSharedCache.maxItems=65536
+cache.asieShardsetsSharedCache.timeToLiveSeconds=0
+cache.asieShardsetsSharedCache.maxIdleSeconds=0
+cache.asieShardsetsSharedCache.cluster.type=fully-distributed
+cache.asieShardsetsSharedCache.backup-count=1
+cache.asieShardsetsSharedCache.eviction-policy=NONE
+cache.asieShardsetsSharedCache.merge-policy=com.hazelcast.map.merge.PutIfAbsentMapMergePolicy
+cache.asieShardsetsSharedCache.readBackupData=false
+
+cache.asieNodesSharedCache.tx.maxItems=65536
+cache.asieNodesSharedCache.tx.statsEnabled=${caches.tx.statsEnabled}
+cache.asieNodesSharedCache.maxItems=65536
+cache.asieNodesSharedCache.timeToLiveSeconds=0
+cache.asieNodesSharedCache.maxIdleSeconds=0
+cache.asieNodesSharedCache.cluster.type=fully-distributed
+cache.asieNodesSharedCache.backup-count=1
+cache.asieNodesSharedCache.eviction-policy=NONE
+cache.asieNodesSharedCache.merge-policy=com.hazelcast.map.merge.PutIfAbsentMapMergePolicy
+cache.asieNodesSharedCache.readBackupData=false
+
+cache.asieShardNodesSharedCache.tx.maxItems=65536
+cache.asieShardNodesSharedCache.tx.statsEnabled=${caches.tx.statsEnabled}
+cache.asieShardNodesSharedCache.maxItems=65536
+cache.asieShardNodesSharedCache.timeToLiveSeconds=0
+cache.asieShardNodesSharedCache.maxIdleSeconds=0
+cache.asieShardNodesSharedCache.cluster.type=fully-distributed
+cache.asieShardNodesSharedCache.backup-count=1
+cache.asieShardNodesSharedCache.eviction-policy=NONE
+cache.asieShardNodesSharedCache.merge-policy=com.hazelcast.map.merge.PutIfAbsentMapMergePolicy
+cache.asieShardNodesSharedCache.readBackupData=false
+
+cache.asieShardInstanceStateSharedCache.tx.maxItems=65536
+cache.asieShardInstanceStateSharedCache.tx.statsEnabled=${caches.tx.statsEnabled}
+cache.asieShardInstanceStateSharedCache.maxItems=65536
+cache.asieShardInstanceStateSharedCache.timeToLiveSeconds=0
+cache.asieShardInstanceStateSharedCache.maxIdleSeconds=0
+cache.asieShardInstanceStateSharedCache.cluster.type=fully-distributed
+cache.asieShardInstanceStateSharedCache.backup-count=1
+cache.asieShardInstanceStateSharedCache.eviction-policy=NONE
+cache.asieShardInstanceStateSharedCache.merge-policy=com.hazelcast.map.merge.PutIfAbsentMapMergePolicy
+cache.asieShardInstanceStateSharedCache.readBackupData=false
+
+cache.asieNodeDisabledSharedCache.tx.maxItems=65536
+cache.asieNodeDisabledSharedCache.tx.statsEnabled=${caches.tx.statsEnabled}
+cache.asieNodeDisabledSharedCache.maxItems=65536
+cache.asieNodeDisabledSharedCache.timeToLiveSeconds=0
+cache.asieNodeDisabledSharedCache.maxIdleSeconds=0
+cache.asieNodeDisabledSharedCache.cluster.type=fully-distributed
+cache.asieNodeDisabledSharedCache.backup-count=1
+cache.asieNodeDisabledSharedCache.eviction-policy=NONE
+cache.asieNodeDisabledSharedCache.merge-policy=com.hazelcast.map.merge.PutIfAbsentMapMergePolicy
+cache.asieNodeDisabledSharedCache.readBackupData=false
+
+cache.asieNodeUnavailableSharedCache.tx.maxItems=65536
+cache.asieNodeUnavailableSharedCache.tx.statsEnabled=${caches.tx.statsEnabled}
+cache.asieNodeUnavailableSharedCache.maxItems=65536
+cache.asieNodeUnavailableSharedCache.timeToLiveSeconds=0
+cache.asieNodeUnavailableSharedCache.maxIdleSeconds=0
+cache.asieNodeUnavailableSharedCache.cluster.type=fully-distributed
+cache.asieNodeUnavailableSharedCache.backup-count=1
+cache.asieNodeUnavailableSharedCache.eviction-policy=NONE
+cache.asieNodeUnavailableSharedCache.merge-policy=com.hazelcast.map.merge.PutIfAbsentMapMergePolicy
+cache.asieNodeUnavailableSharedCache.readBackupData=false
+
+cache.asieShardInstanceDisabledSharedCache.tx.maxItems=65536
+cache.asieShardInstanceDisabledSharedCache.tx.statsEnabled=${caches.tx.statsEnabled}
+cache.asieShardInstanceDisabledSharedCache.maxItems=65536
+cache.asieShardInstanceDisabledSharedCache.timeToLiveSeconds=0
+cache.asieShardInstanceDisabledSharedCache.maxIdleSeconds=0
+cache.asieShardInstanceDisabledSharedCache.cluster.type=fully-distributed
+cache.asieShardInstanceDisabledSharedCache.backup-count=1
+cache.asieShardInstanceDisabledSharedCache.eviction-policy=NONE
+cache.asieShardInstanceDisabledSharedCache.merge-policy=com.hazelcast.map.merge.PutIfAbsentMapMergePolicy
+cache.asieShardInstanceDisabledSharedCache.readBackupData=false
+
+cache.asieShardInstanceUnavailableSharedCache.tx.maxItems=65536
+cache.asieShardInstanceUnavailableSharedCache.tx.statsEnabled=${caches.tx.statsEnabled}
+cache.asieShardInstanceUnavailableSharedCache.maxItems=65536
+cache.asieShardInstanceUnavailableSharedCache.timeToLiveSeconds=0
+cache.asieShardInstanceUnavailableSharedCache.maxIdleSeconds=0
+cache.asieShardInstanceUnavailableSharedCache.cluster.type=fully-distributed
+cache.asieShardInstanceUnavailableSharedCache.backup-count=1
+cache.asieShardInstanceUnavailableSharedCache.eviction-policy=NONE
+cache.asieShardInstanceUnavailableSharedCache.merge-policy=com.hazelcast.map.merge.PutIfAbsentMapMergePolicy
+cache.asieShardInstanceUnavailableSharedCache.readBackupData=false
+
+cache.asieCoreExplicitSharedCache.tx.maxItems=65536
+cache.asieCoreExplicitSharedCache.tx.statsEnabled=${caches.tx.statsEnabled}
+cache.asieCoreExplicitSharedCache.maxItems=65536
+cache.asieCoreExplicitSharedCache.timeToLiveSeconds=0
+cache.asieCoreExplicitSharedCache.maxIdleSeconds=0
+cache.asieCoreExplicitSharedCache.cluster.type=fully-distributed
+cache.asieCoreExplicitSharedCache.backup-count=1
+cache.asieCoreExplicitSharedCache.eviction-policy=NONE
+cache.asieCoreExplicitSharedCache.merge-policy=com.hazelcast.map.merge.PutIfAbsentMapMergePolicy
+cache.asieCoreExplicitSharedCache.readBackupData=false

community-module/src/main/resources/alfresco/module/com_inteligr8_alfresco_asie-community-platform-module/module-context.xml

@@ -0,0 +1,50 @@
+<?xml version='1.0' encoding='UTF-8'?>
+
+<!-- Use this file for beans to be loaded in whatever order Alfresco/Spring decides -->
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:context="http://www.springframework.org/schema/context"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+				http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
+   
+	<bean name="asieShardsetsCache" factory-bean="cacheFactory" factory-method="createCache">
+		<constructor-arg value="cache.asieShardsetsSharedCache" />
+	</bean>
+	
+	<bean name="asieNodesCache" factory-bean="cacheFactory" factory-method="createCache">
+		<constructor-arg value="cache.asieNodesSharedCache" />
+	</bean>
+	
+	<bean name="asieShardNodesCache" factory-bean="cacheFactory" factory-method="createMultiValueCache">
+		<constructor-arg value="cache.asieShardNodesSharedCache" />
+	</bean>
+	
+	<bean name="asieShardInstanceStateCache" factory-bean="cacheFactory" factory-method="createCache">
+		<constructor-arg value="cache.asieShardInstanceStateSharedCache" />
+	</bean>
+	
+	<bean name="asieNodeDisabledCache" factory-bean="cacheFactory" factory-method="createCollectionCache">
+		<constructor-arg value="cache.asieNodeDisabledSharedCache" />
+		<constructor-arg value="java.util.HashSet" />
+	</bean>
+	
+	<bean name="asieNodeUnavailableCache" factory-bean="cacheFactory" factory-method="createCollectionCache">
+		<constructor-arg value="cache.asieNodeUnavailableSharedCache" />
+		<constructor-arg value="java.util.HashSet" />
+	</bean>
+	
+	<bean name="asieShardInstanceDisabledCache" factory-bean="cacheFactory" factory-method="createCollectionCache">
+		<constructor-arg value="cache.asieShardInstanceDisabledSharedCache" />
+		<constructor-arg value="java.util.HashSet" />
+	</bean>
+	
+	<bean name="asieShardInstanceUnavailableCache" factory-bean="cacheFactory" factory-method="createCollectionCache">
+		<constructor-arg value="cache.asieShardInstanceUnavailableSharedCache" />
+		<constructor-arg value="java.util.HashSet" />
+	</bean>
+	
+	<bean name="asieCoreExplicitCache" factory-bean="cacheFactory" factory-method="createCache">
+		<constructor-arg value="cache.asieCoreExplicitSharedCache" />
+	</bean>
+
+</beans>

community-module/src/main/resources/alfresco/module/com_inteligr8_alfresco_asie-community-platform-module/module.properties

@@ -0,0 +1,11 @@
+module.id=com_inteligr8_alfresco_${project.artifactId}
+module.aliases=
+module.title=${project.name}
+module.description=${project.description}
+module.version=${module.version}
+
+module.repo.version.min=23.0
+
+# this is creating all sorts of problems; probably because of the non-standard versioning
+module.depends.com.inteligr8.alfresco.cachext-platform-module=*
+module.depends.com.inteligr8.alfresco.cxf-jaxrs-platform-module=*

community-module/src/test/java/com/inteligr8/alfresco/asie/QueryConstraintUnitTest.java

@@ -0,0 +1,146 @@
+package com.inteligr8.alfresco.asie;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.alfresco.repo.search.impl.parsers.FTSLexer;
+import org.alfresco.repo.search.impl.parsers.FTSParser;
+import org.alfresco.service.cmr.search.SearchParameters.Operator;
+import org.antlr.runtime.ANTLRStringStream;
+import org.antlr.runtime.CharStream;
+import org.antlr.runtime.CommonTokenStream;
+import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.tree.CommonTree;
+import org.antlr.runtime.tree.Tree;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+
+public class QueryConstraintUnitTest {
+
+	private static final ObjectMapper om = new ObjectMapper();
+	
+	@BeforeClass
+	public static void init() {
+		SimpleModule module = new SimpleModule();
+		module.addSerializer(Tree.class, new TreeSerializer());
+		om.registerModule(module);
+	}
+	
+	@Test
+	public void testSingleExactTerm() throws RecognitionException, JsonProcessingException {
+		Tree tree = this.parseFts("=@cm:title:test", Operator.AND);
+		tree = this.validateChildren(tree, "DISJUNCTION");
+		tree = this.validateChildren(tree, "CONJUNCTION");
+		tree = this.validateChildren(tree, "DEFAULT");
+		tree = this.validateChildren(tree, "EXACT_TERM", "test");
+		tree = this.validateChildren(tree, "FIELD_REF", "title");
+		this.validate(tree, "PREFIX", "cm");
+	}
+	
+	@Test
+	public void testSingleFuzzyTerm() throws RecognitionException, JsonProcessingException {
+		Tree tree = this.parseFts("@cm:title:test", Operator.AND);
+		tree = this.validateChildren(tree, "DISJUNCTION");
+		tree = this.validateChildren(tree, "CONJUNCTION");
+		tree = this.validateChildren(tree, "DEFAULT");
+		tree = this.validateChildren(tree, "TERM", "test");
+		tree = this.validateChildren(tree, "FIELD_REF", "title");
+		this.validate(tree, "PREFIX", "cm");
+	}
+	
+	@Test
+	public void testSingleFuzzyString() throws RecognitionException, JsonProcessingException {
+		Tree tree = this.parseFts("@cm:title:'testing'", Operator.AND);
+		tree = this.validateChildren(tree, "DISJUNCTION");
+		tree = this.validateChildren(tree, "CONJUNCTION");
+		tree = this.validateChildren(tree, "DEFAULT");
+		tree = this.validateChildren(tree, "PHRASE", "'testing'");
+		tree = this.validateChildren(tree, "FIELD_REF", "title");
+		this.validate(tree, "PREFIX", "cm");
+	}
+	
+	@Test
+	public void testSingleFuzzyStringDoubleQuotes() throws RecognitionException, JsonProcessingException {
+		Tree tree = this.parseFts("cm:title:\"testing\"", Operator.AND);
+		tree = this.validateChildren(tree, "DISJUNCTION");
+		tree = this.validateChildren(tree, "CONJUNCTION");
+		tree = this.validateChildren(tree, "DEFAULT");
+		tree = this.validateChildren(tree, "PHRASE", "\"testing\"");
+		tree = this.validateChildren(tree, "FIELD_REF", "title");
+		this.validate(tree, "PREFIX", "cm");
+	}
+	
+	@Test
+	public void testSingleRange() throws RecognitionException, JsonProcessingException {
+		Tree tree = this.parseFts("@cm:created:[NOW TO '2025-01-01T00:00:00'>", Operator.AND);
+		tree = this.validateChildren(tree, "DISJUNCTION");
+		tree = this.validateChildren(tree, "CONJUNCTION");
+		tree = this.validateChildren(tree, "DEFAULT");
+		tree = this.validateChildren(tree, "RANGE", "INCLUSIVE", "NOW", "'2025-01-01T00:00:00'", "EXCLUSIVE");
+		tree = this.validateChildren(tree, "FIELD_REF", "created");
+		this.validate(tree, "PREFIX", "cm");
+	}
+	
+	@Test
+	public void testTwoTerms() throws RecognitionException, JsonProcessingException {
+		Tree tree = this.parseFts("=@cm:title:test1 AND @cm:author:test2", Operator.AND);
+		tree = this.validateChildren(tree, "DISJUNCTION");
+		List<Tree> trees = this.validateChildren(tree, "CONJUNCTION", 2);
+		
+		tree = trees.get(0);
+		tree = this.validateChildren(tree, "DEFAULT");
+		tree = this.validateChildren(tree, "EXACT_TERM", "test1");
+		tree = this.validateChildren(tree, "FIELD_REF", "title");
+		this.validate(tree, "PREFIX", "cm");
+		
+		tree = trees.get(1);
+		tree = this.validateChildren(tree, "DEFAULT");
+		tree = this.validateChildren(tree, "TERM", "test2");
+		tree = this.validateChildren(tree, "FIELD_REF", "author");
+		this.validate(tree, "PREFIX", "cm");
+	}
+	
+	protected void validate(Tree tree, String text, String... extraValues) {
+		Assert.assertNotNull(tree);
+		Assert.assertEquals(text, tree.getText());
+		Assert.assertEquals(extraValues.length, tree.getChildCount());
+		for (int c = 0; c < extraValues.length; c++)
+			Assert.assertEquals(extraValues[c], tree.getChild(c).getText());
+	}
+	
+	protected Tree validateChildren(Tree tree, String text, String... extraValues) {
+		Assert.assertNotNull(tree);
+		Assert.assertEquals(text, tree.getText());
+		Assert.assertEquals(extraValues.length + 1, tree.getChildCount());
+		for (int c = 0; c < extraValues.length; c++)
+			Assert.assertEquals(extraValues[c], tree.getChild(c).getText());
+		return tree.getChild(extraValues.length);
+	}
+	
+	protected List<Tree> validateChildren(Tree tree, String text, int count) {
+		Assert.assertNotNull(tree);
+		Assert.assertEquals(text, tree.getText());
+		Assert.assertEquals(count, tree.getChildCount());
+		List<Tree> children = new ArrayList<>();
+		for (int c = 0; c < tree.getChildCount(); c++)
+			children.add(tree.getChild(c));
+		return children;
+	}
+	
+	protected Tree parseFts(String ftsQuery, Operator defaultOperator) throws RecognitionException, JsonProcessingException {
+        CharStream cs = new ANTLRStringStream(ftsQuery);
+        FTSLexer lexer = new FTSLexer(cs);
+        CommonTokenStream tokens = new CommonTokenStream(lexer);
+        FTSParser parser = new FTSParser(tokens);
+        parser.setDefaultFieldConjunction(defaultOperator.equals(Operator.AND));
+        parser.setMode(defaultOperator.equals(Operator.AND) ? FTSParser.Mode.DEFAULT_CONJUNCTION : FTSParser.Mode.DEFAULT_DISJUNCTION);
+        CommonTree tree = (CommonTree) parser.ftsQuery().getTree();
+        return tree;
+	}
+
+}

community-module/src/test/java/com/inteligr8/alfresco/asie/TreeSerializer.java

@@ -0,0 +1,44 @@
+package com.inteligr8.alfresco.asie;
+
+import java.io.IOException;
+
+import org.antlr.runtime.tree.Tree;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+
+public class TreeSerializer extends StdSerializer<Tree> {
+	
+	private static final long serialVersionUID = -2714782538361726878L;
+
+	public TreeSerializer() {
+		super(Tree.class);
+	}
+
+	public TreeSerializer(Class<Tree> type) {
+		super(type);
+	}
+	
+	public TreeSerializer(JavaType type) {
+		super(type);
+	}
+	
+	@Override
+	public void serialize(Tree value, JsonGenerator gen, SerializerProvider provider) throws IOException {
+		gen.writeStartObject();
+		if (value.getText() != null)
+			gen.writeStringField("text", value.getText());
+		
+		if (value.getChildCount() > 0) {
+			gen.writeArrayFieldStart("children");
+			for (int c = 0; c < value.getChildCount(); c++)
+				gen.writeObject(value.getChild(c));
+			gen.writeEndArray();
+		}
+		
+		gen.writeEndObject();
+	}
+
+}

enterprise-module/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>com.inteligr8.alfresco</groupId>
 		<artifactId>asie-platform-module-parent</artifactId>
-		<version>1.1.0</version>
+		<version>1.2.2</version>
 		<relativePath>../</relativePath>
 	</parent>
 
@@ -16,8 +16,12 @@
 	<name>ASIE Platform Module for ACS Enterprise</name>
 
 	<properties>
-		<alfresco.sdk.version>5.2.0</alfresco.sdk.version>
+		<alfresco.sdk.version>4.9.0</alfresco.sdk.version>
 		<alfresco.platform.version>23.3.0</alfresco.platform.version>
+		<alfresco.platform.war.version>23.3.0.98</alfresco.platform.war.version>
+		<tomcat-rad.version>10-2.1</tomcat-rad.version>
+		
+		<beedk.rad.acs-search.enabled>true</beedk.rad.acs-search.enabled>
 	</properties>
 
 	<dependencyManagement>
@@ -79,8 +83,8 @@
 		<dependency>
 			<groupId>com.inteligr8.alfresco</groupId>
 			<artifactId>cxf-jaxrs-platform-module</artifactId>
-			<version>1.3.1-acs-v23.3</version>
-			<scope>provided</scope>
+			<version>1.3.2-acs-v23.3</version>
+			<type>amp</type>
 		</dependency>
 
 		<!-- Including for testing purposes only -->

enterprise-module/rad.sh

@@ -1,22 +1,22 @@
 #!/bin/sh
 
 discoverArtifactId() {
-	ARTIFACT_ID=`mvn -q -Dexpression=project.artifactId -DforceStdout help:evaluate`
+	ARTIFACT_ID=`mvn -q -Dexpression=project.artifactId -DforceStdout help:evaluate | sed 's/\x1B\[[0-9;]\{1,\}[A-Za-z]//g'`
 }
 
 rebuild() {
 	echo "Rebuilding project ..."
-	mvn process-classes
+	mvn process-test-classes
 }
 
 start() {
 	echo "Rebuilding project and starting Docker containers to support rapid application development ..."
-	mvn -Drad process-classes
+	mvn -Drad process-test-classes
 }
 
 start_log() {
 	echo "Rebuilding project and starting Docker containers to support rapid application development ..."
-	mvn -Drad -Ddocker.showLogs process-classes
+	mvn -Drad -Ddocker.showLogs process-test-classes
 }
 
 stop() {

enterprise-module/src/main/java/com/inteligr8/alfresco/asie/enterprise/rest/AbstractUnregisterNodeWebScript.java

@@ -1,4 +1,4 @@
-package com.inteligr8.alfresco.asie.rest;
+package com.inteligr8.alfresco.asie.enterprise.rest;
 
 import java.io.IOException;
 import java.io.Serializable;
@@ -9,6 +9,7 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
+import org.alfresco.repo.index.shard.Shard;
 import org.alfresco.repo.index.shard.ShardState;
 import org.alfresco.service.cmr.attributes.AttributeService;
 import org.alfresco.service.cmr.attributes.AttributeService.AttributeQueryCallback;
@@ -17,16 +18,17 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.extensions.webscripts.WebScriptException;
 import org.springframework.extensions.webscripts.WebScriptRequest;
 import org.springframework.extensions.webscripts.WebScriptResponse;
 import org.springframework.http.HttpStatus;
 
 import com.inteligr8.alfresco.asie.Constants;
 import com.inteligr8.alfresco.asie.api.CoreAdminApi;
-import com.inteligr8.alfresco.asie.model.NodeParameterSet;
-import com.inteligr8.alfresco.asie.service.ShardBackupService;
-import com.inteligr8.alfresco.asie.spi.ShardStateService;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.rest.AbstractAsieNodeWebScript;
+import com.inteligr8.alfresco.asie.rest.model.NodeParameterSet;
+import com.inteligr8.alfresco.asie.spi.ShardBackupService;
+import com.inteligr8.alfresco.asie.enterprise.service.ShardStateService;
 import com.inteligr8.solr.model.CoreMetadata;
 import com.inteligr8.solr.model.core.StatusRequest;
 import com.inteligr8.solr.model.core.StatusResponse;
@@ -84,19 +86,25 @@ public abstract class AbstractUnregisterNodeWebScript<T extends NodeParameterSet
 				ShardState shardNode = matchingCore.getValue();
 				String core = shardNode.getPropertyBag().get("coreName");
 				
-				StatusResponse status = this.getCoreStatus(nodeHostname, nodePort, core);
-				if (status == null)
-					throw new WebScriptException(HttpStatus.INTERNAL_SERVER_ERROR.value(), "This should never happen");
-				CoreMetadata coreMetadata = status.getStatus().getCores().get(core);
-				if (coreMetadata == null || coreMetadata.getName() == null) {
-					this.logger.warn("Registered core does not actually exist on the node host; could be a DNS issue: {}:{}/solr/{}", nodeHostname, nodePort, core);
-				} else {
-					this.unloadCore(nodeHostname, nodePort, core);
-					cores.put(core, coreMetadata.getInstancePath());
+				try {
+					StatusResponse status = this.getCoreStatus(nodeHostname, nodePort, core);
+					if (status == null) {
+						this.logger.warn("Registered host/core status could not be retrieved: {}:{}/solr/{}", nodeHostname, nodePort, core);
+					} else {
+						CoreMetadata coreMetadata = status.getCores().getByCore(core);
+						if (coreMetadata == null || coreMetadata.getName() == null) {
+							this.logger.warn("Registered core does not actually exist on the node host; could be a DNS issue: {}:{}/solr/{}", nodeHostname, nodePort, core);
+						} else {
+							this.unloadCore(nodeHostname, nodePort, core);
+							cores.put(core, coreMetadata.getInstancePath());
+						}
+					}
+				} finally {
+					this.sss.remove(matchingCore.getKey());
+					
+					Shard shard = shardNode.getShardInstance().getShard();
+					this.sbs.forget(ShardSet.from(shard.getFloc(), shardNode), shard.getInstance());
 				}
-				
-				this.sss.remove(matchingCore.getKey());
-				this.sbs.forget(shardNode);
 			}
 		} finally {
 			// FIXME maybe a separate tx?
@@ -133,13 +141,13 @@ public abstract class AbstractUnregisterNodeWebScript<T extends NodeParameterSet
 	
 	protected StatusResponse getCoreStatus(String nodeHostname, int nodePort, String core) {
 		this.logger.debug("Retrieving status for core {} on ASIE node: {}", core, nodeHostname);
-		CoreAdminApi api = this.createApi(nodeHostname, nodePort);
+		CoreAdminApi api = this.getApiService().createApi(nodeHostname, nodePort, CoreAdminApi.class);
 		return api.getStatus(new StatusRequest().withCore(core));
 	}
 	
 	protected void unloadCore(String nodeHostname, int nodePort, String core) {
 		this.logger.info("Unloading core {} on ASIE node: {}", core, nodeHostname);
-		CoreAdminApi api = this.createApi(nodeHostname, nodePort);
+		CoreAdminApi api = this.getApiService().createApi(nodeHostname, nodePort, CoreAdminApi.class);
 		api.unload(new UnloadRequest().withCore(core));
 	}
     

enterprise-module/src/main/java/com/inteligr8/alfresco/asie/enterprise/rest/ReloadNodeShardWebScript.java

@@ -1,4 +1,4 @@
-package com.inteligr8.alfresco.asie.rest;
+package com.inteligr8.alfresco.asie.enterprise.rest;
 
 import java.io.IOException;
 import java.io.Serializable;
@@ -21,6 +21,7 @@ import org.springframework.stereotype.Component;
 
 import com.inteligr8.alfresco.asie.Constants;
 import com.inteligr8.alfresco.asie.api.CoreAdminApi;
+import com.inteligr8.alfresco.asie.rest.AbstractAsieNodeWebScript;
 import com.inteligr8.solr.model.ExceptionResponse;
 import com.inteligr8.solr.model.core.CreateRequest;
 import com.inteligr8.solr.model.core.ReloadRequest;
@@ -62,7 +63,7 @@ public class ReloadNodeShardWebScript extends AbstractAsieNodeWebScript {
 			throw new WebScriptException(HttpStatus.NOT_FOUND.value(), "The specified node/shard could not be found or formulated");
 			
 		this.logger.info("Reloading core {} on ASIE node: {}", coreName, nodeHostname);
-		CoreAdminApi api = this.createApi(nodeHostname, nodePort);
+		CoreAdminApi api = this.getApiService().createApi(nodeHostname, nodePort, CoreAdminApi.class);
 		try {
 			api.create(new CreateRequest()
 					.withCore(coreName)

enterprise-module/src/main/java/com/inteligr8/alfresco/asie/enterprise/rest/ReloadNodeWebScript.java

@@ -1,4 +1,4 @@
-package com.inteligr8.alfresco.asie.rest;
+package com.inteligr8.alfresco.asie.enterprise.rest;
 
 import java.io.IOException;
 import java.io.Serializable;
@@ -23,6 +23,7 @@ import org.springframework.stereotype.Component;
 
 import com.inteligr8.alfresco.asie.Constants;
 import com.inteligr8.alfresco.asie.api.CoreAdminApi;
+import com.inteligr8.alfresco.asie.rest.AbstractAsieNodeWebScript;
 import com.inteligr8.solr.model.ExceptionResponse;
 import com.inteligr8.solr.model.core.CreateRequest;
 import com.inteligr8.solr.model.core.ReloadRequest;
@@ -63,7 +64,7 @@ public class ReloadNodeWebScript extends AbstractAsieNodeWebScript {
 			String coreInstancePath = core.getValue();
 			
 			this.logger.info("Reloading core {} on ASIE node: {}", coreName, nodeHostname);
-			CoreAdminApi api = this.createApi(nodeHostname, nodePort);
+			CoreAdminApi api = this.getApiService().createApi(nodeHostname, nodePort, CoreAdminApi.class);
 			try {
 				api.create(new CreateRequest()
 						.withCore(coreName)

enterprise-module/src/main/java/com/inteligr8/alfresco/asie/enterprise/rest/UnloadNodeShardWebScript.java

@@ -1,11 +1,11 @@
-package com.inteligr8.alfresco.asie.rest;
+package com.inteligr8.alfresco.asie.enterprise.rest;
 
 import org.alfresco.repo.index.shard.ShardState;
 import org.springframework.extensions.webscripts.WebScriptRequest;
 import org.springframework.stereotype.Component;
 
-import com.inteligr8.alfresco.asie.model.NodeShardParameterSet;
 import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.rest.model.NodeShardParameterSet;
 
 @Component(value = "webscript.com.inteligr8.alfresco.asie.nodeShard.delete")
 public class UnloadNodeShardWebScript extends AbstractUnregisterNodeWebScript<NodeShardParameterSet> {
@@ -20,7 +20,7 @@ public class UnloadNodeShardWebScript extends AbstractUnregisterNodeWebScript<No
 	
 	@Override
 	protected boolean matches(NodeShardParameterSet params, ShardState shardState) {
-		if (!params.getShardSet().isFor(shardState))
+		if (!params.getShardSet().contains(shardState))
 			return false;
 		if (params.getShardId() != shardState.getShardInstance().getShard().getInstance())
 			return false;

enterprise-module/src/main/java/com/inteligr8/alfresco/asie/enterprise/rest/UnloadNodeWebScript.java

@@ -1,9 +1,9 @@
-package com.inteligr8.alfresco.asie.rest;
+package com.inteligr8.alfresco.asie.enterprise.rest;
 
 import org.springframework.extensions.webscripts.WebScriptRequest;
 import org.springframework.stereotype.Component;
 
-import com.inteligr8.alfresco.asie.model.NodeParameterSet;
+import com.inteligr8.alfresco.asie.rest.model.NodeParameterSet;
 
 @Component(value = "webscript.com.inteligr8.alfresco.asie.node.delete")
 public class UnloadNodeWebScript extends AbstractUnregisterNodeWebScript<NodeParameterSet> {

enterprise-module/src/main/java/com/inteligr8/alfresco/asie/enterprise/service/ShardDiscoveryService.java

@@ -0,0 +1,404 @@
+package com.inteligr8.alfresco.asie.enterprise.service;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.alfresco.repo.index.shard.Floc;
+import org.alfresco.repo.index.shard.Shard;
+import org.alfresco.repo.index.shard.ShardInstance;
+import org.alfresco.repo.index.shard.ShardMethodEnum;
+import org.alfresco.repo.index.shard.ShardRegistry;
+import org.alfresco.repo.index.shard.ShardState;
+import org.alfresco.util.Pair;
+import org.alfresco.util.collections.CollectionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+
+import com.inteligr8.alfresco.asie.Constants;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
+
+@Component
+public class ShardDiscoveryService implements com.inteligr8.alfresco.asie.spi.ShardDiscoveryService {
+	
+	private final Logger logger = LoggerFactory.getLogger(this.getClass());
+    
+    @Autowired
+    @Qualifier(Constants.QUALIFIER_ASIE)
+    private ShardRegistry shardRegistry;
+    
+    @Override
+    public ShardSet findSetByCore(String core) {
+		Map<Floc, Map<Shard, Set<ShardState>>> flocs = this.shardRegistry.getFlocs();
+		if (flocs.isEmpty())
+    		return null;
+    	this.logger.trace("Found {} shard sets", flocs.size());
+    	
+		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
+			for (Entry<Shard, Set<ShardState>> flocShard : floc.getValue().entrySet()) {
+				for (ShardState shardState : flocShard.getValue()) {
+					ShardSet shardSet = ShardSet.from(floc.getKey(), shardState);
+					if (shardSet.getCore().equals(core))
+						return shardSet;
+				}
+			}
+		}
+		
+		return null;
+    }
+    
+    @Override
+    public SolrHost findNode(String nodeHostname, int nodePort) {
+		Map<Floc, Map<Shard, Set<ShardState>>> flocs = this.shardRegistry.getFlocs();
+		if (flocs.isEmpty())
+    		return null;
+    	this.logger.trace("Found {} shard sets", flocs.size());
+    	
+    	Map<String, InetAddress> resolvedAddresses = new HashMap<>();
+    	
+		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
+			for (Entry<Shard, Set<ShardState>> flocShard : floc.getValue().entrySet()) {
+				for (ShardState shardState : flocShard.getValue()) {
+					ShardInstance shardInstance = shardState.getShardInstance();
+					if (!nodeHostname.equalsIgnoreCase(shardInstance.getHostName())) {
+						if (!resolvedAddresses.containsKey(nodeHostname))
+							resolvedAddresses.put(nodeHostname, this.resolve(nodeHostname));
+						InetAddress nodeAddress = resolvedAddresses.get(nodeHostname);
+				    	this.logger.trace("Resolved: {} => {}", nodeHostname, nodeAddress);
+						if (nodeAddress == null)
+							continue;
+
+						if (!resolvedAddresses.containsKey(shardInstance.getHostName()))
+							resolvedAddresses.put(shardInstance.getHostName(), this.resolve(shardInstance.getHostName()));
+						InetAddress shardInstanceAddress = resolvedAddresses.get(shardInstance.getHostName());
+				    	this.logger.trace("Resolved: {} => {}", shardInstance.getHostName(), shardInstanceAddress);
+						if (!nodeAddress.equals(shardInstanceAddress))
+							continue;
+					}
+
+					if (nodePort == shardInstance.getPort()) {
+						SolrHost node = SolrHost.from(shardInstance);
+				    	this.logger.debug("Found node: {}", node);
+						return node;
+					}
+				}
+			}
+		}
+		
+		return null;
+    }
+    
+    @Override
+    public Map<ShardSet, Map<Integer, ShardInstanceState>> findByNode(SolrHost node) {
+		Map<Floc, Map<Shard, Set<ShardState>>> flocs = this.shardRegistry.getFlocs();
+		if (flocs.isEmpty())
+    		return Collections.emptyMap();
+    	this.logger.trace("Found {} shard sets", flocs.size());
+		
+    	Map<ShardSet, Map<Integer, ShardInstanceState>> setShardStates = new HashMap<>();
+    	
+		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet())
+			setShardStates.putAll(this.findByNode(node, floc.getKey(), floc.getValue()));
+
+		return setShardStates;
+    }
+    
+    private Map<ShardSet, Map<Integer, ShardInstanceState>> findByNode(SolrHost node, Floc floc, Map<Shard, Set<ShardState>> shards) {
+    	ShardSet shardSet = null;
+    	Map<ShardSet, Map<Integer, ShardInstanceState>> setShardStates = new HashMap<>();
+    	int shardStateCount = 0;
+    	
+		for (Entry<Shard, Set<ShardState>> flocShard : shards.entrySet()) {
+			for (ShardState shardState : flocShard.getValue()) {
+				if (shardSet == null)
+					shardSet = ShardSet.from(floc, shardState);
+				
+				ShardInstance shardInstance = shardState.getShardInstance();
+				if (node.equals(SolrHost.from(shardInstance))) {
+					Map<Integer, ShardInstanceState> shardStates = setShardStates.get(shardSet);
+					if (shardStates == null)
+						setShardStates.put(shardSet, shardStates = new HashMap<>());
+					shardStates.put(flocShard.getKey().getInstance(), ShardInstanceState.from(shardState));
+					shardStateCount++;
+				}
+			}
+		}
+
+    	this.logger.debug("Found {} shard states for node: {}", shardStateCount, node);
+		return setShardStates;
+    }
+    
+    @Override
+    public Set<ShardSet> findSetsByShardMethod(ShardMethodEnum... shardMethods) {
+		Map<Floc, Map<Shard, Set<ShardState>>> flocs = this.shardRegistry.getFlocs();
+		if (flocs.isEmpty())
+			return Collections.emptySet();
+    	this.logger.trace("Found {} shard sets", flocs.size());
+    	
+    	Set<ShardMethodEnum> shardMethodSet = CollectionUtils.asSet(shardMethods);
+    	Set<ShardSet> shardSets = new HashSet<>();
+		
+		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
+			if (shardMethodSet.contains(floc.getKey().getShardMethod())) {
+				ShardState shardState = this.extractAnyShardState(floc.getValue());
+				shardSets.add(ShardSet.from(floc.getKey(), shardState));
+			}
+		}
+
+    	this.logger.debug("Found {} shard sets of methods: {}", flocs.size(), shardMethods);
+		return shardSets;
+    }
+    
+    @Override
+    public Set<SolrHost> findNodes(ShardSet shardSet) {
+		Map<Floc, Map<Shard, Set<ShardState>>> flocs = this.shardRegistry.getFlocs();
+		if (flocs.isEmpty())
+			return Collections.emptySet();
+    	this.logger.trace("Found {} shard sets", flocs.size());
+		
+		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
+			Set<SolrHost> nodes = this.findNodes(shardSet, null, floc.getKey(), floc.getValue());
+			if (nodes != null) {
+		    	this.logger.debug("Found {} nodes for set: {}", nodes.size(), shardSet);
+				return nodes;
+			}
+		}
+
+    	this.logger.debug("Found {} nodes for set: {}", 0, shardSet);
+		return Collections.emptySet();
+    }
+    
+    @Override
+    public Set<SolrHost> findNodesByShard(ShardSet shardSet, int shardId) {
+		Map<Floc, Map<Shard, Set<ShardState>>> flocs = this.shardRegistry.getFlocs();
+		if (flocs.isEmpty())
+			return Collections.emptySet();
+    	this.logger.trace("Found {} shard sets", flocs.size());
+		
+		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
+			Set<SolrHost> nodes = this.findNodes(shardSet, shardId, floc.getKey(), floc.getValue());
+			if (nodes != null) {
+		    	this.logger.debug("Found {} nodes for shard #{} in set: {}", nodes.size(), shardId, shardSet);
+				return nodes;
+			}
+		}
+
+    	this.logger.debug("Found {} nodes for shard #{} in set: {}", 0, shardId, shardSet);
+		return Collections.emptySet();
+    }
+    
+    private Set<SolrHost> findNodes(ShardSet shardSet, Integer shardId, Floc floc, Map<Shard, Set<ShardState>> shards) {
+    	Set<SolrHost> nodes = new HashSet<>();
+    	boolean checked = false;
+
+		for (Entry<Shard, Set<ShardState>> shard : shards.entrySet()) {
+			if (shardId == null || shardId.intValue() == shard.getKey().getInstance()) {
+				for (ShardState shardState : shard.getValue()) {
+					if (!checked && !shardSet.equals(ShardSet.from(floc, shardState)))
+						return null;
+					checked = true;
+					
+					ShardInstance shardInstance = shardState.getShardInstance();
+					SolrHost node = SolrHost.from(shardInstance);
+					nodes.add(node);
+				}
+			}
+		}
+
+		return nodes;
+    }
+    
+    @Override
+    public Map<Integer, Pair<SolrHost, ShardInstanceState>> findLatestNodeStates(ShardSet shardSet) {
+		Map<Floc, Map<Shard, Set<ShardState>>> flocs = this.shardRegistry.getFlocs();
+		if (flocs.isEmpty())
+			return Collections.emptyMap();
+    	this.logger.trace("Found {} shard sets", flocs.size());
+		
+		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
+			Map<Integer, Pair<SolrHost, ShardInstanceState>> shardNodeStates = this.findLatestNodeStates(shardSet, floc.getKey(), floc.getValue());
+			if (shardNodeStates != null) {
+		    	this.logger.debug("Found {} shard node states for set: {}", shardNodeStates.size(), shardSet);
+				return shardNodeStates;
+			}
+		}
+
+    	this.logger.debug("Found {} shard node states for set: {}", 0, shardSet);
+		return Collections.emptyMap();
+    }
+    
+    private Map<Integer, Pair<SolrHost, ShardInstanceState>> findLatestNodeStates(ShardSet shardSet, Floc floc, Map<Shard, Set<ShardState>> shards) {
+    	Map<Integer, Pair<SolrHost, ShardInstanceState>> shardNodeStates = new HashMap<>();
+    	boolean checked = false;
+    	
+    	com.inteligr8.alfresco.asie.spi.ShardDiscoveryService.ShardedNodeShardStateComparator comparator = new com.inteligr8.alfresco.asie.spi.ShardDiscoveryService.ShardedNodeShardStateComparator();
+
+		for (Entry<Shard, Set<ShardState>> shard : shards.entrySet()) {
+			int shardId = shard.getKey().getInstance();
+			for (ShardState shardState : shard.getValue()) {
+				if (!checked && !shardSet.equals(ShardSet.from(floc, shardState)))
+					return null;
+				checked = true;
+				
+				ShardInstance shardInstance = shardState.getShardInstance();
+				SolrHost node = SolrHost.from(shardInstance);
+				ShardInstanceState nodeShardState = ShardInstanceState.from(shardState);
+				
+				Pair<SolrHost, ShardInstanceState> pair = new Pair<>(node, nodeShardState);
+				if (comparator.compare(pair, shardNodeStates.get(shardId)) < 0)
+					shardNodeStates.put(shardId, pair);
+			}
+		}
+
+		return shardNodeStates;
+    }
+    
+    @Override
+    public List<Pair<SolrHost, ShardInstanceState>> findNodeStatesByShard(ShardSet shardSet, int shardId) {
+		Map<Floc, Map<Shard, Set<ShardState>>> flocs = this.shardRegistry.getFlocs();
+		if (flocs.isEmpty())
+			return Collections.emptyList();
+    	this.logger.trace("Found {} shard sets", flocs.size());
+		
+		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
+			List<Pair<SolrHost, ShardInstanceState>> nodeStates = this.findNodeStates(shardSet, shardId, floc.getKey(), floc.getValue());
+			if (nodeStates != null) {
+		    	this.logger.debug("Found {} node states for shard #{} in set: {}", nodeStates.size(), shardId, shardSet);
+				return nodeStates;
+			}
+		}
+
+    	this.logger.debug("Found {} node states for shard #{} in set: {}", 0, shardId, shardSet);
+		return Collections.emptyList();
+    }
+    
+    private List<Pair<SolrHost, ShardInstanceState>> findNodeStates(ShardSet shardSet, Integer shardId, Floc floc, Map<Shard, Set<ShardState>> shards) {
+    	List<Pair<SolrHost, ShardInstanceState>> nodeStates = new LinkedList<>();
+    	boolean checked = false;
+
+		for (Entry<Shard, Set<ShardState>> shard : shards.entrySet()) {
+			if (shardId == null || shardId.intValue() == shard.getKey().getInstance()) {
+				for (ShardState shardState : shard.getValue()) {
+					if (!checked && !shardSet.equals(ShardSet.from(floc, shardState)))
+						return null;
+					checked = true;
+					
+					ShardInstance shardInstance = shardState.getShardInstance();
+					SolrHost node = SolrHost.from(shardInstance);
+					ShardInstanceState nodeShardState = ShardInstanceState.from(shardState);
+					nodeStates.add(new Pair<>(node, nodeShardState));
+				}
+			}
+		}
+
+		return nodeStates;
+    }
+    
+    @Override
+    public Set<Integer> findIdsByNode(ShardSet shardSet, SolrHost node) {
+		Map<Floc, Map<Shard, Set<ShardState>>> flocs = this.shardRegistry.getFlocs();
+		if (flocs.isEmpty())
+			return Collections.emptySet();
+    	this.logger.trace("Found {} shard sets", flocs.size());
+		
+		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
+			Set<Integer> shardIds = this.findIdsByNode(shardSet, node, floc.getKey(), floc.getValue());
+			if (shardIds != null) {
+		    	this.logger.debug("Found {} shards for node '{}' in set: {}", shardIds.size(), node, shardSet);
+				return shardIds;
+			}
+		}
+
+    	this.logger.debug("Found {} node states for node '{}' in set: {}", 0, node, shardSet);
+		return Collections.emptySet();
+    }
+    
+    private Set<Integer> findIdsByNode(ShardSet shardSet, SolrHost node, Floc floc, Map<Shard, Set<ShardState>> shards) {
+    	Set<Integer> shardIds = new HashSet<>();
+    	boolean checked = false;
+
+		for (Entry<Shard, Set<ShardState>> shard : shards.entrySet()) {
+			for (ShardState shardState : shard.getValue()) {
+				if (!checked && !shardSet.equals(ShardSet.from(floc, shardState)))
+					return null;
+				checked = true;
+				
+				ShardInstance shardInstance = shardState.getShardInstance();
+				if (node.equals(SolrHost.from(shardInstance)))
+					shardIds.add(shard.getKey().getInstance());
+			}
+		}
+
+		return shardIds;
+    }
+    
+    @Override
+    public Map<Integer, ShardInstanceState> findStatesByNode(ShardSet shardSet, SolrHost node) {
+		Map<Floc, Map<Shard, Set<ShardState>>> flocs = this.shardRegistry.getFlocs();
+		if (flocs.isEmpty())
+			return Collections.emptyMap();
+    	this.logger.trace("Found {} shard sets", flocs.size());
+		
+		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
+			Map<Integer, ShardInstanceState> shardStates = this.findStatesByNode(shardSet, node, floc.getKey(), floc.getValue());
+			if (shardStates != null) {
+		    	this.logger.debug("Found {} shard states for node '{}' in set: {}", shardStates.size(), node, shardSet);
+				return shardStates;
+			}
+		}
+
+    	this.logger.debug("Found {} shard states for node '{}' in set: {}", 0, node, shardSet);
+		return Collections.emptyMap();
+    }
+    
+    private Map<Integer, ShardInstanceState> findStatesByNode(ShardSet shardSet, SolrHost node, Floc floc, Map<Shard, Set<ShardState>> shards) {
+    	Map<Integer, ShardInstanceState> shardStates = new HashMap<>();
+    	boolean checked = false;
+
+		for (Entry<Shard, Set<ShardState>> shard : shards.entrySet()) {
+			for (ShardState shardState : shard.getValue()) {
+				if (!checked && !shardSet.equals(ShardSet.from(floc, shardState)))
+					return null;
+				checked = true;
+				
+				ShardInstance shardInstance = shardState.getShardInstance();
+				if (node.equals(SolrHost.from(shardInstance)))
+					shardStates.put(shard.getKey().getInstance(), ShardInstanceState.from(shardState));
+			}
+		}
+
+		return shardStates;
+    }
+    
+    private ShardState extractAnyShardState(Map<Shard, Set<ShardState>> shards) {
+		if (shards.isEmpty())
+			return null;
+		
+		for (Set<ShardState> shardStates : shards.values())
+			for (ShardState shardState : shardStates)
+				return shardState;
+		
+		return null;
+    }
+    
+    private InetAddress resolve(String hostname) {
+    	try {
+    		return InetAddress.getByName(hostname);
+    	} catch (UnknownHostException uhe) {
+    		return null;
+    	}
+    }
+    
+}

enterprise-module/src/main/java/com/inteligr8/alfresco/asie/enterprise/service/ShardStateService.java

@@ -34,7 +34,8 @@ public class ShardStateService implements com.inteligr8.alfresco.asie.spi.ShardS
 	@Autowired
 	@Qualifier(Constants.BEAN_SHARD_GUID_CACHE)
     private SimpleCache<ShardInstance, String> shardToGuidCache;
-	
+
+	@Override
 	public void clear() {
 		this.logger.info("Removing all nodes/shards from the shard registry");
 		
@@ -76,7 +77,7 @@ public class ShardStateService implements com.inteligr8.alfresco.asie.spi.ShardS
 			this.shardToGuidCache.remove(shardState.getShardInstance());
 		}
 	}
-	
+
 	public void iterate(AttributeQueryCallback callback) {
 		this.attrService.getAttributes(callback, EnterpriseConstants.ATTR_SHARD_STATE);
 	}

enterprise-module/src/main/resources/alfresco/module/com_inteligr8_alfresco_asie-enterprise-platform-module/log4j2.properties

@@ -1,3 +1,3 @@
 
-logger.inteligr8-asie.name=com.inteligr8.alfresco.asie.enterprise
-logger.inteligr8-asie.level=INFO
+logger.inteligr8-asie-ent.name=com.inteligr8.alfresco.asie.enterprise
+logger.inteligr8-asie-ent.level=INFO

pom.xml

@@ -5,7 +5,7 @@
 	
 	<groupId>com.inteligr8.alfresco</groupId>
 	<artifactId>asie-platform-module-parent</artifactId>
-	<version>1.1.0</version>
+	<version>1.2.2</version>
 	<packaging>pom</packaging>
 	
 	<name>ASIE Platform Module Parent</name>
@@ -39,9 +39,9 @@
 
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<maven.compiler.source>11</maven.compiler.source>
-		<maven.compiler.target>11</maven.compiler.target>
-		<maven.compiler.release>11</maven.compiler.release>
+		<maven.compiler.source>17</maven.compiler.source>
+		<maven.compiler.target>17</maven.compiler.target>
+		<maven.compiler.release>17</maven.compiler.release>
 		<maven.deploy.skip>true</maven.deploy.skip>
 	</properties>
 
@@ -56,12 +56,34 @@
 				<!-- avoids struts dependency -->
 				<plugin>
 					<artifactId>maven-site-plugin</artifactId>
-					<version>3.12.1</version>
+					<version>3.21.0</version>
 				</plugin>
 				<!-- Force use of a new maven-dependency-plugin that doesn't download struts dependency -->
 				<plugin>
 					<artifactId>maven-dependency-plugin</artifactId>
-					<version>3.8.0</version>
+					<version>3.8.1</version>
+				</plugin>
+				<plugin>
+					<artifactId>maven-surefire-plugin</artifactId>
+					<version>3.4.0</version>
+					<dependencies>
+						<dependency>
+							<groupId>org.junit.jupiter</groupId>
+							<artifactId>junit-jupiter-engine</artifactId>
+							<version>5.11.0</version>
+						</dependency>
+					</dependencies>
+				</plugin>
+				<plugin>
+					<artifactId>maven-failsafe-plugin</artifactId>
+					<version>3.4.0</version>
+					<dependencies>
+						<dependency>
+							<groupId>org.junit.jupiter</groupId>
+							<artifactId>junit-jupiter-engine</artifactId>
+							<version>5.11.0</version>
+						</dependency>
+					</dependencies>
 				</plugin>
 			</plugins>
 		</pluginManagement>

shared/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>com.inteligr8.alfresco</groupId>
 		<artifactId>asie-platform-module-parent</artifactId>
-		<version>1.1.0</version>
+		<version>1.2.2</version>
 		<relativePath>../</relativePath>
 	</parent>
 
@@ -16,7 +16,7 @@
 	<name>ASIE Shared Library for Platform Modules</name>
 
 	<properties>
-		<alfresco.sdk.version>5.2.0</alfresco.sdk.version>
+		<alfresco.sdk.version>4.9.0</alfresco.sdk.version>
 		<alfresco.platform.version>23.3.0</alfresco.platform.version>
 	</properties>
 
@@ -41,10 +41,15 @@
 		<dependency>
 			<groupId>com.inteligr8</groupId>
 			<artifactId>common-rest-client</artifactId>
-			<version>3.0.1-cxf</version>
+			<version>3.0.3-cxf</version>
 		</dependency>
 		
 		<!-- Needed by this module, but provided by ACS -->
+		<dependency>
+			<groupId>org.alfresco</groupId>
+			<artifactId>alfresco-data-model</artifactId>
+			<scope>provided</scope>
+		</dependency>
 		<dependency>
 			<groupId>org.alfresco</groupId>
 			<artifactId>alfresco-repository</artifactId>

shared/src/main/java/com/inteligr8/alfresco/asie/Constants.java

@@ -2,22 +2,19 @@ package com.inteligr8.alfresco.asie;
 
 public interface Constants {
 	
+	static final String NAMESPACE_ASIE = "http://inteligr8.com/alfresco/asie";
+	
 	static final String QUALIFIER_ASIE = "asie";
 
-	// OOTB
+	// defined OOTB
 	static final String BEAN_SHARD_STATE_CACHE = "shardStateCache";
 	static final String BEAN_SHARD_GUID_CACHE = "shardToGuidCache";
 
-	static final String BEAN_OFFILINE_SHARD_STATE_CACHE = "offlineShardStateCache";
-	static final String BEAN_CORE_EXPLICIT_CACHE = "coreExplicitIdCache";
+	static final String BEAN_SHARD_REGISTRY = "asie.ShardRegistry";
 	static final String BEAN_OBJECT_MAPPER = "asie.ObjectMapper";
 	static final String BEAN_ATTRIBUTE_SERVICE = "asie.AttributeService";
-	static final String BEAN_SHARD_REGISTRY = "asie.ShardRegistry";
 
 	static final String ATTR_ASIE = "inteligr8.asie";
-	static final String ATTR_ASIE_NODES = "inteligr8.asie.nodes";
-	static final String ATTR_STATE = "state";
-	static final String ATTR_ONLINE = "online";
 	static final String ATTR_UNLOADED = "unloadedNode.cores";
 
 }

shared/src/main/java/com/inteligr8/alfresco/asie/SimpleCaster.java

@@ -0,0 +1,48 @@
+package com.inteligr8.alfresco.asie;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+
+public class SimpleCaster {
+	
+	public static <T> T transform(String str, Class<T> returnType) {
+		if (str == null)
+			return null;
+		
+		if (returnType.isAssignableFrom(String.class)) {
+			@SuppressWarnings("unchecked")
+			T t = (T) str;
+			return t;
+		}
+		
+		try {
+			Constructor<T> constructor = returnType.getConstructor(String.class);
+			return constructor.newInstance(str);
+		} catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
+			// suppress
+		}
+		
+		for (String staticMethod : Arrays.asList("from", "valueOf")) {
+			try {
+				return invoke(returnType, staticMethod, str);
+			} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+				// suppress
+			}
+		}
+		
+		throw new IllegalArgumentException();
+	}
+
+	private static <T> T invoke(Class<T> returnType, String staticMethodName, Object... arguments) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+		Method method = returnType.getDeclaredMethod(staticMethodName, String.class);
+		if (!returnType.isAssignableFrom(method.getReturnType()))
+			throw new NoSuchMethodException();
+		
+		@SuppressWarnings("unchecked")
+		T t = (T) method.invoke(null, arguments);
+		return t;
+	}	
+
+}

shared/src/main/java/com/inteligr8/alfresco/asie/model/Node.java

@@ -1,56 +0,0 @@
-package com.inteligr8.alfresco.asie.model;
-
-import java.io.Serializable;
-
-import org.alfresco.repo.index.shard.ShardInstance;
-
-public class Node implements Serializable {
-	
-	private static final long serialVersionUID = -8834744746109388928L;
-	
-	private final String id;
-	private final ShardInstance shardNode;
-	
-	public Node(ShardInstance shardNode) {
-		this.shardNode = shardNode;
-		this.id = this.getHostname() + ":" + this.getPort() + this.getPath();
-	}
-	
-	public String getId() {
-		return this.id;
-	}
-	
-	public String getHostname() {
-		return this.shardNode.getHostName();
-	}
-	
-	public int getPort() {
-		return this.shardNode.getPort();
-	}
-	
-	public String getPath() {
-		// baseUrl is to the shard; we want to the node, so exclude the core
-		int lastSlash = this.shardNode.getBaseUrl().lastIndexOf('/');
-		return this.shardNode.getBaseUrl().substring(0, lastSlash);
-	}
-	
-	@Override
-	public boolean equals(Object obj) {
-		if (!(obj instanceof Node))
-			return false;
-		
-		Node node = (Node) obj;
-		return this.id.equals(node.id);
-	}
-	
-	@Override
-	public int hashCode() {
-		return this.id.hashCode();
-	}
-	
-	@Override
-	public String toString() {
-		return this.id;
-	}
-
-}

shared/src/main/java/com/inteligr8/alfresco/asie/model/PersistedNode.java

@@ -0,0 +1,36 @@
+package com.inteligr8.alfresco.asie.model;
+
+import java.io.Serializable;
+
+public class PersistedNode implements Serializable {
+		
+    private static final long serialVersionUID = 4105196543023419818L;
+    
+    private final SolrHost node;
+    private final long persistMillis;
+    private long expireTimeMillis;
+    
+    public PersistedNode(SolrHost node, int persistMinutes) {
+        this.node = node;
+        this.persistMillis = persistMinutes * 60L * 1000L;
+        this.reset();
+    }
+    
+    public void reset() {
+        this.expireTimeMillis = System.currentTimeMillis() + this.persistMillis;
+    }
+    
+    public boolean isExpired() {
+        return this.expireTimeMillis < System.currentTimeMillis();
+    }
+    
+    public SolrHost getNode() {
+        return this.node;
+    }
+    
+    @Override
+    public String toString() {
+        return "node: " + this.node + "; expires in: " + (System.currentTimeMillis() - this.expireTimeMillis) + " ms";
+    }
+    
+}

shared/src/main/java/com/inteligr8/alfresco/asie/model/RequestParameterSet.java

@@ -1,5 +0,0 @@
-package com.inteligr8.alfresco.asie.model;
-
-public interface RequestParameterSet {
-
-}

shared/src/main/java/com/inteligr8/alfresco/asie/model/Shard.java

@@ -0,0 +1,72 @@
+package com.inteligr8.alfresco.asie.model;
+
+import java.io.Serializable;
+
+import org.alfresco.repo.index.shard.Floc;
+
+public class Shard implements Serializable {
+	
+	private static final long serialVersionUID = 5683743181748541736L;
+
+	public static Shard from(ShardSet shardSet, int shardId) {
+		return new Shard(shardSet, shardId);
+	}
+
+	public static Shard from(String spec) {
+		return new Shard(spec);
+	}
+	
+	private final String spec;
+	
+	protected Shard(ShardSet shardSet, int shardId) {
+		this.spec = shardSet.getCore() + "-" + shardId;
+	}
+	
+	protected Shard(String spec) {
+		this.spec = spec;
+	}
+	
+	public org.alfresco.repo.index.shard.Shard toAlfrescoModel(Floc floc) {
+		org.alfresco.repo.index.shard.Shard shard = new org.alfresco.repo.index.shard.Shard();
+		shard.setFloc(floc);
+		shard.setInstance(this.extractShardId());
+		return shard;
+	}
+	
+	public String getSpec() {
+		return this.spec;
+	}
+	
+	public String getCoreName() {
+		return this.spec;
+	}
+	
+	public String extractShardSetCore() {
+		int pos = this.spec.lastIndexOf('-');
+		return this.spec.substring(0, pos);
+	}
+	
+	public int extractShardId() {
+		int pos = this.spec.lastIndexOf('-');
+		return Integer.parseInt(this.spec.substring(pos+1));
+	}
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (!(obj instanceof Shard))
+			return false;
+		Shard shard = (Shard) obj;
+		return this.spec.equals(shard.spec);
+	}
+	
+	@Override
+	public int hashCode() {
+		return this.spec.hashCode();
+	}
+	
+	@Override
+	public String toString() {
+		return this.spec;
+	}
+
+}

shared/src/main/java/com/inteligr8/alfresco/asie/model/ShardInstance.java

@@ -0,0 +1,64 @@
+package com.inteligr8.alfresco.asie.model;
+
+import java.io.Serializable;
+
+public class ShardInstance implements Serializable {
+	
+	private static final long serialVersionUID = 7455521296197234581L;
+
+	public static ShardInstance from(Shard shard, SolrHost node) {
+		return new ShardInstance(shard, node);
+	}
+	
+	private final String spec;
+	
+	protected ShardInstance(Shard shard, SolrHost node) {
+		this.spec =  node.getSpec() + "~" + shard.getSpec();
+	}
+	
+	public org.alfresco.repo.index.shard.ShardInstance toAlfrescoModel(org.alfresco.repo.index.shard.Shard shard) {
+		SolrHost node = this.extractNode();
+		
+		String core = shard.getFloc().getPropertyBag().get("coreName");
+		
+		org.alfresco.repo.index.shard.ShardInstance shardInstance = new org.alfresco.repo.index.shard.ShardInstance();
+		shardInstance.setHostName(node.getHostname());
+		shardInstance.setPort(node.getPort());
+		shardInstance.setBaseUrl(node.getPath() + "/" + core + "-" + shard.getInstance());
+		shardInstance.setShard(shard);
+		return shardInstance;
+	}
+	
+	public String getSpec() {
+		return spec;
+	}
+	
+	public SolrHost extractNode() {
+		int pos = this.spec.indexOf('~');
+		return SolrHost.from(this.spec.substring(0, pos));
+	}
+	
+	public Shard extractShard() {
+		int pos = this.spec.indexOf('~');
+		return Shard.from(this.spec.substring(pos+1));
+	}
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (!(obj instanceof ShardInstance))
+			return false;
+		ShardInstance shard = (ShardInstance) obj;
+		return this.spec.equals(shard.spec);
+	}
+	
+	@Override
+	public int hashCode() {
+		return this.spec.hashCode();
+	}
+	
+	@Override
+	public String toString() {
+		return this.spec;
+	}
+
+}

shared/src/main/java/com/inteligr8/alfresco/asie/model/ShardInstanceState.java

@@ -0,0 +1,102 @@
+package com.inteligr8.alfresco.asie.model;
+
+import java.io.Serializable;
+import java.time.Instant;
+import java.time.OffsetDateTime;
+import java.time.ZoneOffset;
+import java.util.Map.Entry;
+
+import org.alfresco.repo.index.shard.ShardInstance;
+import org.alfresco.repo.index.shard.ShardState;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+
+public class ShardInstanceState implements Serializable, Comparable<ShardInstanceState> {
+	
+	private static final long serialVersionUID = 2893797002689889478L;
+
+	public static ShardInstanceState from(ShardState shardState) {
+		return new ShardInstanceState(shardState);
+	}
+
+	private final OffsetDateTime lastUpdated;
+	private final long lastIndexedChangeSetId;
+	private final OffsetDateTime lastIndexedChangeSetTime;
+	private final long lastIndexedTxId;
+	private final OffsetDateTime lastIndexedTxTime;
+	private transient Integer hash = null;
+	
+	private ShardInstanceState(ShardState shardState) {
+		this.lastUpdated = Instant.ofEpochMilli(shardState.getLastUpdated()).atOffset(ZoneOffset.UTC);
+		this.lastIndexedChangeSetId = shardState.getLastIndexedChangeSetId();
+		this.lastIndexedChangeSetTime = Instant.ofEpochMilli(shardState.getLastIndexedChangeSetCommitTime()).atOffset(ZoneOffset.UTC);
+		this.lastIndexedTxId = shardState.getLastIndexedTxId();
+		this.lastIndexedTxTime = Instant.ofEpochMilli(shardState.getLastIndexedTxCommitTime()).atOffset(ZoneOffset.UTC);
+	}
+	
+	public ShardState toAlfrescoModel(ShardInstance shardInstance) {
+		ShardState state = new ShardState();
+		state.setLastIndexedChangeSetCommitTime(this.lastIndexedChangeSetTime.toInstant().toEpochMilli());
+		state.setLastIndexedChangeSetId(this.lastIndexedChangeSetId);
+		state.setLastIndexedTxCommitTime(this.lastIndexedTxTime.toInstant().toEpochMilli());
+		state.setLastIndexedTxId(this.lastIndexedTxId);
+		state.setLastUpdated(this.lastUpdated.toInstant().toEpochMilli());
+		state.setShardInstance(shardInstance);
+		
+		for (Entry<String, String> prop : shardInstance.getShard().getFloc().getPropertyBag().entrySet())
+			if (prop.getKey().startsWith("shard."))
+				state.getPropertyBag().put(prop.getKey(), prop.getValue());
+		String core = shardInstance.getShard().getFloc().getPropertyBag().get("coreName");
+		if (core != null)
+			state.getPropertyBag().put("coreName", core + "-" + shardInstance.getShard().getInstance());
+		
+		return state;
+	}
+	
+	public OffsetDateTime getLastUpdated() {
+		return lastUpdated;
+	}
+	
+	public long getLastIndexedChangeSetId() {
+		return lastIndexedChangeSetId;
+	}
+	
+	public OffsetDateTime getLastIndexedChangeSetTime() {
+		return lastIndexedChangeSetTime;
+	}
+	
+	public long getLastIndexedTxId() {
+		return lastIndexedTxId;
+	}
+	
+	public OffsetDateTime getLastIndexedTxTime() {
+		return lastIndexedTxTime;
+	}
+	
+	@Override
+	public int compareTo(ShardInstanceState o) {
+		return -this.lastUpdated.compareTo(o.lastUpdated);
+	}
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (!(obj instanceof ShardInstanceState))
+			return false;
+		ShardInstanceState snss = (ShardInstanceState) obj;
+		
+		return this.lastIndexedChangeSetId == snss.lastIndexedChangeSetId &&
+				this.lastIndexedTxId ==  snss.lastIndexedTxId;
+	}
+	
+	@Override
+	public int hashCode() {
+		if (this.hash == null) {
+			this.hash = new HashCodeBuilder()
+					.append(this.lastIndexedTxId)
+					.append(this.lastIndexedChangeSetId)
+					.build();
+		}
+		
+		return this.hash.intValue();
+	}
+
+}

shared/src/main/java/com/inteligr8/alfresco/asie/model/ShardSet.java

@@ -1,53 +1,194 @@
 package com.inteligr8.alfresco.asie.model;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.regex.Matcher;
+import java.io.Serializable;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.regex.Pattern;
 
 import org.alfresco.repo.index.shard.Floc;
 import org.alfresco.repo.index.shard.ShardMethodEnum;
 import org.alfresco.repo.index.shard.ShardState;
-import org.apache.commons.lang3.builder.HashCodeBuilder;
+import org.alfresco.service.cmr.repository.StoreRef;
+import org.alfresco.util.collections.CollectionUtils;
+import org.apache.commons.collections4.map.CompositeMap;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.Pair;
 
-public class ShardSet {
+import com.inteligr8.alfresco.asie.SimpleCaster;
+
+public class ShardSet implements Serializable {
 	
-	/**
-	 * Examples:
-	 * 
-	 * MOD_ACL_ID
-	 * ACL_ID
-	 * DB_ID
-	 * DB_ID_RANGE;range:0-20000
-	 * DATE;key:cm:created
-	 * DATE;key:cm:created;date.grouping:3
-	 * PROPERTY;key:cm:created;regex:^d{4}
-	 */
-	private final Pattern shardSetPattern = Pattern.compile("([A-Z]+)(;fulltext)?(;([a-z]+):([^;]+))?(;([a-z]+):([^;]+))?");
+	private static final long serialVersionUID = -8891094367429601316L;
+	private static final String DEFAULT_SOLR_TEMPLATE = "rerank";
 	
-	private final ShardMethodEnum method;
-	private final boolean hasContent;
-	private final Map<String, String> config;
-	private Integer hash;
-	
-	public ShardSet(Floc floc, ShardState anyShardNode) {
-		this.method = floc.getShardMethod();
-		this.hasContent = floc.hasContent();
-		this.config = (floc.getPropertyBag().isEmpty() && anyShardNode != null) ? anyShardNode.getPropertyBag() : floc.getPropertyBag(); 
+	public static ShardSet from(Floc floc, ShardState anyShardState) {
+		return new ShardSet(floc, anyShardState);
 	}
 	
-	public ShardSet(String shardSetSpec) {
-    	Matcher matcher = this.shardSetPattern.matcher(shardSetSpec);
-    	if (!matcher.find())
-    		throw new IllegalArgumentException("The shard set '" + shardSetSpec + "' is not properly formatted");
-    	
-    	this.method = ShardMethodEnum.valueOf(matcher.group(1));
-    	this.hasContent = ";fulltext".equals(matcher.group(2));
-    	this.config = new HashMap<>();
-    	for (int g = 3; g < matcher.groupCount(); g += 3)
-    		if (matcher.group(g) != null)
-    			this.config.put("shard." + matcher.group(g+1), matcher.group(g+2));
+	public static ShardSet from(String coreName, String spec) {
+		return new ShardSet(coreName, spec);
+	}
+
+	private final String core;
+	private final ShardMethodEnum method;
+	private final boolean hasContent;
+	private final String template;
+	private final Set<StoreRef> storeRefs;
+	private final Short shards;
+	private final Pair<Long, Long> range;
+	private final Byte dateGrouping;
+	private final String prefixedProperty;
+	private final Pattern regex;
+	private transient String spec;
+	
+	private ShardSet(Floc floc, ShardState anyShardNode) {
+		String shardCoreName = anyShardNode.getPropertyBag().get("coreName");
+		int lastDash = shardCoreName.lastIndexOf('-');
+		this.core = shardCoreName.substring(0, lastDash);
+		
+		this.method = floc.getShardMethod();
+		this.hasContent = floc.hasContent();
+		this.template = floc.getTemplate();
+		this.storeRefs = floc.getStoreRefs();
+		CompositeMap<String, String> propbag = new CompositeMap<>(floc.getPropertyBag(), anyShardNode.getPropertyBag());
+
+		Short shards = null;
+		Pair<Long, Long> range = null;
+		Byte dateGrouping = null;
+		String prefixedProperty = null;
+		String regex = null;
+		
+		switch (this.method) {
+			case DB_ID_RANGE:
+				range = this.strToRange(propbag.get("shard.range"));
+				break;
+			case DATE:
+				dateGrouping = SimpleCaster.transform(propbag.get("shard.date.grouping"), Byte.class);
+			case PROPERTY:
+			case EXPLICIT_ID:
+				prefixedProperty = StringUtils.trimToNull(propbag.get("shard.key"));
+				regex = StringUtils.trimToNull(propbag.get("shard.regex"));
+			default:
+				shards = (short) floc.getNumberOfShards();
+		}
+		
+		this.range = range;
+		this.shards = shards;
+		this.dateGrouping = dateGrouping;
+		this.prefixedProperty = prefixedProperty;
+		this.regex = regex == null ? null : Pattern.compile(regex);
+	}
+	
+	public Floc toAlfrescoModel() {
+		Floc floc = new Floc();
+		floc.setShardMethod(this.method);
+		floc.setHasContent(this.hasContent);
+		floc.setTemplate(this.template);
+		floc.setStoreRefs(new HashSet<>(this.storeRefs));
+		floc.getPropertyBag().put("coreName", this.core);
+		
+		switch (this.method) {
+			case DB_ID_RANGE:
+				floc.getPropertyBag().put("shard.range", this.range.getLeft() + "-" + this.range.getRight());
+				break;
+			case DATE:
+				if (this.dateGrouping != null)
+					floc.getPropertyBag().put("shard.date.grouping", this.dateGrouping.toString());
+			case PROPERTY:
+			case EXPLICIT_ID:
+				floc.getPropertyBag().put("shard.key", this.prefixedProperty);
+				if (this.regex != null)
+					floc.getPropertyBag().put("shard.regex", this.regex.pattern());
+			default:
+				if (this.shards != null)
+					floc.setNumberOfShards(this.shards.intValue());
+		}
+		
+		return floc;
+	}
+	
+	private ShardSet(String coreName, String shardSetSpec) {
+		String[] parts = shardSetSpec.split("[;|_]");
+		if (parts.length == 0)
+			throw new IllegalArgumentException();
+		
+		this.core = coreName;
+		this.method = ShardMethodEnum.valueOf(parts[0].toUpperCase());
+		
+		boolean hasContent = false;
+		String template = DEFAULT_SOLR_TEMPLATE;
+		StoreRef storeRef = StoreRef.STORE_REF_WORKSPACE_SPACESSTORE;
+		Pair<Long, Long> range = null;
+		Short shards = null;
+		Byte dateGrouping = null;
+		String prefixedProperty = null;
+		String regex = null;
+		
+		for (int i = 1; i < parts.length; i++) {
+			int colon = parts[i].indexOf(":");
+			String fieldName = colon < 0 ? parts[i] : parts[i].substring(0, colon);
+			String fieldValue = colon < 0 ? null : parts[i].substring(colon+1);
+			
+			switch (fieldName) {
+				case "txt":
+				case "text":
+				case "fulltext":
+				case "content":
+				case "hasContent":
+				case "hasText":
+					hasContent = true;
+					break;
+				case "t":
+				case "template":
+					template = fieldValue;
+					break;
+				case "sref":
+				case "storeRef":
+					storeRef = new StoreRef(fieldValue);
+					break;
+				case "s":
+				case "shards":
+					shards = SimpleCaster.transform(fieldValue, Short.class);
+					break;
+				case "range":
+					range = this.strToRange(fieldValue);
+					break;
+				case "date.grouping":
+					dateGrouping = SimpleCaster.transform(fieldValue, Byte.class);
+					break;
+				case "k":
+				case "key":
+					prefixedProperty = fieldValue;
+					break;
+				case "regex":
+					regex = fieldValue;
+					break;
+				default:
+					throw new IllegalArgumentException();
+			}
+		}
+		
+		this.hasContent = hasContent;
+		this.template = template;
+		this.storeRefs = CollectionUtils.asSet(storeRef);
+		this.shards = shards;
+		this.range = range;
+		this.dateGrouping = dateGrouping;
+		this.prefixedProperty = prefixedProperty;
+		this.regex = regex == null ? null : Pattern.compile(regex);
+	}
+	
+	private Pair<Long, Long> strToRange(String str) {
+		str = StringUtils.trimToNull(str);
+		if (str == null)
+			return null;
+		
+		String[] rangeValues = str.split("-");
+		return Pair.of(Long.valueOf(rangeValues[0]), Long.valueOf(rangeValues[1]));
+	}
+	
+	public String getCore() {
+		return core;
 	}
 	
 	public ShardMethodEnum getMethod() {
@@ -58,35 +199,70 @@ public class ShardSet {
 		return hasContent;
 	}
 	
+	public String getTemplate() {
+		return template;
+	}
+	
+	public Set<StoreRef> getStoreRefs() {
+		return storeRefs;
+	}
+	
+	public Short getShards() {
+		return shards;
+	}
+	
+	public Pair<Long, Long> getRange() {
+		return range;
+	}
+	
+	public Byte getDateGrouping() {
+		return dateGrouping;
+	}
+	
+	public String getPrefixedProperty() {
+		return prefixedProperty;
+	}
+	
+	public Pattern getRegex() {
+		return regex;
+	}
+	
 	public String toSpec() {
-		StringBuilder spec = new StringBuilder(this.method.toString());
-		if (this.hasContent)
-			spec.append(";fulltext");
-		for (Entry<String, String> c : this.config.entrySet()) {
-			if (!c.getKey().startsWith("shard."))
-				continue;
-			spec.append(';').append(c.getKey().substring(6)).append(':').append(c.getValue());
-		}
-		return spec.toString();
-	}
-	
-	public Map<String, String> getConfig() {
-		return config;
-	}
-	
-	public boolean isFor(ShardState shardState) {
-		return this.method.equals(shardState.getShardInstance().getShard().getFloc().getShardMethod()) &&
-				this.hasContent == shardState.getShardInstance().getShard().getFloc().hasContent() &&
-				this.isConfigurationFor(shardState.getPropertyBag());
-	}
-	
-	public boolean isConfigurationFor(Map<String, String> propertyBag) {
-		for (Entry<String, String> config : this.config.entrySet()) {
-			if (config.getValue() == null || !config.getValue().equals(propertyBag.get(config.getKey())))
-				return false;
+		if (this.spec == null) {
+			StringBuilder spec = new StringBuilder(this.method.toString());
+			if (this.hasContent)
+				spec.append(";txt");
+			spec.append(";t:").append(this.template);
+			spec.append(";sref:").append(StringUtils.join(this.storeRefs, ','));
+			if (this.shards != null)
+				spec.append(";s:").append(this.shards);
+			if (this.range != null)
+				spec.append(";range:").append(this.range.getLeft()).append('-').append(this.range.getRight());
+			if (this.dateGrouping != null)
+				spec.append(";date.grouping:").append(this.dateGrouping);
+			if (this.prefixedProperty != null)
+				spec.append(";k:").append(this.prefixedProperty);
+			if (this.regex != null)
+				spec.append(";regex:").append(this.regex);
+			this.spec = spec.toString();
 		}
 		
-		return true;
+		return spec;
+	}
+	
+	public boolean contains(ShardState shardState) {
+		Floc floc = shardState.getShardInstance().getShard().getFloc();
+		CompositeMap<String, String> propbag = new CompositeMap<>(shardState.getPropertyBag(), floc.getPropertyBag());
+		
+		return this.method.equals(floc.getShardMethod()) &&
+				this.hasContent == floc.hasContent() &&
+				StringUtils.equals(this.template, floc.getTemplate()) &&
+				this.storeRefs.equals(floc.getStoreRefs()) &&
+				this.equals(this.shards, floc.getNumberOfShards()) &&
+				this.equals(this.range, this.strToRange(propbag.get("shard.range"))) &&
+				this.equals(this.dateGrouping, propbag.get("shard.date.grouping")) &&
+				StringUtils.equals(this.prefixedProperty, propbag.get("shard.key")) &&
+				this.equals(this.regex, propbag.get("shard.regex"));
 	}
 	
 	@Override
@@ -95,21 +271,34 @@ public class ShardSet {
 			return false;
 		
 		ShardSet shardSet = (ShardSet) obj;
-		return this.method.equals(shardSet.method) && this.config.equals(shardSet.config);
+		return this.core.equals(shardSet.core);
+	}
+	
+	private <T> boolean equals(Pattern p1, String s2) {
+		s2 = StringUtils.trimToNull(s2);
+		if (p1 == null) {
+			return s2 == null;
+		} else {
+			return p1.pattern().equals(s2);
+		}
+	}
+	
+	private <T> boolean equals(T t1, T t2) {
+		if (t1 == null) {
+			return t2 == null;
+		} else {
+			return t1.equals(t2);
+		}
 	}
 	
 	@Override
 	public int hashCode() {
-		if (this.hash == null) {
-			this.hash = new HashCodeBuilder().append(this.method).append(this.hasContent).append(this.config).build();
-		}
-		
-		return this.hash;
+		return this.core.hashCode();
 	}
 	
 	@Override
 	public String toString() {
-		return this.toSpec();
+		return this.core;
 	}
 
 }

shared/src/main/java/com/inteligr8/alfresco/asie/model/SolrHost.java

@@ -0,0 +1,94 @@
+package com.inteligr8.alfresco.asie.model;
+
+import java.io.Serializable;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.alfresco.repo.index.shard.ShardInstance;
+
+public class SolrHost implements Serializable {
+	
+	private static final long serialVersionUID = -8834744746109388928L;
+	private static final Pattern PATTERN = Pattern.compile("([^:]+):([0-9]+)([^0-9]?.*)");
+	
+	public static SolrHost from(ShardInstance shardNode) {
+		return new SolrHost(shardNode);
+	}
+	
+	public static SolrHost from(String spec) {
+		return new SolrHost(spec);
+	}
+
+	private final String spec;
+	private final String hostname;
+	private final int port;
+	private final String path;
+	
+	protected SolrHost(ShardInstance shardNode) {
+		this.hostname = shardNode.getHostName();
+		this.port = shardNode.getPort();
+
+		// baseUrl is to the shard; we want to the node, so exclude the core
+		int lastSlash = shardNode.getBaseUrl().lastIndexOf('/');
+		this.path = shardNode.getBaseUrl().substring(0, lastSlash);
+		
+		this.spec = this.hostname + ":" + this.port + this.path;
+	}
+	
+	protected SolrHost(String spec) {
+		this.spec = spec;
+		
+		Matcher matcher = PATTERN.matcher(spec);
+		if (!matcher.find())
+			throw new IllegalArgumentException();
+		this.hostname = matcher.group(1);
+		this.port = Integer.parseInt(matcher.group(2));
+		this.path = matcher.group(3);
+	}
+	
+	public String getSpec() {
+		return this.spec;
+	}
+	
+	public String getHostname() {
+		return this.hostname;
+	}
+	
+	public int getPort() {
+		return this.port;
+	}
+	
+	public String getPath() {
+		return this.path;
+	}
+	
+	public URL toUrl(String protocol) {
+		try {
+			return new URL(protocol + "://" + this.hostname + ':' + this.port + this.path);
+		} catch (MalformedURLException mue) {
+			throw new IllegalArgumentException(mue.getMessage());
+		}
+	}
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (!(obj instanceof SolrHost))
+			return false;
+		
+		SolrHost shardNode = (SolrHost) obj;
+		return this.spec.equals(shardNode.spec);
+	}
+	
+	@Override
+	public int hashCode() {
+		return this.spec.hashCode();
+	}
+	
+	@Override
+	public String toString() {
+		return this.spec;
+	}
+
+}

shared/src/main/java/com/inteligr8/alfresco/asie/rest/AbstractAcsNodeActionWebScript.java

@@ -0,0 +1,119 @@
+package com.inteligr8.alfresco.asie.rest;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.alfresco.model.ContentModel;
+import org.alfresco.service.cmr.repository.InvalidNodeRefException;
+import org.alfresco.service.cmr.repository.NodeRef;
+import org.alfresco.service.cmr.repository.NodeService;
+import org.alfresco.service.cmr.repository.StoreRef;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.extensions.webscripts.WebScriptException;
+import org.springframework.extensions.webscripts.WebScriptRequest;
+import org.springframework.extensions.webscripts.WebScriptResponse;
+import org.springframework.http.HttpStatus;
+
+import com.inteligr8.alfresco.asie.model.ShardInstance;
+import com.inteligr8.alfresco.asie.spi.ActionCallback;
+
+public abstract class AbstractAcsNodeActionWebScript extends AbstractAsieWebScript {
+
+	private final Logger logger = LoggerFactory.getLogger(this.getClass());
+	
+	@Autowired
+	private NodeService nodeService;
+	
+	@Override
+	public void executeAuthorized(WebScriptRequest request, WebScriptResponse response) throws IOException {
+		String nodeId = request.getServiceMatch().getTemplateVars().get("nodeId");
+		NodeRef nodeRef = new NodeRef(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE, nodeId);
+		long nodeDbId = this.findNodeDbId(nodeRef);
+		this.logger.trace("Found node database ID: {}: {}", nodeId, nodeDbId);
+
+		try {
+			Map<String, Object> responseMap = new HashMap<>();
+			responseMap.put("nodeDbId", nodeDbId);
+			
+			ActionCallback callback = new ActionCallback() {
+				
+				@Override
+				public void success(ShardInstance instance) {
+					@SuppressWarnings("unchecked")
+					List<String> instances = (List<String>) responseMap.get("success");
+					if (instances == null)
+						responseMap.put("success", instances = new LinkedList<>());
+					instances.add(instance.getSpec());
+				}
+				
+				@Override
+				public void scheduled(ShardInstance instance) {
+					@SuppressWarnings("unchecked")
+					List<String> instances = (List<String>) responseMap.get("scheduled");
+					if (instances == null)
+						responseMap.put("scheduled", instances = new LinkedList<>());
+					instances.add(instance.getSpec());
+				}
+				
+				@Override
+				public void error(ShardInstance instance, String message) {
+					@SuppressWarnings("unchecked")
+					Map<String, Object> instances = (Map<String, Object>) responseMap.get("error");
+					if (instances == null)
+						responseMap.put("error", instances = new HashMap<>());
+					instances.put(instance.getSpec(), Collections.singletonMap("message", message));
+				}
+				
+				@Override
+				public void unknownResult(ShardInstance instance) {
+					@SuppressWarnings("unchecked")
+					List<String> instances = (List<String>) responseMap.get("unknown");
+					if (instances == null)
+						responseMap.put("unknown", instances = new LinkedList<>());
+					instances.add(instance.getSpec());
+				}
+			};
+			
+			this.executeAction(nodeDbId, callback, 10L, TimeUnit.SECONDS, 30L, TimeUnit.SECONDS);
+			
+			if (responseMap.containsKey("error")) {
+				response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
+			} else if (responseMap.containsKey("scheduled")) {
+				response.setStatus(HttpStatus.ACCEPTED.value());
+			} else {
+				response.setStatus(HttpStatus.OK.value());
+			}
+
+			response.setContentType("application/json");
+			this.getObjectMapper().writeValue(response.getWriter(), responseMap);
+		} catch (UnsupportedOperationException uoe) {
+			throw new WebScriptException(HttpStatus.NOT_IMPLEMENTED.value(), uoe.getMessage(), uoe);
+		} catch (InterruptedException ie) {
+			throw new WebScriptException(HttpStatus.SERVICE_UNAVAILABLE.value(), "The execution was interrupted", ie);
+		} catch (TimeoutException te) {
+			throw new WebScriptException(HttpStatus.INTERNAL_SERVER_ERROR.value(), "The execution may continue, but timed-out waiting", te);
+		}
+    }
+	
+	protected abstract void executeAction(
+			long nodeDbId, ActionCallback callback,
+			long fullQueueTimeout, TimeUnit fullQueueUnit,
+			long execTimeout, TimeUnit execUnit) throws TimeoutException, InterruptedException;
+	
+	private long findNodeDbId(NodeRef nodeRef) {
+		try {
+			return (Long) this.nodeService.getProperty(nodeRef, ContentModel.PROP_NODE_DBID);
+		} catch (InvalidNodeRefException inre) {
+			throw new WebScriptException(HttpStatus.NOT_FOUND.value(), "The node does not exist");
+		}
+	}
+    
+}

shared/src/main/java/com/inteligr8/alfresco/asie/rest/AbstractActionWebScript.java

@@ -0,0 +1,102 @@
+package com.inteligr8.alfresco.asie.rest;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.alfresco.model.ContentModel;
+import org.alfresco.service.cmr.repository.InvalidNodeRefException;
+import org.alfresco.service.cmr.repository.NodeRef;
+import org.alfresco.service.cmr.repository.NodeService;
+import org.alfresco.service.cmr.repository.StoreRef;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.extensions.webscripts.WebScriptException;
+import org.springframework.extensions.webscripts.WebScriptRequest;
+import org.springframework.extensions.webscripts.WebScriptResponse;
+import org.springframework.http.HttpStatus;
+
+import com.inteligr8.alfresco.asie.model.ShardInstance;
+import com.inteligr8.alfresco.asie.spi.ActionCallback;
+
+public abstract class AbstractActionWebScript extends AbstractAsieWebScript {
+
+	private final Logger logger = LoggerFactory.getLogger(this.getClass());
+	
+	@Override
+	public void executeAuthorized(WebScriptRequest request, WebScriptResponse response) throws IOException {
+		try {
+			Map<String, Object> responseMap = new HashMap<>();
+			
+			ActionCallback callback = new ActionCallback() {
+				
+				@Override
+				public void success(ShardInstance instance) {
+					@SuppressWarnings("unchecked")
+					List<String> instances = (List<String>) responseMap.get("success");
+					if (instances == null)
+						responseMap.put("success", instances = new LinkedList<>());
+					instances.add(instance.getSpec());
+				}
+				
+				@Override
+				public void scheduled(ShardInstance instance) {
+					@SuppressWarnings("unchecked")
+					List<String> instances = (List<String>) responseMap.get("scheduled");
+					if (instances == null)
+						responseMap.put("scheduled", instances = new LinkedList<>());
+					instances.add(instance.getSpec());
+				}
+				
+				@Override
+				public void error(ShardInstance instance, String message) {
+					@SuppressWarnings("unchecked")
+					Map<String, Object> instances = (Map<String, Object>) responseMap.get("error");
+					if (instances == null)
+						responseMap.put("error", instances = new HashMap<>());
+					instances.put(instance.getSpec(), Collections.singletonMap("message", message));
+				}
+				
+				@Override
+				public void unknownResult(ShardInstance instance) {
+					@SuppressWarnings("unchecked")
+					List<String> instances = (List<String>) responseMap.get("unknown");
+					if (instances == null)
+						responseMap.put("unknown", instances = new LinkedList<>());
+					instances.add(instance.getSpec());
+				}
+			};
+			
+			this.executeAction(callback, 10L, TimeUnit.SECONDS, 30L, TimeUnit.SECONDS);
+			
+			if (responseMap.containsKey("error")) {
+				response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
+			} else if (responseMap.containsKey("scheduled")) {
+				response.setStatus(HttpStatus.ACCEPTED.value());
+			} else {
+				response.setStatus(HttpStatus.OK.value());
+			}
+
+			response.setContentType("application/json");
+			this.getObjectMapper().writeValue(response.getWriter(), responseMap);
+		} catch (UnsupportedOperationException uoe) {
+			throw new WebScriptException(HttpStatus.NOT_IMPLEMENTED.value(), uoe.getMessage(), uoe);
+		} catch (InterruptedException ie) {
+			throw new WebScriptException(HttpStatus.SERVICE_UNAVAILABLE.value(), "The execution was interrupted", ie);
+		} catch (TimeoutException te) {
+			throw new WebScriptException(HttpStatus.INTERNAL_SERVER_ERROR.value(), "The execution may continue, but timed-out waiting", te);
+		}
+    }
+	
+	protected abstract void executeAction(
+			ActionCallback callback,
+			long fullQueueTimeout, TimeUnit fullQueueUnit,
+			long execTimeout, TimeUnit execUnit) throws TimeoutException, InterruptedException;
+    
+}

shared/src/main/java/com/inteligr8/alfresco/asie/rest/AbstractAsieNodeShardWebScript.java

@@ -20,7 +20,7 @@ public abstract class AbstractAsieNodeShardWebScript extends AbstractAsieShardab
 		String nodeEndpoint = this.getRequiredPathParameter(req, "nodeEndpoint");
 		int colon = nodeEndpoint.lastIndexOf(':');
 		String nodeHostname = colon < 0 ? nodeEndpoint : nodeEndpoint.substring(0, colon);
-		int nodePort = colon < 0 ? this.getDefaultSolrPort() : Integer.parseInt(nodeEndpoint.substring(colon+1));
+		int nodePort = colon < 0 ? this.getApiService().getDefaultSolrPort() : Integer.parseInt(nodeEndpoint.substring(colon+1));
 
 		ShardSet shardSet = this.getRequiredPathParameter(req, "shardSet", ShardSet.class);
 		int shardId = this.getRequiredPathParameter(req, "shardId", Integer.class);

shared/src/main/java/com/inteligr8/alfresco/asie/rest/AbstractAsieNodeWebScript.java

@@ -1,9 +1,8 @@
 package com.inteligr8.alfresco.asie.rest;
 
 import java.io.IOException;
-import java.util.Set;
+import java.util.Map;
 
-import org.alfresco.repo.index.shard.ShardState;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -12,7 +11,10 @@ import org.springframework.extensions.webscripts.WebScriptRequest;
 import org.springframework.extensions.webscripts.WebScriptResponse;
 import org.springframework.http.HttpStatus;
 
-import com.inteligr8.alfresco.asie.service.ShardDiscoveryService;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
+import com.inteligr8.alfresco.asie.spi.ShardDiscoveryService;
 
 public abstract class AbstractAsieNodeWebScript extends AbstractAsieShardableWebScript {
     
@@ -29,23 +31,24 @@ public abstract class AbstractAsieNodeWebScript extends AbstractAsieShardableWeb
 		int colon = nodeEndpoint.lastIndexOf(':');
 		String nodeHostname = colon < 0 ? nodeEndpoint : nodeEndpoint.substring(0, colon);
 		nodeHostname = nodeHostname.replace('_', '.');
-		int nodePort = colon < 0 ? this.getDefaultSolrPort() : Integer.parseInt(nodeEndpoint.substring(colon+1));
+		int nodePort = colon < 0 ? this.getApiService().getDefaultSolrPort() : Integer.parseInt(nodeEndpoint.substring(colon+1));
 		
 		this.execute(req, res, nodeHostname, nodePort);
     }
     
     protected void execute(WebScriptRequest req, WebScriptResponse res, String nodeHostname, int nodePort) throws IOException {
 		this.logger.trace("execute({}, {})", nodeHostname, nodePort);
-		
-		Set<ShardState> shardsOnNode = this.sds.findByNode(nodeHostname, nodePort);
+
+		SolrHost node = this.sds.findNode(nodeHostname, nodePort);
+		Map<ShardSet, Map<Integer, ShardInstanceState>> shardsOnNode = this.sds.findByNode(node);
 		if (shardsOnNode == null || shardsOnNode.isEmpty())
 			throw new WebScriptException(HttpStatus.NOT_FOUND.value(), "The ASIE node could not be found");
 		
-		this.execute(req, res, shardsOnNode);
+		this.execute(req, res, node, shardsOnNode);
     }
     
-    protected void execute(WebScriptRequest req, WebScriptResponse res, Set<ShardState> registeredNodeShards) throws IOException {
-		this.logger.trace("execute({})", registeredNodeShards.size());
+    protected void execute(WebScriptRequest req, WebScriptResponse res, SolrHost node, Map<ShardSet, Map<Integer, ShardInstanceState>> shardSetShardStates) throws IOException {
+		this.logger.trace("execute({})", shardSetShardStates.size());
     	// made to be optionally overridden
     }
     

shared/src/main/java/com/inteligr8/alfresco/asie/rest/AbstractAsieShardWebScript.java

@@ -1,9 +1,9 @@
 package com.inteligr8.alfresco.asie.rest;
 
 import java.io.IOException;
-import java.util.Set;
+import java.util.List;
 
-import org.alfresco.repo.index.shard.ShardState;
+import org.alfresco.util.Pair;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -13,7 +13,9 @@ import org.springframework.extensions.webscripts.WebScriptResponse;
 import org.springframework.http.HttpStatus;
 
 import com.inteligr8.alfresco.asie.model.ShardSet;
-import com.inteligr8.alfresco.asie.service.ShardDiscoveryService;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
+import com.inteligr8.alfresco.asie.spi.ShardDiscoveryService;
 
 public abstract class AbstractAsieShardWebScript extends AbstractAsieShardableWebScript {
     
@@ -26,21 +28,24 @@ public abstract class AbstractAsieShardWebScript extends AbstractAsieShardableWe
     public void executeAuthorized(WebScriptRequest req, WebScriptResponse res) throws IOException {
 		this.logger.trace("execute()");
 
-		ShardSet shardSet = this.getRequiredPathParameter(req, "shardSet", ShardSet.class);
-		this.logger.debug("Parsed shard set: {}", shardSet);
+		String coreName = this.getRequiredPathParameter(req, "shardCore");
 		int shardId = this.getRequiredPathParameter(req, "shardId", Integer.class);
 		
 		try {
-			Set<ShardState> registeredShardNodes = this.sds.findByShard(shardSet, shardId);
-			if (registeredShardNodes == null || registeredShardNodes.isEmpty())
-				throw new WebScriptException(HttpStatus.NOT_FOUND.value(), "The ASIE shard set or shard could not be found");
+			ShardSet shardSet = this.sds.findSetByCore(coreName);
+			if (shardSet == null)
+				throw new WebScriptException(HttpStatus.NOT_FOUND.value(), "The ASIE shard set could not be found");
 			
-			this.execute(req, res, registeredShardNodes);
+			List<Pair<SolrHost, ShardInstanceState>> nodeShardStates = this.sds.findNodeStatesByShard(shardSet, shardId);
+			if (nodeShardStates == null || nodeShardStates.isEmpty())
+				throw new WebScriptException(HttpStatus.NOT_FOUND.value(), "The ASIE shard could not be found");
+			
+			this.execute(req, res, shardId, shardSet, nodeShardStates);
 		} catch (IllegalArgumentException iae) {
     		throw new WebScriptException(HttpStatus.BAD_REQUEST.value(), iae.getMessage());
 		}
     }
     
-    protected abstract void execute(WebScriptRequest req, WebScriptResponse res, Set<ShardState> registeredShardNodes) throws IOException;
+    protected abstract void execute(WebScriptRequest req, WebScriptResponse res, int shardId, ShardSet shardSet, List<Pair<SolrHost, ShardInstanceState>> nodeShardStates) throws IOException;
     
 }

shared/src/main/java/com/inteligr8/alfresco/asie/rest/AbstractAsieShardableWebScript.java

@@ -57,7 +57,7 @@ public abstract class AbstractAsieShardableWebScript extends AbstractAsieWebScri
     	
     	try {
 	    	SolrShardHashSampleType type = SolrShardHashSampleType.valueOf(matcher.group(1));
-	    	int shards = Integer.parseInt(matcher.group(2));
+	    	short shards = Short.parseShort(matcher.group(2));
 	    	return this.createSampleHashTable(type, shards);
     	} catch (NumberFormatException nfe) {
     		// this should never happen, because of the regex
@@ -67,7 +67,7 @@ public abstract class AbstractAsieShardableWebScript extends AbstractAsieWebScri
     	}
 	}
     
-    protected SolrShardHashTable<?> createSampleHashTable(SolrShardHashSampleType sampleType, int shards) {
+    protected SolrShardHashTable<?> createSampleHashTable(SolrShardHashSampleType sampleType, short shards) {
 		int thisYear = Year.now().getValue();
 		
     	switch (sampleType) {
@@ -122,7 +122,7 @@ public abstract class AbstractAsieShardableWebScript extends AbstractAsieWebScri
     }
     
     protected CoreAdminApi getApi(ShardInstance shard) {
-    	return this.createApi(shard.getHostName(), shard.getPort());
+    	return this.getApiService().createApi(shard.getHostName(), shard.getPort(), CoreAdminApi.class);
     }
     
 }

shared/src/main/java/com/inteligr8/alfresco/asie/rest/AbstractAsieWebScript.java

@@ -1,140 +1,34 @@
 package com.inteligr8.alfresco.asie.rest;
 
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.extensions.webscripts.WebScriptRequest;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.inteligr8.alfresco.asie.Constants;
-import com.inteligr8.alfresco.asie.api.CoreAdminApi;
-import com.inteligr8.rs.AuthorizationFilter;
-import com.inteligr8.rs.Client;
-import com.inteligr8.rs.ClientCxfConfiguration;
-import com.inteligr8.rs.ClientCxfImpl;
+import com.inteligr8.alfresco.asie.service.ApiService;
 
-import jakarta.ws.rs.client.ClientRequestContext;
-
-public abstract class AbstractAsieWebScript extends AbstractWebScript implements InitializingBean {
-	
-	private final Logger logger = LoggerFactory.getLogger(this.getClass());
-	
-	@Value("${solr.secureComms}")
-	private String solrSecureComms;
-	
-	@Value("${solr.port}")
-	private int solrPort;
-	
-	@Value("${solr.port.ssl}")
-	private int solrSslPort;
-	
-	@Value("${solr.sharedSecret.header}")
-	private String solrSharedSecretHeader;
-	
-	@Value("${solr.sharedSecret}")
-	private String solrSharedSecret;
-	
-	@Value("${inteligr8.asie.allowedAuthorities}")
-	private String authorizedAuthoritiesStr;
-	
-	@Value("${inteligr8.asie.basePath}")
-	private String solrBaseUrl;
+public abstract class AbstractAsieWebScript extends AbstractWebScript {
     
 	@Autowired
 	@Qualifier(Constants.QUALIFIER_ASIE)
     private ObjectMapper objectMapper;
 	
-	private Set<String> authorizedAuthorities;
-	
-	@Override
-	public void afterPropertiesSet() throws Exception {
-		this.authorizedAuthorities = new HashSet<>();
-		String[] authorities = this.authorizedAuthoritiesStr.split(",");
-		for (String authority : authorities) {
-			authority = StringUtils.trimToNull(authority);
-			if (authority != null)
-				this.authorizedAuthorities.add(authority);
-		}
-		
-		if (this.authorizedAuthorities.isEmpty())
-			this.logger.warn("All authenticated users will be authorized to access ASIE web scripts");
-		
-		this.solrSharedSecret = StringUtils.trimToNull(this.solrSharedSecret);
-	}
-	
-	@Override
-	protected Set<String> getAuthorities() {
-		return this.authorizedAuthorities;
-	}
+	@Autowired
+	private ApiService api;
     
     protected ObjectMapper getObjectMapper() {
 		return this.objectMapper;
 	}
     
-    protected CoreAdminApi createApi(String hostname, int port) {
-    	String solrBaseUrl = this.formulateSolrBaseUrl(hostname, port);
-    	this.logger.trace("Using Solr base URL: {}", solrBaseUrl);
-    	Client solrClient = this.createClient(solrBaseUrl);
-    	return this.getApi(solrClient);
-    }
-    
-    protected CoreAdminApi getApi(Client solrClient) {
-		return solrClient.getApi(CoreAdminApi.class);
-    }
-    
-    protected int getDefaultSolrPort() {
-		boolean isSsl = "https".equals(this.solrSecureComms);
-    	return isSsl ? this.solrSslPort : this.solrPort;
+    protected ApiService getApiService() {
+    	return this.api;
     }
 	
 	protected String formulateSolrBaseUrl(WebScriptRequest req) {
 		String hostname = this.getRequiredPathParameter(req, "hostname");
 		Integer port = this.getOptionalPathParameter(req, "port", Integer.class);
-		return this.formulateSolrBaseUrl(hostname, port);
-	}
-	
-	protected String formulateSolrBaseUrl(String hostname, Integer port) {
-		boolean isSsl = "https".equals(this.solrSecureComms);
-		StringBuilder baseUrl = new StringBuilder(isSsl ? "https" : "http").append("://").append(hostname);
-		baseUrl.append(':').append(port == null ? (isSsl ? this.solrSslPort : this.solrPort) : port);
-		baseUrl.append(this.solrBaseUrl);
-		return baseUrl.toString();
-	}
-	
-	protected Client createClient(final String baseUrl) {
-		ClientCxfImpl client = new ClientCxfImpl(new ClientCxfConfiguration() {
-			@Override
-			public String getBaseUrl() {
-				return baseUrl.toString();
-			}
-			
-			@Override
-			public AuthorizationFilter createAuthorizationFilter() {
-				return solrSharedSecret == null ? null : new AuthorizationFilter() {
-					@Override
-					public void filter(ClientRequestContext requestContext) throws IOException {
-						logger.debug("Adding authorization headers for ASIE shared auth: {}", solrSharedSecretHeader);
-						requestContext.getHeaders().putSingle(solrSharedSecretHeader, solrSharedSecret);
-					}
-				};
-			}
-			
-			@Override
-			public boolean isDefaultBusEnabled() {
-				return false;
-			}
-		});
-		
-		client.register();
-		return client;
+		return this.api.formulateSolrBaseUrl(hostname, port);
 	}
     
 }

shared/src/main/java/com/inteligr8/alfresco/asie/rest/AbstractWebScript.java

@@ -4,11 +4,19 @@ import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.Set;
 
 import org.alfresco.repo.security.authentication.AuthenticationUtil;
+import org.alfresco.service.cmr.security.AuthorityService;
 import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.extensions.webscripts.Description.RequiredAuthentication;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.extensions.webscripts.WebScriptException;
 import org.springframework.extensions.webscripts.WebScriptRequest;
 import org.springframework.extensions.webscripts.WebScriptResponse;
@@ -16,9 +24,38 @@ import org.springframework.http.HttpStatus;
 
 import net.sf.acegisecurity.GrantedAuthority;
 
-public abstract class AbstractWebScript extends org.springframework.extensions.webscripts.AbstractWebScript {
+public abstract class AbstractWebScript extends org.springframework.extensions.webscripts.AbstractWebScript implements InitializingBean {
 	
-	protected abstract Set<String> getAuthorities();
+	private final Logger logger = LoggerFactory.getLogger(this.getClass());
+	
+	@Value("${inteligr8.asie.allowedAuthorities}")
+	private String authorizedAuthoritiesStr;
+	
+	@Autowired
+	private AuthorityService authorityService;
+	
+	private Set<String> authorizedAuthorities;
+	
+	@Override
+	public void afterPropertiesSet() throws Exception {
+		this.authorizedAuthorities = new HashSet<>();
+		String[] authorities = this.authorizedAuthoritiesStr.split(",");
+		for (String authority : authorities) {
+			authority = StringUtils.trimToNull(authority);
+			if (authority != null)
+				this.authorizedAuthorities.add(authority);
+		}
+		
+		if (this.authorizedAuthorities.isEmpty()) {
+			this.logger.warn("All authenticated users will be authorized to access web scripts");
+		} else {
+			this.logger.debug("Allowing only authorities: {}", this.authorizedAuthorities);
+		}
+	}
+	
+	protected Set<String> getAuthorities() {
+		return this.authorizedAuthorities;
+	}
 	
 	@Override
 	public final void execute(WebScriptRequest request, WebScriptResponse response) throws IOException {
@@ -38,6 +75,13 @@ public abstract class AbstractWebScript extends org.springframework.extensions.w
 				return true;
 		}
 		
+		Set<String> authorities = this.authorityService.getAuthoritiesForUser(AuthenticationUtil.getFullyAuthenticatedUser());
+		if (authorities != null) {
+			if (!Collections.disjoint(this.getAuthorities(), authorities))
+				return true;
+		}
+		
+		this.logger.trace("Not authorized: user '{}'; authorities: {} + {}", AuthenticationUtil.getFullyAuthenticatedUser(), AuthenticationUtil.getFullAuthentication().getAuthorities(), authorities);
 		return false;
 	}
 	

shared/src/main/java/com/inteligr8/alfresco/asie/rest/ClearRegistryWebScript.java

@@ -3,7 +3,6 @@ package com.inteligr8.alfresco.asie.rest;
 import java.io.IOException;
 
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.extensions.webscripts.AbstractWebScript;
 import org.springframework.extensions.webscripts.WebScriptRequest;
 import org.springframework.extensions.webscripts.WebScriptResponse;
 import org.springframework.http.HttpStatus;
@@ -20,13 +19,13 @@ public class ClearRegistryWebScript extends AbstractWebScript {
 	
 	@Autowired
 	private ShardStateService sss;
-
-    @Override
-    public void execute(WebScriptRequest req, WebScriptResponse res) throws IOException {
+	
+	@Override
+	public void executeAuthorized(WebScriptRequest request, WebScriptResponse response) throws IOException {
     	this.sss.clear();
     	this.sbs.forget();
 
-    	res.setStatus(HttpStatus.OK.value());
+    	response.setStatus(HttpStatus.OK.value());
     }
     
 }

shared/src/main/java/com/inteligr8/alfresco/asie/rest/FixWebScript.java

@@ -0,0 +1,24 @@
+package com.inteligr8.alfresco.asie.rest;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import com.inteligr8.alfresco.asie.service.FixService;
+import com.inteligr8.alfresco.asie.spi.ActionCallback;
+
+@Component(value = "webscript.com.inteligr8.alfresco.asie.fix.post")
+public class FixWebScript extends AbstractActionWebScript {
+	
+	@Autowired
+	private FixService fixSerivce;
+	
+	@Override
+	protected void executeAction(ActionCallback callback, long fullQueueTimeout, TimeUnit fullQueueUnit,
+			long execTimeout, TimeUnit execUnit) throws TimeoutException, InterruptedException {
+		this.fixSerivce.fix(callback, 10L, TimeUnit.SECONDS, 30L, TimeUnit.SECONDS);
+    }
+    
+}

shared/src/main/java/com/inteligr8/alfresco/asie/rest/GetBackupNodeWebScript.java

@@ -1,19 +1,21 @@
 package com.inteligr8.alfresco.asie.rest;
 
 import java.io.IOException;
-import java.util.Set;
+import java.util.Collections;
+import java.util.List;
 
-import org.alfresco.repo.index.shard.ShardState;
+import org.alfresco.util.Pair;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.extensions.webscripts.WebScriptException;
 import org.springframework.extensions.webscripts.WebScriptRequest;
 import org.springframework.extensions.webscripts.WebScriptResponse;
-import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Component;
 
-import com.inteligr8.alfresco.asie.model.Node;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
 import com.inteligr8.alfresco.asie.service.ShardBackupService;
+import com.inteligr8.alfresco.asie.spi.ShardDiscoveryService;
 
 @Component(value = "webscript.com.inteligr8.alfresco.asie.backupNode.get")
 public class GetBackupNodeWebScript extends AbstractAsieShardWebScript {
@@ -22,15 +24,15 @@ public class GetBackupNodeWebScript extends AbstractAsieShardWebScript {
     private ShardBackupService sbs;
 
     @Override
-    public void execute(WebScriptRequest req, WebScriptResponse res, Set<ShardState> shardNodes) throws IOException {
-		if (shardNodes.isEmpty())
-			throw new WebScriptException(HttpStatus.NOT_FOUND.value(), "The ASIE shard state could not be found");
-		
-		Node node = this.sbs.fetchNode(shardNodes);
+    public void execute(WebScriptRequest req, WebScriptResponse res, int shardId, ShardSet shardSet, List<Pair<SolrHost, ShardInstanceState>> nodeShardStates) throws IOException {
+    	Collections.sort(nodeShardStates, new ShardDiscoveryService.ShardedNodeShardStateComparator());
+    	SolrHost mostRecentNode = nodeShardStates.iterator().next().getFirst();
+    	
+		SolrHost backupNode = this.sbs.selectNode(shardSet, shardId, mostRecentNode);
 
 		res.setContentType(MediaType.APPLICATION_JSON_VALUE);
 		res.setContentEncoding("utf-8");
-		this.getObjectMapper().writeValue(res.getWriter(), node.getId());
+		this.getObjectMapper().writeValue(res.getWriter(), backupNode.getSpec());
     }
     
 }

shared/src/main/java/com/inteligr8/alfresco/asie/rest/GetLeadNodeWebScript.java

@@ -1,10 +1,9 @@
 package com.inteligr8.alfresco.asie.rest;
 
 import java.io.IOException;
-import java.util.Set;
+import java.util.List;
 
-import org.alfresco.repo.index.shard.ShardInstance;
-import org.alfresco.repo.index.shard.ShardState;
+import org.alfresco.util.Pair;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.extensions.webscripts.WebScriptException;
 import org.springframework.extensions.webscripts.WebScriptRequest;
@@ -13,7 +12,9 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Component;
 
-import com.inteligr8.alfresco.asie.model.Node;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
 import com.inteligr8.alfresco.asie.spi.ShardDiscoveryService;
 
 @Component(value = "webscript.com.inteligr8.alfresco.asie.leadNode.get")
@@ -23,17 +24,14 @@ public class GetLeadNodeWebScript extends AbstractAsieShardWebScript {
 	private ShardDiscoveryService sds;
 
     @Override
-    public void execute(WebScriptRequest req, WebScriptResponse res, Set<ShardState> shardNodesCache) throws IOException {
-		if (shardNodesCache.isEmpty())
-			throw new WebScriptException(HttpStatus.NOT_FOUND.value(), "The ASIE shard state could not be found");
-
-    	ShardInstance latestNode = this.sds.computeLeadShard(shardNodesCache);
+    public void execute(WebScriptRequest req, WebScriptResponse res, int shardId, ShardSet shardSet, List<Pair<SolrHost, ShardInstanceState>> nodeShardStates) throws IOException {
+    	SolrHost latestNode = this.sds.computeLeadNode(nodeShardStates);
 		if (latestNode == null)
-			throw new WebScriptException(HttpStatus.NOT_FOUND.value(), "The ASIE shard state could not be found");
+			throw new WebScriptException(HttpStatus.NOT_FOUND.value(), "The ASIE node could not be found");
 		
 		res.setContentType(MediaType.APPLICATION_JSON_VALUE);
 		res.setContentEncoding("utf-8");
-		this.getObjectMapper().writeValue(res.getWriter(), new Node(latestNode).getId());
+		this.getObjectMapper().writeValue(res.getWriter(), latestNode.getSpec());
     }
     
 }

shared/src/main/java/com/inteligr8/alfresco/asie/rest/GetNodeWebScript.java

@@ -1,18 +1,17 @@
 package com.inteligr8.alfresco.asie.rest;
 
 import java.io.IOException;
-import java.time.Instant;
-import java.time.OffsetDateTime;
-import java.time.ZoneOffset;
-import java.util.Set;
+import java.util.Map;
+import java.util.Map.Entry;
 
-import org.alfresco.repo.index.shard.ShardInstance;
-import org.alfresco.repo.index.shard.ShardState;
 import org.springframework.extensions.webscripts.WebScriptRequest;
 import org.springframework.extensions.webscripts.WebScriptResponse;
 import org.springframework.stereotype.Component;
 
 import com.inteligr8.alfresco.asie.compute.SolrShardHashTable;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
 import com.inteligr8.alfresco.asie.rest.model.NodeInfo;
 import com.inteligr8.alfresco.asie.rest.model.NodeShardInfo;
 import com.inteligr8.alfresco.asie.rest.model.ShardInfo;
@@ -22,32 +21,32 @@ import com.inteligr8.alfresco.asie.rest.model.ShardSetInfo;
 public class GetNodeWebScript extends AbstractAsieNodeWebScript {
     
     @Override
-    protected void execute(WebScriptRequest req, WebScriptResponse res, Set<ShardState> registeredNodeShards) throws IOException {
-		ShardState anyRegisteredNodeShard = registeredNodeShards.iterator().next();
-		ShardInstance registeredNode = anyRegisteredNodeShard.getShardInstance();
-		int maxShards = registeredNode.getShard().getFloc().getNumberOfShards();
-
+    protected void execute(WebScriptRequest req, WebScriptResponse res, SolrHost node, Map<ShardSet, Map<Integer, ShardInstanceState>> shardSetShardStates) throws IOException {
     	SolrShardHashSampleType sampleHashType = this.getOptionalQueryParameter(req, "sampleHashType", SolrShardHashSampleType.class);
-		SolrShardHashTable<?> sampleHashTable = sampleHashType == null ? null : this.createSampleHashTable(sampleHashType, maxShards);
 
-		NodeInfo node = new NodeShardInfo(registeredNode);
-		
-		for (ShardState registeredNodeShard : registeredNodeShards) {
-			ShardInfo shard = new ShardInfo();
-			shard.setId(registeredNodeShard.getShardInstance().getShard().getInstance());
-			shard.setLatestTx(OffsetDateTime.ofInstant(Instant.ofEpochMilli(registeredNodeShard.getLastIndexedTxCommitTime()), ZoneOffset.UTC));
-			shard.setTxsCompleted(registeredNodeShard.getLastIndexedTxId());
-			
-			shard.setShardSet(new ShardSetInfo(registeredNodeShard.getShardInstance().getShard().getFloc(), registeredNodeShard));
-			if (sampleHashTable != null)
-				this.addShardHashSamples(shard, sampleHashTable);
-			
-			node.getShards().put(shard.getId(), shard);
-		}
+		NodeInfo nodeResponse = NodeShardInfo.from(node);
+    	
+    	for (Entry<ShardSet, Map<Integer, ShardInstanceState>> shardSet : shardSetShardStates.entrySet()) {
+    		Short maxShards = shardSet.getKey().getShards();
+    		SolrShardHashTable<?> sampleHashTable = null;
+    		if (sampleHashType != null && maxShards != null)
+    			sampleHashTable = this.createSampleHashTable(sampleHashType, maxShards);
+
+    		ShardSetInfo shardSetResponse = ShardSetInfo.from(shardSet.getKey());
+    		
+    		for (Entry<Integer, ShardInstanceState> shard : shardSet.getValue().entrySet()) {
+    			ShardInfo shardResponse = ShardInfo.from(shard.getKey(), shard.getValue());
+    			shardResponse.setShardSet(shardSetResponse);
+    			if (sampleHashTable != null)
+    				this.addShardHashSamples(shardResponse, sampleHashTable);
+    			
+    			nodeResponse.getShards().put(shardResponse.getId(), shardResponse);
+    		}
+    	}
 
 		res.setContentType("application/json");
 		res.setContentEncoding("utf-8");
-		this.getObjectMapper().writeValue(res.getWriter(), node);
+		this.getObjectMapper().writeValue(res.getWriter(), nodeResponse);
     }
     
 }

shared/src/main/java/com/inteligr8/alfresco/asie/rest/GetNodesWebScript.java

@@ -8,6 +8,7 @@ import java.util.TreeMap;
 
 import org.alfresco.repo.index.shard.Floc;
 import org.alfresco.repo.index.shard.Shard;
+import org.alfresco.repo.index.shard.ShardMethodEnum;
 import org.alfresco.repo.index.shard.ShardState;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -18,7 +19,9 @@ import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Component;
 
 import com.inteligr8.alfresco.asie.compute.SolrShardHashTable;
-import com.inteligr8.alfresco.asie.model.Node;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
 import com.inteligr8.alfresco.asie.rest.model.NodeInfo;
 import com.inteligr8.alfresco.asie.rest.model.NodeShardInfo;
 import com.inteligr8.alfresco.asie.rest.model.ShardInfo;
@@ -39,34 +42,44 @@ public class GetNodesWebScript extends AbstractAsieShardableWebScript {
 
 		SolrShardHashSampleType sampleHashType = this.getOptionalQueryParameter(req, "sampleHashType", SolrShardHashSampleType.class);
 
-		Map<String, NodeInfo> nodes = new TreeMap<>();
+		Map<String, NodeInfo> nodesResponse = new TreeMap<>();
 		
 		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
-			int maxShards = floc.getKey().getNumberOfShards();
+			Short maxShards = floc.getKey().getShardMethod().equals(ShardMethodEnum.DB_ID_RANGE) ? null : (short) floc.getKey().getNumberOfShards();
+			SolrShardHashTable<?> sampleHashTable = null;
+			if (sampleHashType != null && maxShards != null)
+				sampleHashTable = this.createSampleHashTable(sampleHashType, maxShards);
 			
-			SolrShardHashTable<?> sampleHashTable = sampleHashType == null ? null : this.createSampleHashTable(sampleHashType, maxShards);
+			ShardSetInfo shardSetResponse = null;
 			
 			for (Entry<Shard, Set<ShardState>> registeredShards : floc.getValue().entrySet()) {
 				for (ShardState registeredShardNode : registeredShards.getValue()) {
-					String nodeId = new Node(registeredShardNode.getShardInstance()).getId();
-					NodeInfo node = nodes.get(nodeId);
-					if (node == null) {
-						node = new NodeShardInfo(registeredShardNode.getShardInstance());
-						nodes.put(node.getId(), node);
+					if (shardSetResponse == null) {
+						ShardSet shardSet = ShardSet.from(floc.getKey(), registeredShardNode);
+						shardSetResponse = ShardSetInfo.from(shardSet);
 					}
 					
-					ShardInfo shard = new ShardInfo(registeredShardNode);
-					shard.setShardSet(new ShardSetInfo(floc.getKey(), registeredShardNode));
+					SolrHost node = SolrHost.from(registeredShardNode.getShardInstance());
+					String nodeSpec = node.getSpec();
+					NodeInfo nodeResponse = nodesResponse.get(nodeSpec);
+					if (nodeResponse == null) {
+						nodeResponse = NodeShardInfo.from(node);
+						nodesResponse.put(nodeResponse.getId(), nodeResponse);
+					}
+					
+					ShardInstanceState nodeShardState = ShardInstanceState.from(registeredShardNode);
+					ShardInfo shardResponse = ShardInfo.from(registeredShards.getKey().getInstance(), nodeShardState);
+					shardResponse.setShardSet(shardSetResponse);
 					if (sampleHashTable != null)
-						this.addShardHashSamples(shard, sampleHashTable);
-					node.getShards().put(shard.getId(), shard);
+						this.addShardHashSamples(shardResponse, sampleHashTable);
+					nodeResponse.getShards().put(shardResponse.getId(), shardResponse);
 				}
 			}
 		}
 
 		res.setContentType("application/json");
 		res.setContentEncoding("utf-8");
-		this.getObjectMapper().writeValue(res.getWriter(), nodes);
+		this.getObjectMapper().writeValue(res.getWriter(), nodesResponse);
     }
     
 }

shared/src/main/java/com/inteligr8/alfresco/asie/rest/GetPropertyHashShardsWebScript.java

@@ -1,11 +1,7 @@
 package com.inteligr8.alfresco.asie.rest;
 
 import java.io.IOException;
-import java.time.Instant;
-import java.time.OffsetDateTime;
-import java.time.ZoneOffset;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
@@ -14,10 +10,7 @@ import java.util.Map.Entry;
 import java.util.Set;
 import java.util.TreeMap;
 
-import org.alfresco.repo.index.shard.Floc;
-import org.alfresco.repo.index.shard.Shard;
 import org.alfresco.repo.index.shard.ShardMethodEnum;
-import org.alfresco.repo.index.shard.ShardState;
 import org.alfresco.util.Pair;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -30,11 +23,14 @@ import org.springframework.http.MediaType;
 import org.springframework.stereotype.Component;
 
 import com.inteligr8.alfresco.asie.compute.SolrShardHashTable;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
 import com.inteligr8.alfresco.asie.rest.model.NodeInfo;
 import com.inteligr8.alfresco.asie.rest.model.PropertyHashShardSetInfo;
 import com.inteligr8.alfresco.asie.rest.model.ShardInfo;
 import com.inteligr8.alfresco.asie.rest.model.ShardNodeInfo;
-import com.inteligr8.alfresco.asie.service.ShardDiscoveryService;
+import com.inteligr8.alfresco.asie.spi.ShardDiscoveryService;
 
 @Component(value = "webscript.com.inteligr8.alfresco.asie.propertyHashShards.get")
 public class GetPropertyHashShardsWebScript extends AbstractAsieShardableWebScript {
@@ -55,19 +51,18 @@ public class GetPropertyHashShardsWebScript extends AbstractAsieShardableWebScri
 		List<String> values = this.getOptionalQueryParameterAsList(req);
 		this.validateParameters(min, max, values);
 		
-		List<PropertyHashShardSetInfo> shardSets = new LinkedList<>();
-		
-		Collection<Pair<Floc, Map<Shard, Set<ShardState>>>> flocs = this.sds.findByShardMethod(ShardMethodEnum.PROPERTY);
-		if (flocs.isEmpty())
+		List<PropertyHashShardSetInfo> shardSetsResponse = new LinkedList<>();
+
+		Set<ShardSet> shardSets = this.sds.findSetsByShardMethod(ShardMethodEnum.PROPERTY);
+		if (shardSets.isEmpty())
 			throw new WebScriptException(HttpStatus.NO_CONTENT.value(), "There are no property-based shards");
 		
-		for (Pair<Floc, Map<Shard, Set<ShardState>>> floc : flocs) {
-			ShardState anyShardNode = this.getAnyShardNode(floc.getSecond());
-			PropertyHashShardSetInfo shardSet = new PropertyHashShardSetInfo(floc.getFirst(), anyShardNode);
-			shardSet.setShards(new TreeMap<>());
+		for (ShardSet shardSet : shardSets) {
+			PropertyHashShardSetInfo shardSetResponse = PropertyHashShardSetInfo.from(shardSet);
+			shardSetResponse.setShards(new TreeMap<>());
 
-			int maxShards = floc.getFirst().getNumberOfShards();
-			SolrShardHashTable<?> sampleHashTable = this.createSampleHashTable(sampleHashType, maxShards);
+			Short shardCount = shardSet.getShards();
+			SolrShardHashTable<?> sampleHashTable = this.createSampleHashTable(sampleHashType, shardCount);
 			
 			Map<Integer, List<Object>> shardToHashMap = new HashMap<>();
 			
@@ -83,39 +78,24 @@ public class GetPropertyHashShardsWebScript extends AbstractAsieShardableWebScri
 				}
 			}
 			
-			for (Entry<Shard, Set<ShardState>> shardCache : floc.getSecond().entrySet()) {
-				ShardInfo shard = new ShardInfo();
-				shard.setId(shardCache.getKey().getInstance());
-				shard.setNodes(new HashMap<>());
-				
-				for (ShardState shardNodeCache : shardCache.getValue()) {
-					if (shard.getTxsCompleted() == null || shard.getTxsCompleted().longValue() < shardNodeCache.getLastIndexedTxId()) {
-						shard.setLatestTx(OffsetDateTime.ofInstant(Instant.ofEpochMilli(shardNodeCache.getLastIndexedTxCommitTime()), ZoneOffset.UTC));
-						shard.setTxsCompleted(shardNodeCache.getLastIndexedTxId());
-					}
+			for (Entry<Integer, Pair<SolrHost, ShardInstanceState>> shard : this.sds.findLatestNodeStates(shardSet).entrySet()) {
+				ShardInfo shardResponse = ShardInfo.from(shard.getKey(), shard.getValue().getSecond());
+				shardResponse.setNodes(new HashMap<>());
 					
-					NodeInfo node = new ShardNodeInfo(shardNodeCache);
-					shard.getNodes().put(node.getId(), node);
-				}
+				NodeInfo nodeResponse = ShardNodeInfo.from(shard.getValue().getFirst(), shard.getValue().getSecond());
+				shardResponse.getNodes().put(nodeResponse.getId(), nodeResponse);
 	
-				List<Object> hashedValues = shardToHashMap.get(shard.getId());
+				List<Object> hashedValues = shardToHashMap.get(shardResponse.getId());
 				if (hashedValues != null) for (Object hashedValue : hashedValues)
-					shardSet.getShards().put(hashedValue, shard);
+					shardSetResponse.getShards().put(hashedValue, shardResponse);
 			}
 			
-			shardSets.add(shardSet);
+			shardSetsResponse.add(shardSetResponse);
 		}
 
 		res.setContentType(MediaType.APPLICATION_JSON_VALUE);
 		res.setContentEncoding("utf-8");
-		this.getObjectMapper().writeValue(res.getWriter(), shardSets);
-    }
-    
-    private ShardState getAnyShardNode(Map<Shard, Set<ShardState>> shards) {
-    	for (Set<ShardState> shardNodes : shards.values())
-    		for (ShardState shardNode : shardNodes)
-    			return shardNode;
-    	return null;
+		this.getObjectMapper().writeValue(res.getWriter(), shardSetsResponse);
     }
     
     private List<String> getOptionalQueryParameterAsList(WebScriptRequest req) {

shared/src/main/java/com/inteligr8/alfresco/asie/rest/GetShardWebScript.java

@@ -1,20 +1,19 @@
 package com.inteligr8.alfresco.asie.rest;
 
 import java.io.IOException;
-import java.time.Instant;
-import java.time.OffsetDateTime;
-import java.time.ZoneOffset;
-import java.util.Set;
+import java.util.List;
 import java.util.TreeMap;
 
-import org.alfresco.repo.index.shard.Shard;
-import org.alfresco.repo.index.shard.ShardState;
+import org.alfresco.util.Pair;
 import org.springframework.extensions.webscripts.WebScriptRequest;
 import org.springframework.extensions.webscripts.WebScriptResponse;
 import org.springframework.http.MediaType;
 import org.springframework.stereotype.Component;
 
 import com.inteligr8.alfresco.asie.compute.SolrShardHashTable;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
 import com.inteligr8.alfresco.asie.rest.model.NodeInfo;
 import com.inteligr8.alfresco.asie.rest.model.ShardInfo;
 import com.inteligr8.alfresco.asie.rest.model.ShardNodeInfo;
@@ -24,34 +23,35 @@ import com.inteligr8.alfresco.asie.rest.model.ShardSetInfo;
 public class GetShardWebScript extends AbstractAsieShardWebScript {
 
     @Override
-    public void execute(WebScriptRequest req, WebScriptResponse res, Set<ShardState> registeredShardNodes) throws IOException {
-		ShardState aRegisteredShardNode = registeredShardNodes.iterator().next();
-		Shard registeredShard = aRegisteredShardNode.getShardInstance().getShard();
-		int maxShards = registeredShard.getFloc().getNumberOfShards();
-
+    public void execute(WebScriptRequest req, WebScriptResponse res, int shardId, ShardSet shardSet, List<Pair<SolrHost, ShardInstanceState>> nodeShardStates) throws IOException {
     	SolrShardHashSampleType sampleHashType = this.getOptionalQueryParameter(req, "sampleHashType", SolrShardHashSampleType.class);
-		SolrShardHashTable<?> sampleHashTable = sampleHashType == null ? null : this.createSampleHashTable(sampleHashType, maxShards);
 
-		ShardInfo shard = new ShardInfo();
-		shard.setId(registeredShard.getInstance());
-		shard.setShardSet(new ShardSetInfo(registeredShard.getFloc(), aRegisteredShardNode));
-		shard.setNodes(new TreeMap<>());
+		Short maxShards = shardSet.getShards();
+		SolrShardHashTable<?> sampleHashTable = null;
+		if (sampleHashType != null && maxShards != null)
+			sampleHashTable = this.createSampleHashTable(sampleHashType, maxShards);
+
+		ShardSetInfo shardSetResponse = ShardSetInfo.from(shardSet);
+
+		ShardInfo shardResponse = ShardInfo.from(shardId);
+		shardResponse.setShardSet(shardSetResponse);
+		shardResponse.setNodes(new TreeMap<>());
 		if (sampleHashTable != null)
-			this.addShardHashSamples(shard, sampleHashTable);
+			this.addShardHashSamples(shardResponse, sampleHashTable);
 			
-		for (ShardState registeredShardNode : registeredShardNodes) {
-			if (shard.getTxsCompleted() == null || shard.getTxsCompleted().longValue() < registeredShardNode.getLastIndexedTxId()) {
-				shard.setLatestTx(OffsetDateTime.ofInstant(Instant.ofEpochMilli(registeredShardNode.getLastIndexedTxCommitTime()), ZoneOffset.UTC));
-				shard.setTxsCompleted(registeredShardNode.getLastIndexedTxId());
+		for (Pair<SolrHost, ShardInstanceState> nodeShardState : nodeShardStates) {
+			if (shardResponse.getTxsCompleted() == null || shardResponse.getTxsCompleted().longValue() < nodeShardState.getSecond().getLastIndexedTxId()) {
+				shardResponse.setLatestTx(nodeShardState.getSecond().getLastIndexedTxTime());
+				shardResponse.setTxsCompleted(nodeShardState.getSecond().getLastIndexedTxId());
 			}
 			
-			NodeInfo node = new ShardNodeInfo(registeredShardNode);
-			shard.getNodes().put(node.getId(), node);
+			NodeInfo node = ShardNodeInfo.from(nodeShardState.getFirst(), nodeShardState.getSecond());
+			shardResponse.getNodes().put(node.getId(), node);
 		}
 
 		res.setContentType(MediaType.APPLICATION_JSON_VALUE);
 		res.setContentEncoding("utf-8");
-		this.getObjectMapper().writeValue(res.getWriter(), shard);
+		this.getObjectMapper().writeValue(res.getWriter(), shardResponse);
     }
     
 }

shared/src/main/java/com/inteligr8/alfresco/asie/rest/GetShardsWebScript.java

@@ -22,6 +22,9 @@ import org.springframework.http.MediaType;
 import org.springframework.stereotype.Component;
 
 import com.inteligr8.alfresco.asie.compute.SolrShardHashTable;
+import com.inteligr8.alfresco.asie.model.ShardSet;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
 import com.inteligr8.alfresco.asie.rest.model.NodeInfo;
 import com.inteligr8.alfresco.asie.rest.model.ShardInfo;
 import com.inteligr8.alfresco.asie.rest.model.ShardNodeInfo;
@@ -42,42 +45,46 @@ public class GetShardsWebScript extends AbstractAsieShardableWebScript {
 
 		SolrShardHashSampleType sampleHashType = this.getOptionalQueryParameter(req, "sampleHashType", SolrShardHashSampleType.class);
 
-		Map<String, ShardSetInfo> shardSets = new TreeMap<>();
+		Map<String, ShardSetInfo> shardSetsResponse = new TreeMap<>();
 		
 		for (Entry<Floc, Map<Shard, Set<ShardState>>> floc : flocs.entrySet()) {
-			int maxShards = floc.getKey().getNumberOfShards();
 			ShardState anyShardNode = this.getAnyShardNode(floc.getValue());
-			ShardSetInfo shardSet = new ShardSetInfo(floc.getKey(), anyShardNode);
-			shardSet.setShards(new TreeMap<>());
-
-			SolrShardHashTable<?> sampleHashTable = sampleHashType == null ? null : this.createSampleHashTable(sampleHashType, maxShards);
+			ShardSet shardSet = ShardSet.from(floc.getKey(), anyShardNode);
+			ShardSetInfo shardSetResponse = ShardSetInfo.from(shardSet);
+			shardSetResponse.setShards(new TreeMap<>());
+			
+			Short maxShards = shardSet.getShards();
+			SolrShardHashTable<?> sampleHashTable = null;
+			if (sampleHashType != null && maxShards != null)
+				sampleHashTable = this.createSampleHashTable(sampleHashType, maxShards);
 			
 			for (Entry<Shard, Set<ShardState>> registeredShard : floc.getValue().entrySet()) {
-				ShardInfo shard = new ShardInfo();
-				shard.setId(registeredShard.getKey().getInstance());
-				shard.setNodes(new TreeMap<>());
+				ShardInfo shardResponse = ShardInfo.from(registeredShard.getKey().getInstance());
+				shardResponse.setNodes(new TreeMap<>());
 				
 				for (ShardState registeredShardNode : registeredShard.getValue()) {
-					if (shard.getTxsCompleted() == null || shard.getTxsCompleted().longValue() < registeredShardNode.getLastIndexedTxId()) {
-						shard.setLatestTx(OffsetDateTime.ofInstant(Instant.ofEpochMilli(registeredShardNode.getLastIndexedTxCommitTime()), ZoneOffset.UTC));
-						shard.setTxsCompleted(registeredShardNode.getLastIndexedTxId());
+					if (shardResponse.getTxsCompleted() == null || shardResponse.getTxsCompleted().longValue() < registeredShardNode.getLastIndexedTxId()) {
+						shardResponse.setLatestTx(OffsetDateTime.ofInstant(Instant.ofEpochMilli(registeredShardNode.getLastIndexedTxCommitTime()), ZoneOffset.UTC));
+						shardResponse.setTxsCompleted(registeredShardNode.getLastIndexedTxId());
 					}
 					
-					NodeInfo node = new ShardNodeInfo(registeredShardNode);
-					shard.getNodes().put(node.getId(), node);
+					SolrHost node = SolrHost.from(registeredShardNode.getShardInstance());
+					ShardInstanceState nodeShardState = ShardInstanceState.from(registeredShardNode);
+					NodeInfo nodeResponse = ShardNodeInfo.from(node, nodeShardState);
+					shardResponse.getNodes().put(nodeResponse.getId(), nodeResponse);
 				}
 
 				if (sampleHashTable != null)
-					this.addShardHashSamples(shardSet, shard, sampleHashTable);
-				shardSet.getShards().put(shard.getId(), shard);
+					this.addShardHashSamples(shardSetResponse, shardResponse, sampleHashTable);
+				shardSetResponse.getShards().put(shardResponse.getId(), shardResponse);
 			}
 			
-			shardSets.put(shardSet.getMethodSpec(), shardSet);
+			shardSetsResponse.put(shardSetResponse.getSpec(), shardSetResponse);
 		}
 
 		res.setContentType(MediaType.APPLICATION_JSON_VALUE);
 		res.setContentEncoding("utf-8");
-		this.getObjectMapper().writeValue(res.getWriter(), shardSets);
+		this.getObjectMapper().writeValue(res.getWriter(), shardSetsResponse);
     }
     
     private ShardState getAnyShardNode(Map<Shard, Set<ShardState>> shards) {

shared/src/main/java/com/inteligr8/alfresco/asie/rest/PurgeAcsNodeWebScript.java

@@ -0,0 +1,24 @@
+package com.inteligr8.alfresco.asie.rest;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import com.inteligr8.alfresco.asie.service.PurgeService;
+import com.inteligr8.alfresco.asie.spi.ActionCallback;
+
+@Component(value = "webscript.com.inteligr8.alfresco.asie.purgeAcsNode.put")
+public class PurgeAcsNodeWebScript extends AbstractAcsNodeActionWebScript {
+	
+	@Autowired
+	private PurgeService purgeSerivce;
+	
+	@Override
+	protected void executeAction(long nodeDbId, ActionCallback callback, long fullQueueTimeout, TimeUnit fullQueueUnit,
+			long execTimeout, TimeUnit execUnit) throws TimeoutException, InterruptedException {
+		this.purgeSerivce.purge(nodeDbId, callback, 10L, TimeUnit.SECONDS, 30L, TimeUnit.SECONDS);
+    }
+    
+}

shared/src/main/java/com/inteligr8/alfresco/asie/rest/ReconcileAcsNodesWebScript.java

@@ -0,0 +1,128 @@
+package com.inteligr8.alfresco.asie.rest;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.extensions.webscripts.WebScriptException;
+import org.springframework.extensions.webscripts.WebScriptRequest;
+import org.springframework.extensions.webscripts.WebScriptResponse;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Component;
+
+import com.inteligr8.alfresco.asie.model.ShardInstance;
+import com.inteligr8.alfresco.asie.service.AcsReconcileService;
+import com.inteligr8.alfresco.asie.spi.ReconcileCallback;
+
+@Component(value = "webscript.com.inteligr8.alfresco.asie.reconcileAcsNodes.post")
+public class ReconcileAcsNodesWebScript extends AbstractAsieWebScript {
+	
+	@Autowired
+	private AcsReconcileService reconcileService;
+	
+	@Override
+	public void executeAuthorized(WebScriptRequest request, WebScriptResponse response) throws IOException {
+		final int fromDbId = this.getRequestTemplateIntegerVariable(request, "fromDbId");
+		final int toDbId = this.getRequestTemplateIntegerVariable(request, "toDbId");
+		final boolean reindex = Boolean.TRUE.equals(this.getOptionalQueryParameter(request, "reindex", Boolean.class));
+		final boolean includeReconciled = Boolean.TRUE.equals(this.getOptionalQueryParameter(request, "includeReconciled", Boolean.class));
+		
+		final Map<String, Object> responseMap = new HashMap<>();
+		
+		ReconcileCallback callback = new ReconcileCallback() {
+			
+			@Override
+			public void reconciled(long nodeDbId) {
+				if (includeReconciled) {
+					@SuppressWarnings("unchecked")
+					List<Long> unreconciledNodeDbIds = (List<Long>) responseMap.get("reconciled");
+					if (unreconciledNodeDbIds == null)
+						responseMap.put("reconciled", unreconciledNodeDbIds = new LinkedList<>());
+					unreconciledNodeDbIds.add(nodeDbId);
+				}
+			}
+			
+			@Override
+			public void unreconciled(long nodeDbId) {
+				@SuppressWarnings("unchecked")
+				List<Long> unreconciledNodeDbIds = (List<Long>) responseMap.get("unreconciled");
+				if (unreconciledNodeDbIds == null)
+					responseMap.put("unreconciled", unreconciledNodeDbIds = new LinkedList<>());
+				unreconciledNodeDbIds.add(nodeDbId);
+			}
+			
+			@Override
+			public void processed(long nodeDbId, Set<ShardInstance> instsReconciled, Set<ShardInstance> instsReconciling,
+					Map<ShardInstance, String> instsErrorMessages) {
+				if (!instsReconciled.isEmpty()) {
+					@SuppressWarnings("unchecked")
+					Map<Long, List<String>> nodeHosts = (Map<Long, List<String>>) responseMap.get("success");
+					if (nodeHosts == null)
+						responseMap.put("success", nodeHosts = new HashMap<>());
+					
+					List<String> instances = new LinkedList<>();
+					for (ShardInstance instance : instsReconciled)
+						instances.add(instance.getSpec());
+					nodeHosts.put(nodeDbId, instances);
+				}
+				
+				if (!instsReconciling.isEmpty()) {
+					@SuppressWarnings("unchecked")
+					Map<Long, List<String>> nodeHosts = (Map<Long, List<String>>) responseMap.get("scheduled");
+					if (nodeHosts == null)
+						responseMap.put("scheduled", nodeHosts = new HashMap<>());
+					
+					List<String> instances = new LinkedList<>();
+					for (ShardInstance instance : instsReconciled)
+						instances.add(instance.getSpec());
+					nodeHosts.put(nodeDbId, instances);
+				}
+				
+				if (!instsErrorMessages.isEmpty()) {
+					@SuppressWarnings("unchecked")
+					Map<Long, Map<String, Map<String, String>>> nodeHosts = (Map<Long, Map<String, Map<String, String>>>) responseMap.get("error");
+					if (nodeHosts == null)
+						responseMap.put("error", nodeHosts = new HashMap<>());
+					
+					Map<String, Map<String, String>> nodeHost = new HashMap<>();
+					for (Entry<ShardInstance, String> message : instsErrorMessages.entrySet())
+						nodeHost.put(message.getKey().getSpec(), Collections.singletonMap("message", message.getValue()));
+					nodeHosts.put(nodeDbId, nodeHost);
+				}
+			}
+		};
+		
+		try {
+			this.reconcileService.reconcile(fromDbId, toDbId, null, reindex, callback, 1L, TimeUnit.HOURS, 2L, TimeUnit.MINUTES);
+
+			if (responseMap.containsKey("error")) {
+				response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
+			} else if (responseMap.containsKey("scheduled")) {
+				response.setStatus(HttpStatus.ACCEPTED.value());
+			} else {
+				response.setStatus(HttpStatus.OK.value());
+			}
+
+			response.setContentType("application/json");
+			this.getObjectMapper().writeValue(response.getWriter(), responseMap);
+		} catch (InterruptedException ie) {
+			throw new WebScriptException(HttpStatus.SERVICE_UNAVAILABLE.value(), "The reindex was interrupted", ie);
+		} catch (TimeoutException te) {
+			throw new WebScriptException(HttpStatus.INTERNAL_SERVER_ERROR.value(), "The reindex may continue, but timed-out waiting", te);
+		}
+    }
+	
+	private int getRequestTemplateIntegerVariable(WebScriptRequest request, String templateVariableName) {
+		String str = request.getServiceMatch().getTemplateVars().get(templateVariableName);
+		return Integer.valueOf(str);
+	}
+    
+}

shared/src/main/java/com/inteligr8/alfresco/asie/rest/ReindexAcsNodeWebScript.java

@@ -0,0 +1,24 @@
+package com.inteligr8.alfresco.asie.rest;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import com.inteligr8.alfresco.asie.service.ReindexService;
+import com.inteligr8.alfresco.asie.spi.ActionCallback;
+
+@Component(value = "webscript.com.inteligr8.alfresco.asie.reindexAcsNode.put")
+public class ReindexAcsNodeWebScript extends AbstractAcsNodeActionWebScript {
+	
+	@Autowired
+	private ReindexService reindexSerivce;
+	
+	@Override
+	protected void executeAction(long nodeDbId, ActionCallback callback, long fullQueueTimeout, TimeUnit fullQueueUnit,
+			long execTimeout, TimeUnit execUnit) throws TimeoutException, InterruptedException {
+		this.reindexSerivce.reindex(nodeDbId, callback, 10L, TimeUnit.SECONDS, 30L, TimeUnit.SECONDS);
+    }
+    
+}

shared/src/main/java/com/inteligr8/alfresco/asie/rest/RetryWebScript.java

@@ -0,0 +1,24 @@
+package com.inteligr8.alfresco.asie.rest;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import com.inteligr8.alfresco.asie.service.RetryService;
+import com.inteligr8.alfresco.asie.spi.ActionCallback;
+
+@Component(value = "webscript.com.inteligr8.alfresco.asie.retry.post")
+public class RetryWebScript extends AbstractActionWebScript {
+	
+	@Autowired
+	private RetryService retrySerivce;
+	
+	@Override
+	protected void executeAction(ActionCallback callback, long fullQueueTimeout, TimeUnit fullQueueUnit,
+			long execTimeout, TimeUnit execUnit) throws TimeoutException, InterruptedException {
+		this.retrySerivce.retry(callback, 10L, TimeUnit.SECONDS, 30L, TimeUnit.SECONDS);
+    }
+    
+}

shared/src/main/java/com/inteligr8/alfresco/asie/rest/model/NodeInfo.java

@@ -3,12 +3,10 @@ package com.inteligr8.alfresco.asie.rest.model;
 import java.util.Map;
 import java.util.TreeMap;
 
-import org.alfresco.repo.index.shard.ShardInstance;
-
 import com.fasterxml.jackson.annotation.JsonProperty;
-import com.inteligr8.alfresco.asie.model.Node;
+import com.inteligr8.alfresco.asie.model.SolrHost;
 
-public abstract class NodeInfo {
+public abstract class NodeInfo implements ResponseInfo {
 
 	@JsonProperty	
 	private String id;
@@ -19,8 +17,8 @@ public abstract class NodeInfo {
 	public NodeInfo() {
 	}
 	
-	public NodeInfo(ShardInstance nodeCache) {
-		this.setId(new Node(nodeCache).getId());
+	protected NodeInfo(SolrHost node) {
+		this.id = node.getSpec();
 	}
 	
 	public String getId() {

shared/src/main/java/com/inteligr8/alfresco/asie/rest/model/NodeParameterSet.java

@@ -1,4 +1,4 @@
-package com.inteligr8.alfresco.asie.model;
+package com.inteligr8.alfresco.asie.rest.model;
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;

shared/src/main/java/com/inteligr8/alfresco/asie/rest/model/NodeShardInfo.java

@@ -2,25 +2,28 @@ package com.inteligr8.alfresco.asie.rest.model;
 
 import java.util.Map;
 
-import org.alfresco.repo.index.shard.ShardInstance;
-
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonInclude.Include;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.inteligr8.alfresco.asie.model.SolrHost;
 
 @JsonInclude(Include.NON_EMPTY)
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class NodeShardInfo extends NodeInfo {
 	
+	public static NodeShardInfo from(SolrHost node) {
+		return new NodeShardInfo(node);
+	}
+	
 	@JsonProperty
 	private Map<Integer, ShardInfo> shards;
 	
 	public NodeShardInfo() {
 	}
 	
-	public NodeShardInfo(ShardInstance nodeCache) {
-		super(nodeCache);
+	protected NodeShardInfo(SolrHost node) {
+		super(node);
 	}
 
 }

shared/src/main/java/com/inteligr8/alfresco/asie/rest/model/NodeShardParameterSet.java

@@ -1,4 +1,6 @@
-package com.inteligr8.alfresco.asie.model;
+package com.inteligr8.alfresco.asie.rest.model;
+
+import com.inteligr8.alfresco.asie.model.ShardSet;
 
 public class NodeShardParameterSet extends NodeParameterSet {
 	

shared/src/main/java/com/inteligr8/alfresco/asie/rest/model/PropertyHashShardSetInfo.java

@@ -2,24 +2,25 @@ package com.inteligr8.alfresco.asie.rest.model;
 
 import java.util.Map;
 
-import org.alfresco.repo.index.shard.Floc;
-import org.alfresco.repo.index.shard.ShardState;
-
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonInclude.Include;
-import com.inteligr8.alfresco.asie.model.ShardSet;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.inteligr8.alfresco.asie.model.ShardSet;
 
 @JsonInclude(Include.NON_EMPTY)
 @JsonIgnoreProperties(ignoreUnknown = true)
-public class PropertyHashShardSetInfo {
+public class PropertyHashShardSetInfo implements ResponseInfo {
+	
+	public static PropertyHashShardSetInfo from(ShardSet shardSet) {
+		return new PropertyHashShardSetInfo(shardSet);
+	}
 
 	@JsonProperty	
-	private String methodSpec;
-	
-	@JsonProperty
-	private int shardCount;
+	private String core;
+
+	@JsonProperty	
+	private String spec;
 
 	@JsonProperty
 	private Map<Object, ShardInfo> shards;
@@ -27,26 +28,25 @@ public class PropertyHashShardSetInfo {
 	public PropertyHashShardSetInfo() {
 	}
 	
-	public PropertyHashShardSetInfo(Floc floc, ShardState anyShardNode) {
-		ShardSet shardSet = new ShardSet(floc, anyShardNode);
-		this.setMethodSpec(shardSet.toSpec());
-		this.setShardCount(floc.getNumberOfShards());
+	protected PropertyHashShardSetInfo(ShardSet shardSet) {
+		this.core = shardSet.getCore();
+		this.spec = shardSet.toSpec();
+	}
+	
+	public String getCore() {
+		return core;
+	}
+	
+	public void setCore(String core) {
+		this.core = core;
 	}
 
-	public String getMethodSpec() {
-		return this.methodSpec;
+	public String getSpec() {
+		return this.spec;
 	}
 
-	public void setMethodSpec(String methodSpec) {
-		this.methodSpec = methodSpec;
-	}
-
-	public int getShardCount() {
-		return shardCount;
-	}
-
-	public void setShardCount(int shardCount) {
-		this.shardCount = shardCount;
+	public void setSpec(String spec) {
+		this.spec = spec;
 	}
 
 	public Map<Object, ShardInfo> getShards() {

shared/src/main/java/com/inteligr8/alfresco/asie/rest/model/RequestParameterSet.java

@@ -0,0 +1,5 @@
+package com.inteligr8.alfresco.asie.rest.model;
+
+public interface RequestParameterSet {
+
+}

shared/src/main/java/com/inteligr8/alfresco/asie/rest/model/ResponseInfo.java

@@ -0,0 +1,5 @@
+package com.inteligr8.alfresco.asie.rest.model;
+
+public interface ResponseInfo {
+
+}

shared/src/main/java/com/inteligr8/alfresco/asie/rest/model/ShardInfo.java

@@ -1,22 +1,27 @@
 package com.inteligr8.alfresco.asie.rest.model;
 
-import java.time.Instant;
 import java.time.OffsetDateTime;
-import java.time.ZoneOffset;
 import java.util.Map;
 
-import org.alfresco.repo.index.shard.ShardState;
-
 import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonFormat.Shape;
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonInclude;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import com.fasterxml.jackson.annotation.JsonFormat.Shape;
 import com.fasterxml.jackson.annotation.JsonInclude.Include;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
 
 @JsonInclude(Include.NON_EMPTY)
 @JsonIgnoreProperties(ignoreUnknown = true)
-public class ShardInfo {
+public class ShardInfo implements ResponseInfo {
+	
+	public static ShardInfo from(int shardId) {
+		return new ShardInfo(shardId, null);
+	}
+	
+	public static ShardInfo from(int shardId, ShardInstanceState nodeShardState) {
+		return new ShardInfo(shardId, nodeShardState);
+	}
 
 	@JsonProperty	
 	private int id;
@@ -40,10 +45,10 @@ public class ShardInfo {
 	public ShardInfo() {
 	}
 	
-	public ShardInfo(ShardState shard) {
-		this.setId(shard.getShardInstance().getShard().getInstance());
-		this.setLatestTx(OffsetDateTime.ofInstant(Instant.ofEpochMilli(shard.getLastIndexedTxCommitTime()), ZoneOffset.UTC));
-		this.setTxsCompleted(shard.getLastIndexedTxId());
+	protected ShardInfo(int shardId, ShardInstanceState nodeShardState) {
+		this.id = shardId;
+		this.latestTx = nodeShardState == null ? null : nodeShardState.getLastIndexedTxTime();
+		this.txsCompleted = nodeShardState == null ? null : nodeShardState.getLastIndexedTxId();
 	}
 
 	public int getId() {

shared/src/main/java/com/inteligr8/alfresco/asie/rest/model/ShardNodeInfo.java

@@ -1,10 +1,6 @@
 package com.inteligr8.alfresco.asie.rest.model;
 
-import java.time.Instant;
 import java.time.OffsetDateTime;
-import java.time.ZoneOffset;
-
-import org.alfresco.repo.index.shard.ShardState;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonFormat.Shape;
@@ -12,11 +8,17 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonInclude.Include;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.inteligr8.alfresco.asie.model.SolrHost;
+import com.inteligr8.alfresco.asie.model.ShardInstanceState;
 
 @JsonInclude(Include.NON_EMPTY)
 @JsonIgnoreProperties(ignoreUnknown = true)
 public class ShardNodeInfo extends NodeInfo {
 	
+	public static ShardNodeInfo from(SolrHost node, ShardInstanceState nodeShardState) {
+		return new ShardNodeInfo(node, nodeShardState);
+	}
+	
 	@JsonProperty
 	private Long txsCompleted;
 	
@@ -24,13 +26,16 @@ public class ShardNodeInfo extends NodeInfo {
 	@JsonFormat(shape = Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ssXXX")
 	private OffsetDateTime latestTx;
 	
+	/**
+	 * For Spring deserialization
+	 */
 	public ShardNodeInfo() {
 	}
 	
-	public ShardNodeInfo(ShardState shard) {
-		super(shard.getShardInstance());
-		this.setLatestTx(OffsetDateTime.ofInstant(Instant.ofEpochMilli(shard.getLastIndexedTxCommitTime()), ZoneOffset.UTC));
-		this.setTxsCompleted(shard.getLastIndexedTxId());
+	protected ShardNodeInfo(SolrHost node, ShardInstanceState nodeShardState) {
+		super(node);
+		this.latestTx = nodeShardState.getLastIndexedTxTime();
+		this.txsCompleted = nodeShardState.getLastIndexedTxId();
 	}
 	
 	public Long getTxsCompleted() {