Source code

001/*
002 * Copyright (c) 2010-2011 The Regents of the University of California.
003 * All rights reserved.
004 *
005 * '$Author: barseghian $'
006 * '$Date: 2013-01-29 22:20:22 +0000 (Tue, 29 Jan 2013) $' 
007 * '$Revision: 31385 $'
008 * 
009 * Permission is hereby granted, without written agreement and without
010 * license or royalty fees, to use, copy, modify, and distribute this
011 * software and its documentation for any purpose, provided that the above
012 * copyright notice and the following two paragraphs appear in all copies
013 * of this software.
014 *
015 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
016 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
017 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
018 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
019 * SUCH DAMAGE.
020 *
021 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
022 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
023 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
024 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
025 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
026 * ENHANCEMENTS, OR MODIFICATIONS.
027 *
028 */
029
030package org.kepler.util;
031
032import java.util.Date;
033import java.util.HashMap;
034import java.util.Map;
035
036import org.apache.commons.logging.Log;
037import org.apache.commons.logging.LogFactory;
038import org.kepler.objectmanager.lsid.KeplerLSID;
039import org.kepler.sms.NamedOntClass;
040import org.kepler.util.WorkflowRun.RunAttribute;
041
042/**
043 * A class for building a WorkflowRun piecemeal from property Strings.
044 * 
045 * @author
046 * @version $Id: WorkflowRunBuilder.java 31385 2013-01-29 22:20:22Z barseghian $
047 */
048public class WorkflowRunBuilder{
049
050        private static final Log log = LogFactory.getLog(WorkflowRunBuilder.class
051                        .getName());
052        
053        private KeplerLSID _execLSID = null;
054        private String _referralList = null;
055        private String _user = null;
056        private String _workflowName = null;
057        private KeplerLSID _workflowLSID = null;
058        private Date _startDate = null;
059        private Long _duration = null;
060        private Integer _execId = null;
061        private Map<Integer, String> _errorMsgs = new HashMap<Integer, String>();
062        private String _hostId = null;
063        private String _annotation = null;
064        private String _moduleDependencies = null;
065        private String _type = null;
066        private Map<NamedOntClass, String> _tagsList = new HashMap<NamedOntClass, String>();
067        
068        //not required to create run, but used for KAR download:
069        private KeplerLSID _karLSID = null;
070        private String _karFileName = null;
071        private Long _karFileSize = null;
072        
073        private boolean _malformed = false;
074        
075        public WorkflowRunBuilder(){
076        }
077
078        public void addRunProperty(String name, String value, boolean subproperty){
079                try{
080                        
081                        if (RunAttribute.isValid(name)){
082                                if (name.equals(RunAttribute.ANNOTATION.toString())){
083                                        setAnnotation(value);
084                                }
085                                else if(name.equals(RunAttribute.DURATION.toString())){
086                                        setDuration(value);
087                                }
088                                else if (name.matches(RunAttribute.ERROR.toString()+"\\d*")){
089                                        addError(name, value);
090                                }
091                                else if (name.equals(RunAttribute.EXECID.toString())){
092                                        setExecId(value);
093                                }
094                                else if (name.equals(RunAttribute.EXECLSID.toString())){
095                                        setExecLSID(value);
096                                }
097                                else if (name.equals(RunAttribute.HOSTID.toString())){
098                                        setHostId(value);
099                                }
100                                else if (name.equals(RunAttribute.MODULEDEPENDENCIES.toString())){
101                                        setModuleDependencies(value);
102                                }
103                                else if (name.equals(RunAttribute.REFERRALLIST.toString())){
104                                        setReferralList(value);
105                                }
106                                else if (name.matches(RunAttribute.SEMANTICTYPE.toString()+"\\d*")){
107                                        if (subproperty){
108                                                addTag(value, WorkflowRun.TAG_TYPE_WORKFLOW.toString());
109                                        }
110                                        else{
111                                                addTag(value, WorkflowRun.TAG_TYPE_RUN.toString());
112                                        }
113                                }
114                                else if (name.equals(RunAttribute.STARTTIME.toString())){
115                                        setStartDate(value);
116                                }
117                                else if (name.equals(RunAttribute.TYPE.toString())){
118                                        setType(value);
119                                }
120                                else if (name.equals(RunAttribute.USER.toString())){
121                                        setUser(value);
122                                }
123                                else if (name.equals(RunAttribute.WORKFLOWLSID.toString())){
124                                        setWorkflowLSID(value);
125                                }
126                                else if (name.equals(RunAttribute.WORKFLOWNAME.toString())){
127                                        setWorkflowName(value);
128                                }
129                        }
130                        else{
131                                setMalformed(true);
132                                log.error("ERROR WorkflowRunBuilder.addRunProperty " +
133                                                "invalid WorkflowRun attribute:" + name);
134                        }
135                }catch (Exception e){
136                        setMalformed(true);
137                        log.error("ERROR WorkflowRunBuilder.addRunProperty " +
138                                        "error trying to deal with :" + name + " value:" + value);
139                }
140        }
141        
142        public void setExecLSID(String execLSIDString) {
143                try {
144                        KeplerLSID execLSID = new KeplerLSID(execLSIDString);
145                        _execLSID = execLSID;
146                } catch (Exception e) {
147                        setMalformed(true);
148                        log.error("Couldn't create LSID from execLSIDString:" + execLSIDString);
149                }
150        }
151        
152        public void setKARLSID(String karLSIDString) throws Exception {
153                try {
154                        KeplerLSID karLSID = new KeplerLSID(karLSIDString);
155                        _karLSID = karLSID;
156                } catch (Exception e) {
157                        log.error("Couldn't create LSID from karLSIDString:" + karLSIDString);
158                        throw new Exception(e);
159                }
160        }
161        
162        public KeplerLSID getKARLSID(){
163                return _karLSID;
164        }
165        
166        public void setKARFileName(String karFileName) {
167                _karFileName = karFileName;     
168        }
169        
170        public String getKARFileName() {
171                return _karFileName;    
172        }
173        
174        public void setKARFileSize(String karFileSize) 
175                throws Exception{
176                try{
177                        _karFileSize = new Long(karFileSize);
178                }
179                catch(NumberFormatException nfe){
180                        log.error("NumberFormatException. Couldn't " +
181                                        "create Long karFileSize from String:" + karFileSize);
182                        throw new Exception(nfe);
183                }
184        }
185        
186        public Long getKARFileSize() {
187                return _karFileSize;
188        }
189        
190        /**
191         * @param referralList (i.e. derivedFrom)
192         */
193        public void setReferralList(String referralList) {
194                _referralList = referralList;
195        }
196        
197        public void setUser(String user) {
198                _user = user;
199        }
200        
201        public void setWorkflowName(String workflowName) {
202                _workflowName = workflowName;
203        }
204        
205        public void setWorkflowLSID(String workflowLSIDString) {
206                try{
207                        KeplerLSID workflowLSID = new KeplerLSID(workflowLSIDString);
208                        _workflowLSID = workflowLSID;
209                }
210                catch(Exception e){
211                        setMalformed(true);
212                        log.error("Couldn't create LSID from workflowLSIDString:" + workflowLSIDString);
213                }
214        }
215        
216        public void setStartDate(String startDateString) {
217                try {
218                        Date startDate = WorkflowRunUtil.formatStringFromISO8601(startDateString);
219                        _startDate = startDate;
220                } catch (Exception e) {
221                        setMalformed(true);
222                        log.error("Couldn't create Date from startDateString:" + startDateString);
223                }
224        }
225        
226        public void setDuration(String durationString) {
227                try{
228                        Long duration = new Long(durationString);
229                        _duration = duration;
230                } catch (NumberFormatException nfe){
231                        setMalformed(true);
232                        log.error("Couldn't create Long from durationString:" + durationString);
233                }
234        }
235        
236        public void setExecId(String execIdString) {
237                try{
238                        Integer execId = Integer.parseInt(execIdString);
239                        _execId = execId;
240                }
241                catch (NumberFormatException nfe){
242                        setMalformed(true);
243                        log.error("Couldn't create Integer from execIdString:" + execIdString);
244                }
245        }
246        
247        public void addError(String errorName, String errorString){
248                String errNumStr = errorName.substring(5);
249                try {
250                        Integer errNum = new Integer(errNumStr);
251                        _errorMsgs.put(errNum, errorString);
252                } catch (NumberFormatException nfe) {
253                        setMalformed(true);
254                        log.error("Couldn't get Integer off end of errorName:" + errorName);
255                }
256        }
257        
258        public void setHostId(String hostId) {
259                _hostId = hostId;
260        }
261        
262        public void setAnnotation(String annotation) {
263                _annotation = annotation;
264        }
265        
266        public void setModuleDependencies(String moduleDependencies) {
267                _moduleDependencies = moduleDependencies;
268        }
269        
270        public void setType(String type) {
271                _type = type;
272        }
273        
274        public void addTag(String tagURI, String type){
275        boolean isRemovable = (WorkflowRun.TAG_TYPE_RUN).equals(type);
276        NamedOntClass cls = NamedOntClass.createNamedOntClassFromURI(tagURI);
277        cls.setRemovable(isRemovable);
278        if (!_tagsList.containsKey(cls)) {
279                _tagsList.put(cls, type);
280        }
281        }
282
283        public void setMalformed(boolean malformed){
284                log.error("set malformed:" + malformed);
285                _malformed = malformed;
286        }
287        
288        public boolean getMalformed(){
289                return _malformed;
290        }
291        
292        public KeplerLSID getExecLSID() {
293                return _execLSID;
294        }
295        
296        /**
297         * Attempt to create a WorkflowRun from this WorkflowRunBuilder
298         * @return WorkflowRun, or null if error.
299         */
300        public WorkflowRun createWorkflowRun(){
301                
302                if (getMalformed()){
303                        log.error("was marked malformed, unable to create WorkflowRun");
304                        return null;
305                }
306                
307                try {
308                        WorkflowRun run = new WorkflowRun(_execLSID, _referralList, _user, _workflowName,
309                        _workflowLSID, _startDate, _duration, _execId, _errorMsgs, _hostId, _annotation, 
310                        _moduleDependencies, _type, _tagsList);
311                        return run;
312                } catch (Exception e) {
313                        log.error("Error constructing run: " + e.getMessage());
314                        return null;
315                }
316        }
317        
318}