| /* |
| * 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.util; |
| |
| //JDK imports |
| import java.util.List; |
| import java.util.Iterator; |
| import java.util.Hashtable; |
| import java.util.Set; |
| import java.util.Vector; |
| |
| //OODT imports |
| import org.apache.oodt.cas.metadata.Metadata; |
| import org.apache.oodt.cas.workflow.structs.Priority; |
| import org.apache.oodt.cas.workflow.structs.Workflow; |
| import org.apache.oodt.cas.workflow.structs.WorkflowConditionConfiguration; |
| import org.apache.oodt.cas.workflow.structs.WorkflowInstancePage; |
| import org.apache.oodt.cas.workflow.structs.WorkflowTask; |
| import org.apache.oodt.cas.workflow.structs.WorkflowTaskConfiguration; |
| import org.apache.oodt.cas.workflow.structs.WorkflowCondition; |
| import org.apache.oodt.cas.workflow.structs.WorkflowInstance; |
| |
| /** |
| * |
| * A Struct Factory for creating and unpacking Workflow Objects to be sent and |
| * received across the XML-RPC wire. |
| * |
| * @author mattmann |
| * @version $Revision$ |
| * |
| */ |
| public final class XmlRpcStructFactory { |
| |
| private XmlRpcStructFactory() throws InstantiationException { |
| throw new InstantiationException("Don't instantiate XmlRpcStructFactories!"); |
| } |
| |
| /** |
| * Gets a {@link Hashtable} representation of a {@link WorkflowInstancePage} |
| * that is serializable over the XML-RPC wire. |
| * |
| * @param page |
| * The {@link WorkflowInstancePage} to turn into a {@link Hashtable}. |
| * @return A {@link Hashtable} representation of a |
| * {@link WorkflowInstancePage}. |
| */ |
| public static Hashtable getXmlRpcWorkflowInstancePage( |
| WorkflowInstancePage page) { |
| Hashtable pageHash = new Hashtable(); |
| pageHash.put("totalPages", String.valueOf(page.getTotalPages())); |
| pageHash.put("pageNum", String.valueOf(page.getPageNum())); |
| pageHash.put("pageSize", String.valueOf(page.getPageSize())); |
| pageHash.put("pageWorkflows", |
| getXmlRpcWorkflowInstances(page.getPageWorkflows())); |
| |
| return pageHash; |
| |
| } |
| |
| /** |
| * Gets a {@link WorkflowInstancePage} off of the XML-RPC wire by converting |
| * the XML-RPC {@link Hashtable} representation of the page into a |
| * {@link WorkflowInstancePage}. |
| * |
| * @param pageHash |
| * The XML-RPC {@link Hashtable} representation of this |
| * {@link WorkflowInstancePage}. |
| * @return The {@link WorkflowInstancePage} that this XML-RPC |
| * {@link Hashtable} provided represents. |
| */ |
| public static WorkflowInstancePage getWorkflowInstancePageFromXmlRpc( |
| Hashtable pageHash) { |
| WorkflowInstancePage page = new WorkflowInstancePage(); |
| page.setPageNum(Integer.parseInt((String) pageHash.get("pageNum"))); |
| page.setPageSize(Integer.parseInt((String) pageHash.get("pageSize"))); |
| page.setTotalPages(Integer.parseInt((String) pageHash.get("totalPages"))); |
| page.setPageWorkflows(getWorkflowInstancesFromXmlRpc((Vector) pageHash |
| .get("pageWorkflows"))); |
| |
| return page; |
| |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link Hashtable} representation of a {@link WorkflowInstance} to be |
| * sent across the XML-RPC wire. |
| * </p> |
| * |
| * @param wInst |
| * The WorkflowInstance to turned into a java.util.Hashtable. |
| * @return A {@link Hashtable} representation of a {@link WorkflowInstance}. |
| */ |
| public static Hashtable getXmlRpcWorkflowInstance(WorkflowInstance wInst) { |
| Hashtable workflowInstance = new Hashtable(); |
| workflowInstance.put("current_task_id", wInst.getCurrentTaskId()); |
| workflowInstance.put("status", wInst.getStatus()); |
| workflowInstance.put("id", wInst.getId()); |
| workflowInstance.put("workflow", getXmlRpcWorkflow(wInst.getWorkflow())); |
| workflowInstance.put("start_date_time", |
| wInst.getStartDateTimeIsoStr() != null ? wInst.getStartDateTimeIsoStr() |
| : ""); |
| workflowInstance.put("end_date_time", |
| wInst.getEndDateTimeIsoStr() != null ? wInst.getEndDateTimeIsoStr() |
| : ""); |
| workflowInstance.put( |
| "current_task_start_date_time", |
| wInst.getCurrentTaskStartDateTimeIsoStr() != null ? wInst |
| .getCurrentTaskStartDateTimeIsoStr() : ""); |
| workflowInstance.put( |
| "current_task_end_date_time", |
| wInst.getCurrentTaskEndDateTimeIsoStr() != null ? wInst |
| .getCurrentTaskEndDateTimeIsoStr() : ""); |
| workflowInstance.put("sharedContext", |
| wInst.getSharedContext() != null ? wInst.getSharedContext() |
| .getHashtable() : new Hashtable()); |
| workflowInstance.put( |
| "priority", |
| wInst.getPriority() != null ? String.valueOf(wInst.getPriority() |
| .getValue()) : String.valueOf(Priority.getDefault().getValue())); |
| return workflowInstance; |
| } |
| |
| public static WorkflowInstance getWorkflowInstanceFromXmlRpc( |
| Hashtable workflowInstance) { |
| WorkflowInstance wInst = new WorkflowInstance(); |
| wInst.setCurrentTaskId((String) workflowInstance.get("current_task_id")); |
| wInst.setStatus((String) workflowInstance.get("status")); |
| wInst.setId((String) workflowInstance.get("id")); |
| wInst.setWorkflow(getWorkflowFromXmlRpc((Hashtable) workflowInstance |
| .get("workflow"))); |
| wInst.setStartDateTimeIsoStr((String) workflowInstance |
| .get("start_date_time")); |
| wInst.setEndDateTimeIsoStr((String) workflowInstance.get("end_date_time")); |
| wInst.setCurrentTaskStartDateTimeIsoStr((String) workflowInstance |
| .get("current_task_start_date_time")); |
| wInst.setCurrentTaskEndDateTimeIsoStr((String) workflowInstance |
| .get("current_task_end_date_time")); |
| if (workflowInstance.get("sharedContext") != null) { |
| Metadata met = new Metadata(); |
| met.addMetadata((Hashtable) workflowInstance.get("sharedContext")); |
| wInst.setSharedContext(met); |
| } else |
| wInst.setSharedContext(new Metadata()); |
| |
| if (workflowInstance.get("priority") != null) { |
| Priority p = Priority.getPriority(Double |
| .valueOf((String) workflowInstance.get("priority"))); |
| } |
| |
| return wInst; |
| } |
| |
| /** |
| * Gets a {@link List} of {@link WorkflowInstance}s from their representations |
| * as {@link Hashtable}s in XML-RPC. |
| * |
| * @param instsVector |
| * The {@link Vector} of {@link Hashtable} representations of |
| * {@link WorkflowInstance}s. |
| * @return A {@link List} of {@link WorkflowInstance}s from their |
| * representations as {@link Hashtable}s in XML-RPC. |
| */ |
| public static List getWorkflowInstancesFromXmlRpc(Vector instsVector) { |
| List wInsts = new Vector(); |
| |
| if (instsVector != null && instsVector.size() > 0) { |
| for (Iterator i = instsVector.iterator(); i.hasNext();) { |
| Hashtable wInstHash = (Hashtable) i.next(); |
| WorkflowInstance inst = getWorkflowInstanceFromXmlRpc(wInstHash); |
| wInsts.add(inst); |
| } |
| } |
| |
| return wInsts; |
| } |
| |
| /** |
| * Gets an XML-RPC serializable {@link Vector} of {@link Hashtable} |
| * representations of {@link WorkflowInstance}s. |
| * |
| * @param wInsts |
| * The {@link List} of {@link WorkflowInstance}s to serialize. |
| * @return A XML-RPC serializable {@link Vector} of {@link Hashtable} |
| * representations of {@link WorkflowInstance}s. |
| */ |
| public static Vector getXmlRpcWorkflowInstances(List wInsts) { |
| Vector instsVector = new Vector(); |
| |
| if (wInsts != null && wInsts.size() > 0) { |
| for (Iterator i = wInsts.iterator(); i.hasNext();) { |
| WorkflowInstance inst = (WorkflowInstance) i.next(); |
| instsVector.add(getXmlRpcWorkflowInstance(inst)); |
| } |
| } |
| |
| return instsVector; |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link Hashtable} representation of a {@link Workflow} to be sent |
| * across the XML-RPC wire. |
| * </p> |
| * |
| * @param w |
| * The Workflow to be turned into a java.util.Hashtable |
| * @return A {@link Hashtable} representation of a {@link Workflow}. |
| */ |
| public static Hashtable getXmlRpcWorkflow(Workflow w) { |
| Hashtable workflow = new Hashtable(); |
| workflow.put("id", w.getId()); |
| workflow.put("name", w.getName() != null ? w.getName() : ""); |
| workflow.put("tasks", getXmlRpcWorkflowTasks(w.getTasks())); |
| workflow.put("conditions", getXmlRpcWorkflowConditions(w.getConditions())); |
| |
| return workflow; |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link Workflow} from the XML-RPC {@link Hashtable} version. |
| * </p> |
| * |
| * @param w |
| * The Hashtable to obtain a Workflow from. |
| * @return a {@link Workflow} from the XML-RPC {@link Hashtable} version. |
| */ |
| public static Workflow getWorkflowFromXmlRpc(Hashtable w) { |
| Workflow workflow = new Workflow(); |
| workflow.setName((String) w.get("name")); |
| workflow.setId((String) w.get("id")); |
| workflow.setTasks(getWorkflowTasksFromXmlRpc((Vector) w.get("tasks"))); |
| workflow.setConditions(getWorkflowConditionsFromXmlRpc((Vector) w |
| .get("conditions"))); |
| |
| return workflow; |
| } |
| |
| /** |
| * <p> |
| * Gets an XML-RPC version of the {@link WorkflowTask} to send over the wire. |
| * </p> |
| * |
| * @param t |
| * The WorkflowTask to obtain an XML-RPC Hashtable from. |
| * @return an XML-RPC version of the {@link WorkflowTask} to send over the |
| * wire. |
| */ |
| public static Hashtable getXmlRpcWorkflowTask(WorkflowTask t) { |
| Hashtable task = new Hashtable(); |
| task.put("class", t.getTaskInstanceClassName()); |
| task.put("id", t.getTaskId()); |
| task.put("name", t.getTaskName()); |
| task.put("order", String.valueOf(t.getOrder())); |
| task.put("conditions", getXmlRpcWorkflowConditions(t.getConditions())); |
| task.put("configuration", |
| getXmlRpcWorkflowTaskConfiguration(t.getTaskConfig())); |
| task.put("requiredMetFields", |
| getXmlRpcWorkflowTaskReqMetFields(t.getRequiredMetFields())); |
| return task; |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link Vector} representation of a {@link List} of |
| * {@link WorkflowTask}s to be sent across the XML-RPC wire. |
| * </p> |
| * |
| * @param tasks |
| * The {@link List} of {@link WorkflowTask}s. |
| * |
| * @return A {@link Vector} representation of a {@link List} of |
| * {@link WorkflowTask}s. |
| */ |
| public static Vector getXmlRpcWorkflowTasks(List tasks) { |
| Vector wTasks = new Vector(); |
| |
| if (tasks == null) { |
| return wTasks; |
| } |
| |
| for (Iterator i = tasks.iterator(); i.hasNext();) { |
| WorkflowTask t = (WorkflowTask) i.next(); |
| Hashtable task = getXmlRpcWorkflowTask(t); |
| wTasks.add(task); |
| } |
| |
| return wTasks; |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link WorkflowTask} from an XML-RPC {@link Hashtable} sent over the |
| * wire. |
| * </p> |
| * |
| * @param task |
| * The XML-RPC Hashtable version of the WorkflowTask. |
| * @return a {@link WorkflowTask} from an XML-RPC {@link Hashtable} sent over |
| * the wire. |
| */ |
| public static WorkflowTask getWorkflowTaskFromXmlRpc(Hashtable task) { |
| WorkflowTask t = new WorkflowTask(); |
| t.setTaskInstanceClassName((String) task.get("class")); |
| t.setTaskId((String) task.get("id")); |
| t.setTaskName((String) task.get("name")); |
| t.setOrder(Integer.valueOf((String) task.get("order")).intValue()); |
| t.setTaskConfig(getWorkflowTaskConfigurationFromXmlRpc((Hashtable) task |
| .get("configuration"))); |
| t.setConditions(getWorkflowConditionsFromXmlRpc((Vector) task |
| .get("conditions"))); |
| t.setRequiredMetFields(getWorkflowTaskReqMetFieldsFromXmlRpc((Vector) task |
| .get("requiredMetFields"))); |
| |
| return t; |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link List} of {@link WorkflowTask}s from an XML-RPC {@link Vector} |
| * . |
| * </p> |
| * |
| * @param tsks |
| * The {@link Vector} of {@link WorkflowTask}s. |
| * @return A {@link List} of {@link WorkflowTask}s from an XML-RPC |
| * {@link Vector}. |
| */ |
| public static List getWorkflowTasksFromXmlRpc(Vector tsks) { |
| List tasks = new Vector(); |
| |
| for (Iterator i = tsks.iterator(); i.hasNext();) { |
| Hashtable taskHashtable = (Hashtable) i.next(); |
| WorkflowTask task = getWorkflowTaskFromXmlRpc(taskHashtable); |
| tasks.add(task); |
| |
| } |
| return tasks; |
| } |
| |
| /** |
| * <p> |
| * Gets an XML-RPC {@link Hashtable} representation of the |
| * {@link WorkflowCondition} to send over the wire. |
| * </p> |
| * |
| * @param c |
| * The WorkflowCondition to turn into an XML-RPC Hashtable. |
| * @return an XML-RPC {@link Hashtable} representation of the |
| * {@link WorkflowCondition} to send over the wire. |
| */ |
| public static Hashtable getXmlRpcWorkflowCondition(WorkflowCondition c) { |
| Hashtable condition = new Hashtable(); |
| condition.put("class", c.getConditionInstanceClassName()); |
| condition.put("id", c.getConditionId()); |
| condition.put("name", c.getConditionName()); |
| condition.put("order", String.valueOf(c.getOrder())); |
| condition.put("timeout", String.valueOf(c.getTimeoutSeconds())); |
| condition.put("optional", String.valueOf(c.isOptional())); |
| condition.put("configuration", |
| getXmlRpcWorkflowConditionConfig(c.getCondConfig())); |
| return condition; |
| |
| } |
| |
| /** |
| * Bulids an XML-RPC friendly version of a |
| * {@link WorkflowConditionConfiguration}. |
| * |
| * @param conf |
| * The {@link WorkflowConditionConfiguration} to transform into an |
| * XML-RPC {@link Hashtable}. |
| * @return an XML-RPC friendly version of a |
| * {@link WorkflowConditionConfiguration}. |
| */ |
| public static Hashtable getXmlRpcWorkflowConditionConfig( |
| WorkflowConditionConfiguration conf) { |
| Hashtable confHash = new Hashtable(); |
| for (String propName : (Set<String>) (Set<?>) conf.getProperties().keySet()) { |
| confHash.put(propName, conf.getProperty(propName)); |
| } |
| return confHash; |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link Vector} representation of the {@link List} of |
| * {@link WorkflowCondition}s to be sent across the XML-RPC wire. |
| * </p> |
| * |
| * @param conditions |
| * The List of WorkflowConditions to turn into a Vector. |
| * @return A {@link Vector} representation of a {@link List} of |
| * {@link WorkflowCondition}s. |
| */ |
| public static Vector getXmlRpcWorkflowConditions(List conditions) { |
| Vector wConditions = new Vector(); |
| |
| /* |
| * because conditions are optional, so if they're null, just return an empty |
| * Vector: XML-RPC doesn't support null |
| */ |
| if (conditions == null) { |
| return wConditions; |
| } |
| |
| for (Iterator i = conditions.iterator(); i.hasNext();) { |
| WorkflowCondition c = (WorkflowCondition) i.next(); |
| Hashtable condition = getXmlRpcWorkflowCondition(c); |
| wConditions.add(condition); |
| } |
| |
| return wConditions; |
| } |
| |
| /** |
| * Gets the required {@link List} of {@link String} met fields for this |
| * {@link WorkflowTask}. |
| * |
| * @param fields |
| * The fields required for this task. |
| * @return The {@link List} of {@link String} met fields for this |
| * {@link WorkflowTask}. |
| */ |
| public static List getWorkflowTaskReqMetFieldsFromXmlRpc(Vector fields) { |
| List reqFields = new Vector(); |
| |
| if (fields == null) { |
| return reqFields; |
| } |
| |
| for (Iterator i = fields.iterator(); i.hasNext();) { |
| String reqField = (String) i.next(); |
| reqFields.add(reqField); |
| } |
| |
| return reqFields; |
| } |
| |
| /** |
| * Gets a {@link List} of {@link String}s that are required {@link Metadata} |
| * fields for this {@link WorkflowTask}. |
| * |
| * @param metFields |
| * The required {@link Metadata} fields. |
| * @return A {@link List} of {@link String}s that are required for this |
| * {@link WorkflowTask}. |
| */ |
| public static Vector getXmlRpcWorkflowTaskReqMetFields(List metFields) { |
| Vector fields = new Vector(); |
| if (metFields == null) { |
| return fields; |
| } |
| |
| for (Iterator i = metFields.iterator(); i.hasNext();) { |
| String reqFieldName = (String) i.next(); |
| fields.add(reqFieldName); |
| } |
| |
| return fields; |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link WorkflowCondition} from an XML-RPC {@link Hashtable}. |
| * </p> |
| * |
| * @param cond |
| * The Hashtable to turn into a real WorkflowCondition. |
| * @return a {@link WorkflowCondition} from an XML-RPC {@link Hashtable}. |
| */ |
| public static WorkflowCondition getWorkflowConditionFromXmlRpc(Hashtable cond) { |
| WorkflowCondition condition = new WorkflowCondition(); |
| condition.setConditionInstanceClassName((String) cond.get("class")); |
| condition.setConditionId((String) cond.get("id")); |
| condition.setConditionName((String) cond.get("name")); |
| condition.setOrder(Integer.valueOf((String) cond.get("order")).intValue()); |
| condition |
| .setTimeoutSeconds(Long.valueOf(cond.get("timeout") != null ? (String) cond |
| .get("timeout") : "-1")); |
| condition.setOptional(Boolean.valueOf((String) cond.get("optional"))); |
| condition |
| .setCondConfig(getWorkflowConditionConfigurationFromXmlRpc((Hashtable) cond |
| .get("configuration"))); |
| return condition; |
| } |
| |
| /** |
| * Unravels a {@link WorkflowConditionConfiguration} from XML-RPC. |
| * |
| * @param conf |
| * XML-RPC friendly Hashtable representing a |
| * {@link WorkflowConditionConfiguration}. |
| * @return A {@link WorkflowConditionConfiguration} from XML-RPC. |
| */ |
| public static WorkflowConditionConfiguration getWorkflowConditionConfigurationFromXmlRpc( |
| Hashtable conf) { |
| WorkflowConditionConfiguration config = new WorkflowConditionConfiguration(); |
| for (String key : (Set<String>) (Set<?>) conf.keySet()) { |
| config.addConfigProperty(key, (String) conf.get(key)); |
| } |
| |
| return config; |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link List} of {@link WorkflowCondition}s from an XML-RPC |
| * {@link Vector}. |
| * </p> |
| * |
| * @param conds |
| * The {@link Vector} of {@link WorkflowCondition}s. |
| * @return A {@link List} of {@link WorkflowCondition}s from an XML-RPC |
| * {@link Vector}. |
| */ |
| public static List getWorkflowConditionsFromXmlRpc(Vector conds) { |
| List conditions = new Vector(); |
| |
| if (conds != null && conds.size() > 0) { |
| for (Iterator i = conds.iterator(); i.hasNext();) { |
| Hashtable cond = (Hashtable) i.next(); |
| WorkflowCondition condition = getWorkflowConditionFromXmlRpc(cond); |
| conditions.add(condition); |
| } |
| } |
| |
| return conditions; |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link Hashtable} representation of the passed in |
| * {@link WorkflowTaskConfiguration}'s {@link Properties} to be sent across |
| * the XML-RPC wire. |
| * </p> |
| * |
| * @param config |
| * The WorkflowTaskConfiguration to convert to a Hashtable. |
| * @return A {@link Hashtable} representation of the passed in |
| * {@link WorkflowTaskConfiguration}'s {@link Properties}. |
| */ |
| public static Hashtable getXmlRpcWorkflowTaskConfiguration( |
| WorkflowTaskConfiguration config) { |
| Hashtable configuration = new Hashtable(); |
| |
| for (Iterator i = config.getProperties().keySet().iterator(); i.hasNext();) { |
| String name = (String) i.next(); |
| String value = (String) config.getProperties().get(name); |
| configuration.put(name, value); |
| } |
| |
| return configuration; |
| } |
| |
| /** |
| * <p> |
| * Gets a {@link WorkflowTaskConfiguration} from an XML-RPC {@link Hashtable}. |
| * |
| * @param config |
| * The original Hashtable version of the WorkflowTaskConfiguration. |
| * @return A {@link WorkflowTaskConfiguration} from an XML-RPC |
| * {@link Hashtable}. |
| */ |
| public static WorkflowTaskConfiguration getWorkflowTaskConfigurationFromXmlRpc( |
| Hashtable config) { |
| WorkflowTaskConfiguration configuration = new WorkflowTaskConfiguration(); |
| |
| for (Iterator i = config.keySet().iterator(); i.hasNext();) { |
| String name = (String) i.next(); |
| String value = (String) config.get(name); |
| |
| configuration.getProperties().put(name, value); |
| } |
| |
| return configuration; |
| } |
| |
| } |