001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one
003     * or more contributor license agreements.  See the NOTICE file
004     * distributed with this work for additional information
005     * regarding copyright ownership.  The ASF licenses this file
006     * to you under the Apache License, Version 2.0 (the
007     * "License"); you may not use this file except in compliance
008     * with the License.  You may obtain a copy of the License at
009     *
010     *      http://www.apache.org/licenses/LICENSE-2.0
011     *
012     * Unless required by applicable law or agreed to in writing, software
013     * distributed under the License is distributed on an "AS IS" BASIS,
014     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015     * See the License for the specific language governing permissions and
016     * limitations under the License.
017     */
018    package org.apache.oozie;
019    
020    import com.google.common.annotations.VisibleForTesting;
021    import org.apache.commons.lang.StringUtils;
022    import org.apache.hadoop.conf.Configuration;
023    import org.apache.oozie.client.CoordinatorAction;
024    import org.apache.oozie.client.CoordinatorJob;
025    import org.apache.oozie.client.OozieClient;
026    import org.apache.oozie.client.WorkflowJob;
027    import org.apache.oozie.client.rest.RestConstants;
028    import org.apache.oozie.command.CommandException;
029    import org.apache.oozie.command.coord.CoordActionInfoXCommand;
030    import org.apache.oozie.command.coord.CoordActionsIgnoreXCommand;
031    import org.apache.oozie.command.coord.CoordActionsKillXCommand;
032    import org.apache.oozie.command.coord.CoordChangeXCommand;
033    import org.apache.oozie.command.coord.CoordJobXCommand;
034    import org.apache.oozie.command.coord.CoordJobsXCommand;
035    import org.apache.oozie.command.coord.CoordKillXCommand;
036    import org.apache.oozie.command.coord.CoordRerunXCommand;
037    import org.apache.oozie.command.coord.CoordResumeXCommand;
038    import org.apache.oozie.command.coord.CoordSubmitXCommand;
039    import org.apache.oozie.command.coord.CoordSuspendXCommand;
040    import org.apache.oozie.command.coord.CoordUpdateXCommand;
041    import org.apache.oozie.executor.jpa.JPAExecutorException;
042    import org.apache.oozie.executor.jpa.WorkflowJobQueryExecutor;
043    import org.apache.oozie.executor.jpa.WorkflowJobQueryExecutor.WorkflowJobQuery;
044    import org.apache.oozie.service.DagXLogInfoService;
045    import org.apache.oozie.service.Services;
046    import org.apache.oozie.service.XLogStreamingService;
047    import org.apache.oozie.util.CoordActionsInDateRange;
048    import org.apache.oozie.util.DateUtils;
049    import org.apache.oozie.util.Pair;
050    import org.apache.oozie.util.ParamChecker;
051    import org.apache.oozie.util.XLog;
052    import org.apache.oozie.util.XLogFilter;
053    import org.apache.oozie.util.XLogUserFilterParam;
054    
055    import java.io.IOException;
056    import java.io.Writer;
057    import java.sql.Timestamp;
058    import java.text.ParseException;
059    import java.util.ArrayList;
060    import java.util.Collections;
061    import java.util.Comparator;
062    import java.util.Date;
063    import java.util.HashMap;
064    import java.util.HashSet;
065    import java.util.Iterator;
066    import java.util.LinkedHashSet;
067    import java.util.List;
068    import java.util.Map;
069    import java.util.Set;
070    import java.util.StringTokenizer;
071    
072    public class CoordinatorEngine extends BaseEngine {
073        private static final XLog LOG = XLog.getLog(CoordinatorEngine.class);
074        public final static String COORD_ACTIONS_LOG_MAX_COUNT = "oozie.coord.actions.log.max.count";
075        private final static int COORD_ACTIONS_LOG_MAX_COUNT_DEFAULT = 50;
076        private final int maxNumActionsForLog;
077    
078        public enum FILTER_COMPARATORS {
079            //This ordering is important, dont change this
080            GREATER_EQUAL(">="), GREATER(">"), LESSTHAN_EQUAL("<="), LESSTHAN("<"), NOT_EQUALS("!="), EQUALS("=");
081    
082            private final String sign;
083    
084            FILTER_COMPARATORS(String sign) {
085                this.sign = sign;
086            }
087    
088            public String getSign() {
089                return sign;
090            }
091        }
092    
093        public static final String[] VALID_JOB_FILTERS = {OozieClient.FILTER_STATUS, OozieClient.FILTER_NOMINAL_TIME};
094    
095        /**
096         * Create a system Coordinator engine, with no user and no group.
097         */
098        public CoordinatorEngine() {
099            if (!Services.get().getConf().getBoolean(USE_XCOMMAND, true)) {
100                LOG.debug("Oozie CoordinatorEngine is not using XCommands.");
101            }
102            else {
103                LOG.debug("Oozie CoordinatorEngine is using XCommands.");
104            }
105            maxNumActionsForLog = Services.get().getConf()
106                    .getInt(COORD_ACTIONS_LOG_MAX_COUNT, COORD_ACTIONS_LOG_MAX_COUNT_DEFAULT);
107        }
108    
109        /**
110         * Create a Coordinator engine to perform operations on behave of a user.
111         *
112         * @param user user name.
113         */
114        public CoordinatorEngine(String user) {
115            this();
116            this.user = ParamChecker.notEmpty(user, "user");
117        }
118    
119        /*
120         * (non-Javadoc)
121         *
122         * @see org.apache.oozie.BaseEngine#getDefinition(java.lang.String)
123         */
124        @Override
125        public String getDefinition(String jobId) throws BaseEngineException {
126            CoordinatorJobBean job = getCoordJobWithNoActionInfo(jobId);
127            return job.getOrigJobXml();
128        }
129    
130        /**
131         * @param jobId
132         * @return CoordinatorJobBean
133         * @throws BaseEngineException
134         */
135        private CoordinatorJobBean getCoordJobWithNoActionInfo(String jobId) throws BaseEngineException {
136            try {
137                return new CoordJobXCommand(jobId).call();
138            }
139            catch (CommandException ex) {
140                throw new BaseEngineException(ex);
141            }
142        }
143    
144        /**
145         * @param actionId
146         * @return CoordinatorActionBean
147         * @throws BaseEngineException
148         */
149        public CoordinatorActionBean getCoordAction(String actionId) throws BaseEngineException {
150            try {
151                return new CoordActionInfoXCommand(actionId).call();
152            }
153            catch (CommandException ex) {
154                throw new BaseEngineException(ex);
155            }
156        }
157    
158        /*
159         * (non-Javadoc)
160         *
161         * @see org.apache.oozie.BaseEngine#getCoordJob(java.lang.String)
162         */
163        @Override
164        public CoordinatorJobBean getCoordJob(String jobId) throws BaseEngineException {
165            try {
166                return new CoordJobXCommand(jobId).call();
167            }
168            catch (CommandException ex) {
169                throw new BaseEngineException(ex);
170            }
171        }
172    
173        /*
174         * (non-Javadoc)
175         *
176         * @see org.apache.oozie.BaseEngine#getCoordJob(java.lang.String, java.lang.String, int, int)
177         */
178        @Override
179        public CoordinatorJobBean getCoordJob(String jobId, String filter, int offset, int length, boolean desc)
180                throws BaseEngineException {
181            Map<Pair<String, FILTER_COMPARATORS>, List<Object>> filterMap = parseJobFilter(filter);
182            try {
183                return new CoordJobXCommand(jobId, filterMap, offset, length, desc).call();
184            }
185            catch (CommandException ex) {
186                throw new BaseEngineException(ex);
187            }
188        }
189    
190        /*
191         * (non-Javadoc)
192         *
193         * @see org.apache.oozie.BaseEngine#getJobIdForExternalId(java.lang.String)
194         */
195        @Override
196        public String getJobIdForExternalId(String externalId) throws CoordinatorEngineException {
197            return null;
198        }
199    
200        /*
201         * (non-Javadoc)
202         *
203         * @see org.apache.oozie.BaseEngine#kill(java.lang.String)
204         */
205        @Override
206        public void kill(String jobId) throws CoordinatorEngineException {
207            try {
208                new CoordKillXCommand(jobId).call();
209                LOG.info("User " + user + " killed the Coordinator job " + jobId);
210            }
211            catch (CommandException e) {
212                throw new CoordinatorEngineException(e);
213            }
214        }
215    
216        public CoordinatorActionInfo killActions(String jobId, String rangeType, String scope) throws CoordinatorEngineException {
217            try {
218                return new CoordActionsKillXCommand(jobId, rangeType, scope).call();
219            }
220            catch (CommandException e) {
221                throw new CoordinatorEngineException(e);
222            }
223        }
224    
225        /* (non-Javadoc)
226         * @see org.apache.oozie.BaseEngine#change(java.lang.String, java.lang.String)
227         */
228        @Override
229        public void change(String jobId, String changeValue) throws CoordinatorEngineException {
230            try {
231                new CoordChangeXCommand(jobId, changeValue).call();
232                LOG.info("User " + user + " changed the Coordinator job [" + jobId + "] to " + changeValue);
233            }
234            catch (CommandException e) {
235                throw new CoordinatorEngineException(e);
236            }
237        }
238    
239        public CoordinatorActionInfo ignore(String jobId, String type, String scope) throws CoordinatorEngineException {
240            try {
241                LOG.info("User " + user + " ignore a Coordinator Action (s) [" + scope + "] of the Coordinator Job ["
242                        + jobId + "]");
243                return new CoordActionsIgnoreXCommand(jobId, type, scope).call();
244            }
245            catch (CommandException e) {
246                throw new CoordinatorEngineException(e);
247            }
248        }
249    
250        @Override
251        @Deprecated
252        public void reRun(String jobId, Configuration conf) throws BaseEngineException {
253            throw new BaseEngineException(new XException(ErrorCode.E0301, "invalid use of rerun"));
254        }
255    
256        /**
257         * Rerun coordinator actions for given rerunType
258         *
259         * @param jobId
260         * @param rerunType
261         * @param scope
262         * @param refresh
263         * @param noCleanup
264         * @throws BaseEngineException
265         */
266        public CoordinatorActionInfo reRun(String jobId, String rerunType, String scope, boolean refresh, boolean noCleanup)
267                throws BaseEngineException {
268            try {
269                return new CoordRerunXCommand(jobId, rerunType, scope, refresh,
270                        noCleanup).call();
271            }
272            catch (CommandException ex) {
273                throw new BaseEngineException(ex);
274            }
275        }
276    
277        /*
278         * (non-Javadoc)
279         *
280         * @see org.apache.oozie.BaseEngine#resume(java.lang.String)
281         */
282        @Override
283        public void resume(String jobId) throws CoordinatorEngineException {
284            try {
285                new CoordResumeXCommand(jobId).call();
286            }
287            catch (CommandException e) {
288                throw new CoordinatorEngineException(e);
289            }
290        }
291    
292        @Override
293        @Deprecated
294        public void start(String jobId) throws BaseEngineException {
295            throw new BaseEngineException(new XException(ErrorCode.E0301, "invalid use of start"));
296        }
297    
298        /*
299         * (non-Javadoc)
300         *
301         * @see org.apache.oozie.BaseEngine#streamLog(java.lang.String,
302         * java.io.Writer)
303         */
304        @Override
305        public void streamLog(String jobId, Writer writer, Map<String, String[]> params) throws IOException,
306                BaseEngineException {
307    
308            try {
309                XLogFilter filter = new XLogFilter(new XLogUserFilterParam(params));
310                filter.setParameter(DagXLogInfoService.JOB, jobId);
311                Date lastTime = null;
312                CoordinatorJobBean job = getCoordJobWithNoActionInfo(jobId);
313                if (job.isTerminalStatus()) {
314                    lastTime = job.getLastModifiedTime();
315                }
316                if (lastTime == null) {
317                    lastTime = new Date();
318                }
319                Services.get().get(XLogStreamingService.class)
320                        .streamLog(filter, job.getCreatedTime(), lastTime, writer, params);
321            }
322            catch (Exception e) {
323                throw new IOException(e);
324            }
325        }
326    
327        /**
328         * Add list of actions to the filter based on conditions
329         *
330         * @param jobId Job Id
331         * @param logRetrievalScope Value for the retrieval type
332         * @param logRetrievalType Based on which filter criteria the log is retrieved
333         * @param writer writer to stream the log to
334         * @param params additional parameters from the request
335         * @throws IOException
336         * @throws BaseEngineException
337         * @throws CommandException
338         */
339        public void streamLog(String jobId, String logRetrievalScope, String logRetrievalType, Writer writer,
340                Map<String, String[]> params) throws IOException, BaseEngineException, CommandException {
341    
342            Date startTime = null;
343            Date endTime = null;
344            XLogFilter filter = new XLogFilter(new XLogUserFilterParam(params));
345    
346            filter.setParameter(DagXLogInfoService.JOB, jobId);
347            if (logRetrievalScope != null && logRetrievalType != null) {
348                // if coordinator action logs are to be retrieved based on action id range
349                if (logRetrievalType.equals(RestConstants.JOB_LOG_ACTION)) {
350                    // Use set implementation that maintains order or elements to achieve reproducibility:
351                    Set<String> actionSet = new LinkedHashSet<String>();
352                    String[] list = logRetrievalScope.split(",");
353                    for (String s : list) {
354                        s = s.trim();
355                        if (s.contains("-")) {
356                            String[] range = s.split("-");
357                            if (range.length != 2) {
358                                throw new CommandException(ErrorCode.E0302, "format is wrong for action's range '" + s
359                                        + "'");
360                            }
361                            int start;
362                            int end;
363                            try {
364                                start = Integer.parseInt(range[0].trim());
365                            } catch (NumberFormatException ne) {
366                                throw new CommandException(ErrorCode.E0302, "could not parse " + range[0].trim() + "into an integer",
367                                        ne);
368                            }
369                            try {
370                                end = Integer.parseInt(range[1].trim());
371                            } catch (NumberFormatException ne) {
372                                throw new CommandException(ErrorCode.E0302, "could not parse " + range[1].trim() + "into an integer",
373                                        ne);
374                            }
375                            if (start > end) {
376                                throw new CommandException(ErrorCode.E0302, "format is wrong for action's range '" + s + "'");
377                            }
378                            for (int i = start; i <= end; i++) {
379                                actionSet.add(jobId + "@" + i);
380                            }
381                        }
382                        else {
383                            try {
384                                Integer.parseInt(s);
385                            }
386                            catch (NumberFormatException ne) {
387                                throw new CommandException(ErrorCode.E0302, "format is wrong for action id'" + s
388                                        + "'. Integer only.");
389                            }
390                            actionSet.add(jobId + "@" + s);
391                        }
392                    }
393    
394                    if (actionSet.size() >= maxNumActionsForLog) {
395                        throw new CommandException(ErrorCode.E0302,
396                                "Retrieving log of too many coordinator actions. Max count is "
397                                        + maxNumActionsForLog + " actions");
398                    }
399                    Iterator<String> actionsIterator = actionSet.iterator();
400                    StringBuilder orSeparatedActions = new StringBuilder("");
401                    boolean orRequired = false;
402                    while (actionsIterator.hasNext()) {
403                        if (orRequired) {
404                            orSeparatedActions.append("|");
405                        }
406                        orSeparatedActions.append(actionsIterator.next().toString());
407                        orRequired = true;
408                    }
409                    if (actionSet.size() > 1 && orRequired) {
410                        orSeparatedActions.insert(0, "(");
411                        orSeparatedActions.append(")");
412                    }
413    
414                    filter.setParameter(DagXLogInfoService.ACTION, orSeparatedActions.toString());
415                    if (actionSet != null && actionSet.size() == 1) {
416                        CoordinatorActionBean actionBean = getCoordAction(actionSet.iterator().next());
417                        startTime = actionBean.getCreatedTime();
418                        endTime = actionBean.getStatus().equals(CoordinatorAction.Status.RUNNING) ? new Date() : actionBean
419                                .getLastModifiedTime();
420                        filter.setActionList(true);
421                    }
422                    else if (actionSet != null && actionSet.size() > 0) {
423                        List<String> tempList = new ArrayList<String>(actionSet);
424                        Collections.sort(tempList, new Comparator<String>() {
425                            public int compare(String a, String b) {
426                                return Integer.valueOf(a.substring(a.lastIndexOf("@") + 1)).compareTo(
427                                        Integer.valueOf(b.substring(b.lastIndexOf("@") + 1)));
428                            }
429                        });
430                        startTime = getCoordAction(tempList.get(0)).getCreatedTime();
431                        endTime = CoordActionsInDateRange.getCoordActionsLastModifiedDate(jobId, tempList.get(0),
432                                tempList.get(tempList.size() - 1));
433                        filter.setActionList(true);
434                    }
435                }
436                // if coordinator action logs are to be retrieved based on date range
437                // this block gets the corresponding list of coordinator actions to be used by the log filter
438                if (logRetrievalType.equalsIgnoreCase(RestConstants.JOB_LOG_DATE)) {
439                    List<String> coordActionIdList = null;
440                    try {
441                        coordActionIdList = CoordActionsInDateRange.getCoordActionIdsFromDates(jobId, logRetrievalScope);
442                    }
443                    catch (XException xe) {
444                        throw new CommandException(ErrorCode.E0302, "Error in date range for coordinator actions", xe);
445                    }
446                    if(coordActionIdList.size() >= maxNumActionsForLog) {
447                        throw new CommandException(ErrorCode.E0302,
448                                "Retrieving log of too many coordinator actions. Max count is "
449                                        + maxNumActionsForLog + " actions");
450                    }
451                    StringBuilder orSeparatedActions = new StringBuilder("");
452                    boolean orRequired = false;
453                    for (String coordActionId : coordActionIdList) {
454                        if (orRequired) {
455                            orSeparatedActions.append("|");
456                        }
457                        orSeparatedActions.append(coordActionId);
458                        orRequired = true;
459                    }
460                    if (coordActionIdList.size() > 1 && orRequired) {
461                        orSeparatedActions.insert(0, "(");
462                        orSeparatedActions.append(")");
463                    }
464                    filter.setParameter(DagXLogInfoService.ACTION, orSeparatedActions.toString());
465                    if (coordActionIdList != null && coordActionIdList.size() == 1) {
466                        CoordinatorActionBean actionBean = getCoordAction(coordActionIdList.get(0));
467                        startTime = actionBean.getCreatedTime();
468                        endTime = actionBean.getStatus().equals(CoordinatorAction.Status.RUNNING) ? new Date() : actionBean
469                                .getLastModifiedTime();
470                        filter.setActionList(true);
471                    }
472                    else if (coordActionIdList != null && coordActionIdList.size() > 0) {
473                        Collections.sort(coordActionIdList, new Comparator<String>() {
474                            public int compare(String a, String b) {
475                                return Integer.valueOf(a.substring(a.lastIndexOf("@") + 1)).compareTo(
476                                        Integer.valueOf(b.substring(b.lastIndexOf("@") + 1)));
477                            }
478                        });
479                        startTime = getCoordAction(coordActionIdList.get(0)).getCreatedTime();
480                        endTime = CoordActionsInDateRange.getCoordActionsLastModifiedDate(jobId, coordActionIdList.get(0),
481                                coordActionIdList.get(coordActionIdList.size() - 1));
482                        filter.setActionList(true);
483                    }
484                }
485            }
486            if (startTime == null || endTime == null) {
487                CoordinatorJobBean job = getCoordJobWithNoActionInfo(jobId);
488                if (startTime == null) {
489                    startTime = job.getCreatedTime();
490                }
491                if (endTime == null) {
492                    if (job.isTerminalStatus()) {
493                        endTime = job.getLastModifiedTime();
494                    }
495                    if (endTime == null) {
496                        endTime = new Date();
497                    }
498                }
499            }
500            Services.get().get(XLogStreamingService.class).streamLog(filter, startTime, endTime, writer, params);
501        }
502    
503        /*
504         * (non-Javadoc)
505         *
506         * @see
507         * org.apache.oozie.BaseEngine#submitJob(org.apache.hadoop.conf.Configuration
508         * , boolean)
509         */
510        @Override
511        public String submitJob(Configuration conf, boolean startJob) throws CoordinatorEngineException {
512            try {
513                CoordSubmitXCommand submit = new CoordSubmitXCommand(conf);
514                return submit.call();
515            }
516            catch (CommandException ex) {
517                throw new CoordinatorEngineException(ex);
518            }
519        }
520    
521        /*
522         * (non-Javadoc)
523         *
524         * @see
525         * org.apache.oozie.BaseEngine#dryRunSubmit(org.apache.hadoop.conf.Configuration)
526         */
527        @Override
528        public String dryRunSubmit(Configuration conf) throws CoordinatorEngineException {
529            try {
530                CoordSubmitXCommand submit = new CoordSubmitXCommand(true, conf);
531                return submit.call();
532            }
533            catch (CommandException ex) {
534                throw new CoordinatorEngineException(ex);
535            }
536        }
537    
538        /*
539         * (non-Javadoc)
540         *
541         * @see org.apache.oozie.BaseEngine#suspend(java.lang.String)
542         */
543        @Override
544        public void suspend(String jobId) throws CoordinatorEngineException {
545            try {
546                new CoordSuspendXCommand(jobId).call();
547            }
548            catch (CommandException e) {
549                throw new CoordinatorEngineException(e);
550            }
551    
552        }
553    
554        /*
555         * (non-Javadoc)
556         *
557         * @see org.apache.oozie.BaseEngine#getJob(java.lang.String)
558         */
559        @Override
560        public WorkflowJob getJob(String jobId) throws BaseEngineException {
561            throw new BaseEngineException(new XException(ErrorCode.E0301, "cannot get a workflow job from CoordinatorEngine"));
562        }
563    
564        /*
565         * (non-Javadoc)
566         *
567         * @see org.apache.oozie.BaseEngine#getJob(java.lang.String, int, int)
568         */
569        @Override
570        public WorkflowJob getJob(String jobId, int start, int length) throws BaseEngineException {
571            throw new BaseEngineException(new XException(ErrorCode.E0301, "cannot get a workflow job from CoordinatorEngine"));
572        }
573    
574        private static final Set<String> FILTER_NAMES = new HashSet<String>();
575    
576        static {
577            FILTER_NAMES.add(OozieClient.FILTER_USER);
578            FILTER_NAMES.add(OozieClient.FILTER_NAME);
579            FILTER_NAMES.add(OozieClient.FILTER_GROUP);
580            FILTER_NAMES.add(OozieClient.FILTER_STATUS);
581            FILTER_NAMES.add(OozieClient.FILTER_ID);
582            FILTER_NAMES.add(OozieClient.FILTER_FREQUENCY);
583            FILTER_NAMES.add(OozieClient.FILTER_UNIT);
584        }
585    
586        /**
587         * @param filter
588         * @param start
589         * @param len
590         * @return CoordinatorJobInfo
591         * @throws CoordinatorEngineException
592         */
593        public CoordinatorJobInfo getCoordJobs(String filter, int start, int len) throws CoordinatorEngineException {
594            Map<String, List<String>> filterList = parseJobsFilter(filter);
595    
596            try {
597                return new CoordJobsXCommand(filterList, start, len).call();
598            }
599            catch (CommandException ex) {
600                throw new CoordinatorEngineException(ex);
601            }
602        }
603    
604        // Parses the filter string (e.g status=RUNNING;status=WAITING) and returns a list of status values
605        public Map<Pair<String, FILTER_COMPARATORS>, List<Object>> parseJobFilter(String filter) throws
606            CoordinatorEngineException {
607            Map<Pair<String, FILTER_COMPARATORS>, List<Object>> filterMap = new HashMap<Pair<String,
608                FILTER_COMPARATORS>, List<Object>>();
609            if (filter != null) {
610                //split name value pairs
611                StringTokenizer st = new StringTokenizer(filter, ";");
612                while (st.hasMoreTokens()) {
613                    String token = st.nextToken().trim();
614                    Pair<String, FILTER_COMPARATORS> pair = null;
615                    for (FILTER_COMPARATORS comp : FILTER_COMPARATORS.values()) {
616                        if (token.contains(comp.getSign())) {
617                            int index = token.indexOf(comp.getSign());
618                            String key = token.substring(0, index);
619                            String valueStr = token.substring(index + comp.getSign().length());
620                            Object value;
621    
622                            if (key.equalsIgnoreCase(OozieClient.FILTER_STATUS)) {
623                                value = valueStr.toUpperCase();
624                                try {
625                                    CoordinatorAction.Status.valueOf((String) value);
626                                } catch (IllegalArgumentException ex) {
627                                    // Check for incorrect status value
628                                    throw new CoordinatorEngineException(ErrorCode.E0421, filter,
629                                        XLog.format("invalid status value [{0}]." + " Valid status values are: [{1}]",
630                                            valueStr, StringUtils.join(CoordinatorAction.Status.values(), ", ")));
631                                }
632    
633                                if (!(comp == FILTER_COMPARATORS.EQUALS || comp == FILTER_COMPARATORS.NOT_EQUALS)) {
634                                    throw new CoordinatorEngineException(ErrorCode.E0421, filter,
635                                        XLog.format("invalid comparator [{0}] for status." + " Valid are = and !=",
636                                            comp.getSign()));
637                                }
638    
639                                pair = Pair.of(OozieClient.FILTER_STATUS, comp);
640                            } else if (key.equalsIgnoreCase(OozieClient.FILTER_NOMINAL_TIME)) {
641                                try {
642                                    value = new Timestamp(DateUtils.parseDateUTC(valueStr).getTime());
643                                } catch (ParseException e) {
644                                    throw new CoordinatorEngineException(ErrorCode.E0421, filter,
645                                        XLog.format("invalid nominal time [{0}]." + " Valid format: " +
646                                                "[{1}]", valueStr, DateUtils.ISO8601_UTC_MASK));
647                                }
648                                pair = Pair.of(OozieClient.FILTER_NOMINAL_TIME, comp);
649                            } else {
650                                // Check for incorrect filter option
651                                throw new CoordinatorEngineException(ErrorCode.E0421, filter,
652                                    XLog.format("invalid filter [{0}]." + " Valid filters [{1}]", key, StringUtils.join
653                                        (VALID_JOB_FILTERS, ", ")));
654                            }
655                            if (!filterMap.containsKey(pair)) {
656                                filterMap.put(pair, new ArrayList<Object>());
657                            }
658                            filterMap.get(pair).add(value);
659                            break;
660                        }
661                    }
662    
663                    if (pair == null) {
664                        //token doesn't contain comparator
665                        throw new CoordinatorEngineException(ErrorCode.E0421, filter,
666                            "filter should be of format <key><comparator><value> pairs");
667                    }
668                }
669            }
670            return filterMap;
671        }
672    
673        /**
674         * @param filter
675         * @return Map<String, List<String>>
676         * @throws CoordinatorEngineException
677         */
678        @VisibleForTesting
679        Map<String, List<String>> parseJobsFilter(String filter) throws CoordinatorEngineException {
680            Map<String, List<String>> map = new HashMap<String, List<String>>();
681            boolean isTimeUnitSpecified = false;
682            String timeUnit = "MINUTE";
683            boolean isFrequencySpecified = false;
684            String frequency = "";
685            if (filter != null) {
686                StringTokenizer st = new StringTokenizer(filter, ";");
687                while (st.hasMoreTokens()) {
688                    String token = st.nextToken();
689                    if (token.contains("=")) {
690                        String[] pair = token.split("=");
691                        if (pair.length != 2) {
692                            throw new CoordinatorEngineException(ErrorCode.E0420, filter,
693                                    "elements must be name=value pairs");
694                        }
695                        if (!FILTER_NAMES.contains(pair[0].toLowerCase())) {
696                            throw new CoordinatorEngineException(ErrorCode.E0420, filter, XLog.format("invalid name [{0}]",
697                                    pair[0]));
698                        }
699                        if (pair[0].equalsIgnoreCase("frequency")) {
700                            isFrequencySpecified = true;
701                            try {
702                                frequency = (int) Float.parseFloat(pair[1]) + "";
703                                continue;
704                            }
705                            catch (NumberFormatException NANException) {
706                                throw new CoordinatorEngineException(ErrorCode.E0420, filter, XLog.format(
707                                        "invalid value [{0}] for frequency. A numerical value is expected", pair[1]));
708                            }
709                        }
710                        if (pair[0].equalsIgnoreCase("unit")) {
711                            isTimeUnitSpecified = true;
712                            timeUnit = pair[1];
713                            if (!timeUnit.equalsIgnoreCase("months") && !timeUnit.equalsIgnoreCase("days")
714                                    && !timeUnit.equalsIgnoreCase("hours") && !timeUnit.equalsIgnoreCase("minutes")) {
715                                throw new CoordinatorEngineException(ErrorCode.E0420, filter, XLog.format(
716                                        "invalid value [{0}] for time unit. "
717                                                + "Valid value is one of months, days, hours or minutes", pair[1]));
718                            }
719                            continue;
720                        }
721                        if (pair[0].equals("status")) {
722                            try {
723                                CoordinatorJob.Status.valueOf(pair[1]);
724                            }
725                            catch (IllegalArgumentException ex) {
726                                throw new CoordinatorEngineException(ErrorCode.E0420, filter, XLog.format(
727                                        "invalid status [{0}]", pair[1]));
728                            }
729                        }
730                        List<String> list = map.get(pair[0]);
731                        if (list == null) {
732                            list = new ArrayList<String>();
733                            map.put(pair[0], list);
734                        }
735                        list.add(pair[1]);
736                    } else {
737                        throw new CoordinatorEngineException(ErrorCode.E0420, filter, "elements must be name=value pairs");
738                    }
739                }
740                // Unit is specified and frequency is not specified
741                if (!isFrequencySpecified && isTimeUnitSpecified) {
742                    throw new CoordinatorEngineException(ErrorCode.E0420, filter, "time unit should be added only when "
743                            + "frequency is specified. Either specify frequency also or else remove the time unit");
744                } else if (isFrequencySpecified) {
745                    // Frequency value is specified
746                    if (isTimeUnitSpecified) {
747                        if (timeUnit.equalsIgnoreCase("months")) {
748                            timeUnit = "MONTH";
749                        } else if (timeUnit.equalsIgnoreCase("days")) {
750                            timeUnit = "DAY";
751                        } else if (timeUnit.equalsIgnoreCase("hours")) {
752                            // When job details are persisted to database, frequency in hours are converted to minutes.
753                            // This conversion is to conform with that.
754                            frequency = Integer.parseInt(frequency) * 60 + "";
755                            timeUnit = "MINUTE";
756                        } else if (timeUnit.equalsIgnoreCase("minutes")) {
757                            timeUnit = "MINUTE";
758                        }
759                    }
760                    // Adding the frequency and time unit filters to the filter map
761                    List<String> list = new ArrayList<String>();
762                    list.add(timeUnit);
763                    map.put("unit", list);
764                    list = new ArrayList<String>();
765                    list.add(frequency);
766                    map.put("frequency", list);
767                }
768            }
769            return map;
770        }
771    
772        public List<WorkflowJobBean> getReruns(String coordActionId) throws CoordinatorEngineException {
773            List<WorkflowJobBean> wfBeans;
774            try {
775                wfBeans = WorkflowJobQueryExecutor.getInstance().getList(WorkflowJobQuery.GET_WORKFLOWS_PARENT_COORD_RERUN,
776                        coordActionId);
777            }
778            catch (JPAExecutorException e) {
779                throw new CoordinatorEngineException(e);
780            }
781            return wfBeans;
782        }
783    
784        /**
785         * Update coord job definition.
786         *
787         * @param conf the conf
788         * @param jobId the job id
789         * @param dryrun the dryrun
790         * @param showDiff the show diff
791         * @return the string
792         * @throws CoordinatorEngineException the coordinator engine exception
793         */
794        public String updateJob(Configuration conf, String jobId, boolean dryrun, boolean showDiff)
795                throws CoordinatorEngineException {
796            try {
797                CoordUpdateXCommand update = new CoordUpdateXCommand(dryrun, conf, jobId, showDiff);
798                return update.call();
799            }
800            catch (CommandException ex) {
801                throw new CoordinatorEngineException(ex);
802            }
803        }
804    }