| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| |
| package org.apache.oodt.cas.workflow.instrepo; |
| |
| //OODT imports |
| import org.apache.oodt.cas.metadata.Metadata; |
| import org.apache.oodt.cas.workflow.lifecycle.WorkflowLifecycleStage; |
| import org.apache.oodt.cas.workflow.lifecycle.WorkflowState; |
| import org.apache.oodt.cas.workflow.structs.Priority; |
| import org.apache.oodt.cas.workflow.structs.Workflow; |
| import org.apache.oodt.cas.workflow.structs.WorkflowCondition; |
| import org.apache.oodt.cas.workflow.structs.WorkflowInstance; |
| import org.apache.oodt.cas.workflow.structs.WorkflowTask; |
| import org.apache.oodt.cas.workflow.structs.WorkflowTaskConfiguration; |
| import org.apache.oodt.cas.workflow.structs.exceptions.InstanceRepositoryException; |
| |
| //JDK imports |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Vector; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| |
| //Lucene imports |
| import org.apache.lucene.analysis.standard.StandardAnalyzer; |
| import org.apache.lucene.document.Document; |
| import org.apache.lucene.document.Field; |
| import org.apache.lucene.index.IndexReader; |
| import org.apache.lucene.index.IndexWriter; |
| import org.apache.lucene.index.Term; |
| import org.apache.lucene.search.BooleanClause; |
| import org.apache.lucene.search.BooleanQuery; |
| import org.apache.lucene.search.Hits; |
| import org.apache.lucene.search.IndexSearcher; |
| import org.apache.lucene.search.Sort; |
| import org.apache.lucene.search.SortField; |
| import org.apache.lucene.search.TermQuery; |
| |
| //JUG imports |
| import org.safehaus.uuid.UUID; |
| import org.safehaus.uuid.UUIDGenerator; |
| |
| /** |
| * @author mattmann |
| * @version $Revision$ |
| * |
| * <p> |
| * An implementation of the {@link WorkflowEngine} interface that is backed by |
| * <a href="http://lucene.apache.org">Apache Lucene</a>. |
| * </p>. |
| */ |
| public class LuceneWorkflowInstanceRepository extends |
| AbstractPaginatibleInstanceRepository { |
| |
| /* path to lucene index directory to store wInst info */ |
| private String idxFilePath = null; |
| |
| /* our log stream */ |
| private static final Logger LOG = Logger |
| .getLogger(LuceneWorkflowInstanceRepository.class.getName()); |
| |
| /* our workflow inst id generator */ |
| private static UUIDGenerator generator = UUIDGenerator.getInstance(); |
| |
| /** |
| * |
| */ |
| public LuceneWorkflowInstanceRepository(String idxPath, int pageSize) { |
| this.idxFilePath = idxPath; |
| this.pageSize = pageSize; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.oodt.cas.workflow.instrepo.WorkflowInstanceRepository#getNumWorkflowInstances() |
| */ |
| public int getNumWorkflowInstances() throws InstanceRepositoryException { |
| IndexSearcher searcher = null; |
| int numInsts = -1; |
| |
| try { |
| searcher = new IndexSearcher(idxFilePath); |
| Term instIdTerm = new Term("myfield", "myvalue"); |
| org.apache.lucene.search.Query query = new TermQuery(instIdTerm); |
| Sort sort = new Sort(new SortField("workflow_inst_startdatetime", |
| SortField.STRING, true)); |
| Hits hits = searcher.search(query, sort); |
| |
| numInsts = hits.length(); |
| |
| } catch (IOException e) { |
| LOG.log(Level.WARNING, |
| "IOException when opening index directory: [" + idxFilePath |
| + "] for search: Message: " + e.getMessage()); |
| throw new InstanceRepositoryException(e.getMessage()); |
| } finally { |
| if (searcher != null) { |
| try { |
| searcher.close(); |
| } catch (Exception ignore) { |
| } |
| searcher = null; |
| } |
| } |
| |
| return numInsts; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.oodt.cas.workflow.instrepo.WorkflowInstanceRepository#getNumWorkflowInstancesByStatus(java.lang.String) |
| */ |
| public int getNumWorkflowInstancesByStatus(String status) |
| throws InstanceRepositoryException { |
| IndexSearcher searcher = null; |
| int numInsts = -1; |
| |
| try { |
| searcher = new IndexSearcher(idxFilePath); |
| Term instIdTerm = new Term("workflow_inst_status", status); |
| org.apache.lucene.search.Query query = new TermQuery(instIdTerm); |
| Sort sort = new Sort(new SortField("workflow_inst_startdatetime", |
| SortField.STRING, true)); |
| Hits hits = searcher.search(query, sort); |
| |
| numInsts = hits.length(); |
| |
| } catch (IOException e) { |
| LOG.log(Level.WARNING, |
| "IOException when opening index directory: [" + idxFilePath |
| + "] for search: Message: " + e.getMessage()); |
| throw new InstanceRepositoryException(e.getMessage()); |
| } finally { |
| if (searcher != null) { |
| try { |
| searcher.close(); |
| } catch (Exception ignore) { |
| } |
| searcher = null; |
| } |
| } |
| |
| return numInsts; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.oodt.cas.workflow.instrepo.WorkflowInstanceRepository#addWorkflowInstance(org.apache.oodt.cas.workflow.structs.WorkflowInstance) |
| */ |
| public synchronized void addWorkflowInstance(WorkflowInstance wInst) |
| throws InstanceRepositoryException { |
| // generate UUID for inst |
| UUID uuid = UUIDGenerator.getInstance().generateTimeBasedUUID(); |
| wInst.setId(uuid.toString()); |
| |
| addWorkflowInstanceToCatalog(wInst); |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.oodt.cas.workflow.instrepo.WorkflowInstanceRepository#removeWorkflowInstance(org.apache.oodt.cas.workflow.structs.WorkflowInstance) |
| */ |
| public synchronized void removeWorkflowInstance(WorkflowInstance wInst) |
| throws InstanceRepositoryException { |
| removeWorkflowInstanceDocument(wInst); |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.oodt.cas.workflow.instrepo.WorkflowInstanceRepository#updateWorkflowInstance(org.apache.oodt.cas.workflow.structs.WorkflowInstance) |
| */ |
| public synchronized void updateWorkflowInstance(WorkflowInstance wInst) |
| throws InstanceRepositoryException { |
| removeWorkflowInstanceDocument(wInst); |
| addWorkflowInstanceToCatalog(wInst); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.oodt.cas.workflow.instrepo.WorkflowInstanceRepository#getWorkflowInstanceById(java.lang.String) |
| */ |
| public WorkflowInstance getWorkflowInstanceById(String workflowInstId) |
| throws InstanceRepositoryException { |
| IndexSearcher searcher = null; |
| WorkflowInstance wInst = null; |
| |
| try { |
| searcher = new IndexSearcher(idxFilePath); |
| Term instIdTerm = new Term("workflow_inst_id", workflowInstId); |
| org.apache.lucene.search.Query query = new TermQuery(instIdTerm); |
| Hits hits = searcher.search(query); |
| |
| if (hits.length() != 1) { |
| LOG.log(Level.WARNING, "The workflow instance: [" |
| + workflowInstId + "] is not being " |
| + "managed by this " + "workflow engine, or " |
| + "is not unique in the catalog: num hits: ["+hits.length()+"]"); |
| return null; |
| } else { |
| Document instDoc = hits.doc(0); |
| wInst = toWorkflowInstance(instDoc); |
| } |
| |
| } catch (IOException e) { |
| LOG.log(Level.WARNING, |
| "IOException when opening index directory: [" + idxFilePath |
| + "] for search: Message: " + e.getMessage()); |
| throw new InstanceRepositoryException(e.getMessage()); |
| } finally { |
| if (searcher != null) { |
| try { |
| searcher.close(); |
| } catch (Exception ignore) { |
| } |
| searcher = null; |
| } |
| } |
| |
| return wInst; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.oodt.cas.workflow.instrepo.WorkflowInstanceRepository#getWorkflowInstances() |
| */ |
| public List getWorkflowInstances() throws InstanceRepositoryException { |
| IndexSearcher searcher = null; |
| List wInsts = null; |
| |
| try { |
| searcher = new IndexSearcher(idxFilePath); |
| Term instIdTerm = new Term("myfield", "myvalue"); |
| org.apache.lucene.search.Query query = new TermQuery(instIdTerm); |
| Sort sort = new Sort(new SortField("workflow_inst_startdatetime", |
| SortField.STRING, true)); |
| Hits hits = searcher.search(query, sort); |
| |
| if (hits.length() > 0) { |
| wInsts = new Vector(hits.length()); |
| |
| for (int i = 0; i < hits.length(); i++) { |
| Document doc = hits.doc(i); |
| WorkflowInstance wInst = toWorkflowInstance(doc); |
| wInsts.add(wInst); |
| } |
| } |
| |
| } catch (IOException e) { |
| LOG.log(Level.WARNING, |
| "IOException when opening index directory: [" + idxFilePath |
| + "] for search: Message: " + e.getMessage()); |
| throw new InstanceRepositoryException(e.getMessage()); |
| } finally { |
| if (searcher != null) { |
| try { |
| searcher.close(); |
| } catch (Exception ignore) { |
| } |
| searcher = null; |
| } |
| } |
| |
| return wInsts; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.oodt.cas.workflow.instrepo.WorkflowInstanceRepository#getWorkflowInstancesByStatus(java.lang.String) |
| */ |
| public List getWorkflowInstancesByStatus(String status) |
| throws InstanceRepositoryException { |
| IndexSearcher searcher = null; |
| List wInsts = null; |
| |
| try { |
| searcher = new IndexSearcher(idxFilePath); |
| Term instIdTerm = new Term("workflow_inst_status", status); |
| org.apache.lucene.search.Query query = new TermQuery(instIdTerm); |
| Sort sort = new Sort(new SortField("workflow_inst_startdatetime", |
| SortField.STRING, true)); |
| Hits hits = searcher.search(query, sort); |
| |
| if (hits.length() > 0) { |
| wInsts = new Vector(hits.length()); |
| |
| for (int i = 0; i < hits.length(); i++) { |
| Document doc = hits.doc(i); |
| WorkflowInstance wInst = toWorkflowInstance(doc); |
| wInsts.add(wInst); |
| } |
| } |
| |
| } catch (IOException e) { |
| LOG.log(Level.WARNING, |
| "IOException when opening index directory: [" + idxFilePath |
| + "] for search: Message: " + e.getMessage()); |
| throw new InstanceRepositoryException(e.getMessage()); |
| } finally { |
| if (searcher != null) { |
| try { |
| searcher.close(); |
| } catch (Exception ignore) { |
| } |
| searcher = null; |
| } |
| } |
| |
| return wInsts; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.apache.oodt.cas.workflow.instrepo.AbstractPaginatibleInstanceRepository#paginateWorkflows(int, |
| * java.lang.String) |
| */ |
| protected List paginateWorkflows(int pageNum, String status) |
| throws InstanceRepositoryException { |
| List instIds = null; |
| IndexSearcher searcher = null; |
| |
| try { |
| searcher = new IndexSearcher(idxFilePath); |
| |
| // construct a Boolean query here |
| BooleanQuery booleanQuery = new BooleanQuery(); |
| |
| Term instIdTerm = new Term("myfield", "myvalue"); |
| if (status != null) { |
| Term statusTerm = new Term("workflow_inst_status", status); |
| booleanQuery.add(new TermQuery(statusTerm), |
| BooleanClause.Occur.MUST); |
| } |
| booleanQuery.add(new TermQuery(instIdTerm), |
| BooleanClause.Occur.MUST); |
| |
| Sort sort = new Sort(new SortField("workflow_inst_startdatetime", |
| SortField.STRING, true)); |
| LOG.log(Level.FINE, |
| "Querying LuceneWorkflowInstanceRepository: q: [" |
| + booleanQuery + "]"); |
| Hits hits = searcher.search(booleanQuery, sort); |
| if (hits.length() > 0) { |
| |
| int startNum = (pageNum - 1) * pageSize; |
| if (startNum > hits.length()) { |
| startNum = 0; |
| } |
| |
| instIds = new Vector(pageSize); |
| |
| for (int i = startNum; i < Math.min(hits.length(), |
| (startNum + pageSize)); i++) { |
| Document instDoc = hits.doc(i); |
| WorkflowInstance inst = toWorkflowInstance(instDoc); |
| instIds.add(inst.getId()); |
| |
| } |
| } else { |
| LOG.log(Level.WARNING, "No workflow instances found " |
| + "when attempting to paginate!"); |
| } |
| |
| } catch (IOException e) { |
| LOG.log(Level.WARNING, |
| "IOException when opening index directory: [" + idxFilePath |
| + "] for search: Message: " + e.getMessage()); |
| throw new InstanceRepositoryException(e.getMessage()); |
| } finally { |
| if (searcher != null) { |
| try { |
| searcher.close(); |
| } catch (Exception ignore) { |
| } |
| searcher = null; |
| } |
| } |
| |
| return instIds; |
| } |
| |
| private synchronized void removeWorkflowInstanceDocument( |
| WorkflowInstance inst) throws InstanceRepositoryException { |
| IndexReader reader = null; |
| |
| try { |
| reader = IndexReader.open(idxFilePath); |
| LOG.log(Level.FINE, |
| "LuceneWorkflowEngine: remove document from index for workflow instance: [" |
| + inst.getId() + "]"); |
| reader.deleteDocuments(new Term("workflow_inst_id", inst.getId())); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| LOG |
| .log(Level.WARNING, |
| "Exception removing workflow instance: [" |
| + inst.getId() + "] from index: Message: " |
| + e.getMessage()); |
| throw new InstanceRepositoryException(e.getMessage()); |
| } finally { |
| if (reader != null) { |
| try { |
| reader.close(); |
| } catch (Exception ignore) { |
| } |
| |
| reader = null; |
| } |
| |
| } |
| } |
| |
| private synchronized void addWorkflowInstanceToCatalog( |
| WorkflowInstance wInst) throws InstanceRepositoryException { |
| IndexWriter writer = null; |
| |
| File indexDir = new File(idxFilePath); |
| |
| boolean createIndex = false; |
| |
| if (indexDir.exists() && indexDir.isDirectory()) { |
| createIndex = false; |
| } else |
| createIndex = true; |
| |
| try { |
| writer = new IndexWriter(idxFilePath, new StandardAnalyzer(), |
| createIndex); |
| writer.setMergeFactor(20); |
| |
| Document doc = toDoc(wInst); |
| writer.addDocument(doc); |
| } catch (IOException e) { |
| LOG.log(Level.WARNING, "Unable to index workflow instance: [" |
| + wInst.getId() + "]: Message: " + e.getMessage()); |
| throw new InstanceRepositoryException( |
| "Unable to index workflow instance: [" + wInst.getId() |
| + "]: Message: " + e.getMessage()); |
| } finally { |
| try { |
| writer.close(); |
| } catch (Exception ignore) { |
| } |
| writer = null; |
| } |
| |
| } |
| |
| private Document toDoc(WorkflowInstance workflowInst) { |
| Document doc = new Document(); |
| |
| // store the workflow instance info first |
| doc.add(new Field("workflow_inst_id", workflowInst.getId(), |
| Field.Store.YES, Field.Index.UN_TOKENIZED)); |
| |
| doc.add(new Field("workflow_inst_timesblocked", |
| String.valueOf(workflowInst.getTimesBlocked()), Field.Store.YES, |
| Field.Index.UN_TOKENIZED)); |
| |
| // will leave this for back compat, but will also store |
| // category |
| doc.add(new Field("workflow_inst_status", workflowInst.getStatus(), |
| Field.Store.YES, Field.Index.UN_TOKENIZED)); |
| |
| if(workflowInst.getState() != null){ |
| WorkflowState state = workflowInst.getState(); |
| |
| if(state.getDescription() != null){ |
| doc.add(new Field("workflow_inst_state_desc", |
| state.getDescription(), Field.Store.YES, Field.Index.UN_TOKENIZED)); |
| } |
| |
| if(state.getMessage() != null){ |
| doc.add(new Field("workflow_inst_state_message", |
| state.getMessage(), Field.Store.YES, Field.Index.UN_TOKENIZED)); |
| } |
| |
| if(state.getCategory() != null && state.getCategory().getName() != null){ |
| doc.add(new Field("workflow_inst_state_category", |
| state.getCategory().getName(), Field.Store.YES, Field.Index.UN_TOKENIZED)); |
| } |
| } |
| |
| doc |
| .add(new Field("workflow_inst_current_task_id", workflowInst |
| .getCurrentTaskId(), Field.Store.YES, |
| Field.Index.UN_TOKENIZED)); |
| |
| doc |
| .add(new Field( |
| "workflow_inst_currenttask_startdatetime", |
| workflowInst.getCurrentTaskStartDateTimeIsoStr() != null ? workflowInst |
| .getCurrentTaskStartDateTimeIsoStr() |
| : "", Field.Store.YES, Field.Index.UN_TOKENIZED)); |
| doc.add(new Field("workflow_inst_currenttask_enddatetime", workflowInst |
| .getCurrentTaskEndDateTimeIsoStr() != null ? workflowInst |
| .getCurrentTaskEndDateTimeIsoStr() : "", Field.Store.YES, |
| Field.Index.UN_TOKENIZED)); |
| doc.add(new Field("workflow_inst_startdatetime", workflowInst |
| .getStartDateTimeIsoStr() != null ? workflowInst |
| .getStartDateTimeIsoStr() : "", Field.Store.YES, |
| Field.Index.UN_TOKENIZED)); |
| doc.add(new Field("workflow_inst_enddatetime", workflowInst |
| .getEndDateTimeIsoStr() != null ? workflowInst |
| .getEndDateTimeIsoStr() : "", Field.Store.YES, |
| Field.Index.UN_TOKENIZED)); |
| doc.add(new Field("workflow_inst_priority", |
| workflowInst.getPriority() != null ? |
| String.valueOf(workflowInst.getPriority().getValue()): |
| String.valueOf(Priority.getDefault().getValue()), |
| Field.Store.YES, |
| Field.Index.UN_TOKENIZED)); |
| |
| // add all metadata |
| addInstanceMetadataToDoc(doc, workflowInst.getSharedContext()); |
| |
| // store the workflow info too |
| doc.add(new Field("workflow_id", workflowInst.getWorkflow().getId(), |
| Field.Store.YES, Field.Index.UN_TOKENIZED)); |
| doc.add(new Field("workflow_name", |
| workflowInst.getWorkflow().getName(), Field.Store.YES, |
| Field.Index.NO)); |
| |
| // store the tasks |
| addTasksToDoc(doc, workflowInst.getWorkflow().getTasks()); |
| |
| // store workflow conditions |
| addConditionsToDoc("workflow_condition_"+workflowInst.getWorkflow().getId(), |
| workflowInst.getWorkflow().getConditions() |
| , doc); |
| |
| // add the default field (so that we can do a query for *) |
| doc.add(new Field("myfield", "myvalue", Field.Store.YES, |
| Field.Index.UN_TOKENIZED)); |
| |
| return doc; |
| } |
| |
| private void addInstanceMetadataToDoc(Document doc, Metadata met) { |
| if (met != null && met.getHashtable().keySet().size() > 0) { |
| for (Iterator i = met.getHashtable().keySet().iterator(); i |
| .hasNext();) { |
| String metKey = (String) i.next(); |
| List metVals = met.getAllMetadata(metKey); |
| if (metVals != null && metVals.size() > 0) { |
| for (Iterator j = metVals.iterator(); j.hasNext();) { |
| String metVal = (String) j.next(); |
| doc.add(new Field(metKey, metVal, Field.Store.YES, |
| Field.Index.UN_TOKENIZED)); |
| } |
| |
| // now index the field name so that we can use it to |
| // look it up when converting from doc to |
| // WorkflowInstance |
| doc.add(new Field("workflow_inst_met_flds", metKey, |
| Field.Store.YES, Field.Index.NO)); |
| |
| } |
| } |
| } |
| } |
| |
| private void addTasksToDoc(Document doc, List tasks) { |
| if (tasks != null && tasks.size() > 0) { |
| for (Iterator i = tasks.iterator(); i.hasNext();) { |
| WorkflowTask task = (WorkflowTask) i.next(); |
| doc.add(new Field("task_id", task.getTaskId(), Field.Store.YES, |
| Field.Index.UN_TOKENIZED)); |
| doc.add(new Field("task_name", task.getTaskName(), |
| Field.Store.YES, Field.Index.NO)); |
| doc.add(new Field("task_order", |
| String.valueOf(task.getOrder()), Field.Store.YES, |
| Field.Index.NO)); |
| doc.add(new Field("task_class", |
| task.getTaskInstanceClassName(), Field.Store.YES, |
| Field.Index.NO)); |
| |
| addConditionsToDoc(task.getTaskId(), task.getConditions(), doc); |
| addTaskConfigToDoc(task.getTaskId(), task.getTaskConfig(), doc); |
| } |
| } |
| } |
| |
| private void addTaskConfigToDoc(String taskId, |
| WorkflowTaskConfiguration config, Document doc) { |
| if (config != null) { |
| for (Iterator i = config.getProperties().keySet().iterator(); i |
| .hasNext();) { |
| String propName = (String) i.next(); |
| String propValue = config.getProperty(propName); |
| |
| doc.add(new Field(taskId + "_config_property_name", propName, |
| Field.Store.YES, Field.Index.NO)); |
| doc.add(new Field(taskId + "_config_property_value", propValue, |
| Field.Store.YES, Field.Index.NO)); |
| } |
| } |
| } |
| |
| private void addConditionsToDoc(String taskId, List conditionList, |
| Document doc) { |
| if (conditionList != null && conditionList.size() > 0) { |
| for (Iterator i = conditionList.iterator(); i.hasNext();) { |
| WorkflowCondition cond = (WorkflowCondition) i.next(); |
| doc.add(new Field(taskId + "_condition_name", cond.getConditionName(), |
| Field.Store.YES, Field.Index.NO)); |
| doc.add(new Field(taskId + "_condition_id", cond.getConditionId(), |
| Field.Store.YES, Field.Index.UN_TOKENIZED)); |
| doc.add(new Field(taskId + "_condition_class", cond |
| .getConditionInstanceClassName(), Field.Store.YES, Field.Index.NO)); |
| doc.add(new Field(taskId + "_condition_order", String.valueOf(cond |
| .getOrder()), Field.Store.YES, Field.Index.NO)); |
| doc.add(new Field(taskId + "_condition_timeout", String.valueOf(cond |
| .getTimeoutSeconds()), Field.Store.YES, Field.Index.NO)); |
| doc.add(new Field(taskId+"_condition_optional", String.valueOf(cond.isOptional()), |
| Field.Store.YES, Field.Index.NO)); |
| } |
| } |
| } |
| |
| private WorkflowInstance toWorkflowInstance(Document doc) { |
| WorkflowInstance inst = new WorkflowInstance(); |
| |
| // first read all the instance info |
| inst.setId(doc.get("workflow_inst_id")); |
| |
| inst.setTimesBlocked(Integer.parseInt(doc.get("workflow_inst_timesblocked") != |
| null ? doc.get("workflow_inst_timesblocked"):"0")); |
| |
| // try and construct a state |
| WorkflowState state = new WorkflowState(); |
| state.setName(doc.get("workflow_inst_status")); |
| if(doc.get("workflow_inst_state_category") != null){ |
| WorkflowLifecycleStage category = new WorkflowLifecycleStage(); |
| category.setName(doc.get("workflow_inst_state_category")); |
| state.setCategory(category); |
| } |
| |
| if(doc.get("workflow_inst_state_desc") != null){ |
| state.setDescription(doc.get("workflow_inst_state_desc")); |
| } |
| |
| if(doc.get("workflow_inst_state_message") != null){ |
| state.setMessage(doc.get("workflow_inst_state_message")); |
| } |
| inst.setState(state); |
| inst.setCurrentTaskId(doc.get("workflow_inst_current_task_id")); |
| inst.setCurrentTaskStartDateTimeIsoStr(doc |
| .get("workflow_inst_currenttask_startdatetime")); |
| inst.setCurrentTaskEndDateTimeIsoStr(doc |
| .get("workflow_inst_currenttask_enddatetime")); |
| inst.setStartDateTimeIsoStr(doc.get("workflow_inst_startdatetime")); |
| inst.setEndDateTimeIsoStr(doc.get("workflow_inst_enddatetime")); |
| inst.setPriority(Priority.getPriority(doc.get("workflow_inst_priority") != null ? |
| Double.valueOf(doc.get("workflow_inst_priority")):Priority.getDefault().getValue())); |
| |
| // read the workflow instance metadata |
| Metadata sharedContext = new Metadata(); |
| String[] instMetFields = doc.getValues("workflow_inst_met_flds"); |
| if (instMetFields != null && instMetFields.length > 0) { |
| for (int i = 0; i < instMetFields.length; i++) { |
| String fldName = instMetFields[i]; |
| String[] vals = doc.getValues(fldName); |
| if (vals != null && vals.length > 0) { |
| for (int j = 0; j < vals.length; j++) { |
| sharedContext.addMetadata(fldName, vals[j]); |
| } |
| } |
| } |
| } |
| |
| inst.setSharedContext(sharedContext); |
| |
| // now read all of the workflow info |
| |
| Workflow workflow = new Workflow(); |
| |
| workflow.setId(doc.get("workflow_id")); |
| workflow.setName(doc.get("workflow_name")); |
| workflow.setTasks(toTasks(doc)); |
| workflow.setConditions(toConditions("workflow_condition_"+workflow.getId(), doc)); |
| |
| inst.setWorkflow(workflow); |
| |
| return inst; |
| } |
| |
| private List toTasks(Document doc) { |
| List taskList = new Vector(); |
| |
| String[] taskIds = doc.getValues("task_id"); |
| String[] taskNames = doc.getValues("task_name"); |
| String[] taskOrders = doc.getValues("task_order"); |
| String[] taskClasses = doc.getValues("task_class"); |
| |
| if (taskIds.length != taskNames.length |
| || taskIds.length != taskOrders.length |
| || taskIds.length != taskClasses.length) { |
| LOG.log(Level.WARNING, |
| "task arrays are not of same size when rebuilding " |
| + "task list from Document!"); |
| return null; |
| } |
| |
| for (int i = 0; i < taskIds.length; i++) { |
| WorkflowTask task = new WorkflowTask(); |
| task.setOrder(Integer.parseInt(taskOrders[i])); |
| task.setTaskName(taskNames[i]); |
| task.setTaskId(taskIds[i]); |
| task.setTaskInstanceClassName(taskClasses[i]); |
| |
| task.setConditions(toConditions(task.getTaskId(), doc)); |
| task.setTaskConfig(toTaskConfig(task.getTaskId(), doc)); |
| taskList.add(task); |
| } |
| |
| return taskList; |
| } |
| |
| private WorkflowTaskConfiguration toTaskConfig(String taskId, Document doc) { |
| WorkflowTaskConfiguration taskConfig = new WorkflowTaskConfiguration(); |
| |
| String[] propNames = doc.getValues(taskId + "_config_property_name"); |
| String[] propValues = doc.getValues(taskId + "_config_property_value"); |
| |
| if (propNames == null) { |
| return taskConfig; |
| } |
| |
| if (propNames.length != propValues.length) { |
| LOG.log(Level.WARNING, |
| "Task Config prop name and value arrays are not " |
| + "of same size!"); |
| return null; |
| } |
| |
| for (int i = 0; i < propNames.length; i++) { |
| taskConfig.addConfigProperty(propNames[i], propValues[i]); |
| } |
| |
| return taskConfig; |
| } |
| |
| private List toConditions(String taskId, Document doc) { |
| List condList = new Vector(); |
| |
| String[] condNames = doc.getValues(taskId + "_condition_name"); |
| String[] condClasses = doc.getValues(taskId + "_condition_class"); |
| String[] condOrders = doc.getValues(taskId + "_condition_order"); |
| String[] condIds = doc.getValues(taskId + "_condition_id"); |
| String[] condTimeouts = doc.getValues(taskId+"_condition_timeout"); |
| String[] condOptionals = doc.getValues(taskId+"_condition_optional"); |
| |
| if (condNames == null) { |
| return condList; |
| } |
| |
| if (condNames.length != condClasses.length |
| || condNames.length != condOrders.length |
| || condNames.length != condIds.length |
| || (condTimeouts != null && condNames.length != condTimeouts.length) |
| || (condOptionals != null && condNames.length != condOptionals.length)) { |
| LOG.log(Level.WARNING, |
| "Condition arrays are not of same size when " |
| + "rebuilding from given Document"); |
| return null; |
| } |
| |
| for (int i = 0; i < condNames.length; i++) { |
| WorkflowCondition cond = new WorkflowCondition(); |
| cond.setConditionId(condIds[i]); |
| cond.setConditionInstanceClassName(condClasses[i]); |
| cond.setConditionName(condNames[i]); |
| cond.setOrder(Integer.parseInt(condOrders[i])); |
| if(condTimeouts != null){ |
| cond.setTimeoutSeconds(Long.parseLong(condTimeouts[i])); |
| } |
| if(condOptionals != null){ |
| cond.setOptional(Boolean.valueOf(condOptionals[i])); |
| } |
| condList.add(cond); |
| } |
| |
| return condList; |
| } |
| |
| } |
