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.command.coord;
019
020 import java.io.IOException;
021 import java.io.StringReader;
022 import java.net.URI;
023 import java.net.URISyntaxException;
024 import java.text.ParseException;
025 import java.util.Calendar;
026 import java.util.Date;
027 import java.util.List;
028
029 import org.apache.hadoop.conf.Configuration;
030 import org.apache.oozie.CoordinatorActionBean;
031 import org.apache.oozie.CoordinatorJobBean;
032 import org.apache.oozie.ErrorCode;
033 import org.apache.oozie.client.CoordinatorAction;
034 import org.apache.oozie.client.Job;
035 import org.apache.oozie.client.OozieClient;
036 import org.apache.oozie.command.CommandException;
037 import org.apache.oozie.command.PreconditionException;
038 import org.apache.oozie.coord.CoordELEvaluator;
039 import org.apache.oozie.coord.CoordELFunctions;
040 import org.apache.oozie.coord.TimeUnit;
041 import org.apache.oozie.dependency.URIHandler;
042 import org.apache.oozie.dependency.URIHandlerException;
043 import org.apache.oozie.executor.jpa.CoordActionGetForInputCheckJPAExecutor;
044 import org.apache.oozie.executor.jpa.CoordActionQueryExecutor;
045 import org.apache.oozie.executor.jpa.CoordActionQueryExecutor.CoordActionQuery;
046 import org.apache.oozie.executor.jpa.CoordJobQueryExecutor;
047 import org.apache.oozie.executor.jpa.CoordJobQueryExecutor.CoordJobQuery;
048 import org.apache.oozie.executor.jpa.JPAExecutorException;
049 import org.apache.oozie.service.CallableQueueService;
050 import org.apache.oozie.service.EventHandlerService;
051 import org.apache.oozie.service.JPAService;
052 import org.apache.oozie.service.Service;
053 import org.apache.oozie.service.Services;
054 import org.apache.oozie.service.URIHandlerService;
055 import org.apache.oozie.util.DateUtils;
056 import org.apache.oozie.util.ELEvaluator;
057 import org.apache.oozie.util.LogUtils;
058 import org.apache.oozie.util.ParamChecker;
059 import org.apache.oozie.util.StatusUtils;
060 import org.apache.oozie.util.XConfiguration;
061 import org.apache.oozie.util.XLog;
062 import org.apache.oozie.util.XmlUtils;
063 import org.jdom.Element;
064
065 /**
066 * The command to check if an action's data input paths exist in the file system.
067 */
068 public class CoordActionInputCheckXCommand extends CoordinatorXCommand<Void> {
069
070 private final String actionId;
071 /**
072 * Property name of command re-queue interval for coordinator action input check in
073 * milliseconds.
074 */
075 public static final String CONF_COORD_INPUT_CHECK_REQUEUE_INTERVAL = Service.CONF_PREFIX
076 + "coord.input.check.requeue.interval";
077 /**
078 * Default re-queue interval in ms. It is applied when no value defined in
079 * the oozie configuration.
080 */
081 private final int DEFAULT_COMMAND_REQUEUE_INTERVAL = 60000; // 1 minute
082 private CoordinatorActionBean coordAction = null;
083 private CoordinatorJobBean coordJob = null;
084 private JPAService jpaService = null;
085 private String jobId = null;
086
087 public CoordActionInputCheckXCommand(String actionId, String jobId) {
088 super("coord_action_input", "coord_action_input", 1);
089 this.actionId = ParamChecker.notEmpty(actionId, "actionId");
090 this.jobId = jobId;
091 }
092
093 /**
094 * Computes the nominal time of the next action.
095 * Based on CoordMaterializeTransitionXCommand#materializeActions
096 *
097 * @return the nominal time of the next action
098 * @throws ParseException
099 */
100 private Date computeNextNominalTime() throws ParseException {
101 Date nextNominalTime;
102 boolean isCronFrequency = false;
103 int freq = -1;
104 try {
105 freq = Integer.parseInt(coordJob.getFrequency());
106 } catch (NumberFormatException e) {
107 isCronFrequency = true;
108 }
109
110 if (isCronFrequency) {
111 nextNominalTime = CoordCommandUtils.getNextValidActionTimeForCronFrequency(coordAction.getNominalTime(), coordJob);
112 } else {
113 Calendar nextNominalTimeCal = Calendar.getInstance(DateUtils.getTimeZone(coordJob.getTimeZone()));
114 nextNominalTimeCal.setTime(coordAction.getNominalTime());
115 TimeUnit freqTU = TimeUnit.valueOf(coordJob.getTimeUnitStr());
116 nextNominalTimeCal.add(freqTU.getCalendarUnit(), freq);
117 nextNominalTime = nextNominalTimeCal.getTime();
118 }
119
120 // If the next nominal time is after the job's end time, then this is the last action, so return null
121 if (nextNominalTime.after(coordJob.getEndTime())) {
122 nextNominalTime = null;
123 }
124 return nextNominalTime;
125 }
126
127 @Override
128 protected Void execute() throws CommandException {
129 LOG.debug("[" + actionId + "]::ActionInputCheck:: Action is in WAITING state.");
130
131 // this action should only get processed if current time > nominal time;
132 // otherwise, requeue this action for delay execution;
133 Date nominalTime = coordAction.getNominalTime();
134 Date currentTime = new Date();
135 if (nominalTime.compareTo(currentTime) > 0) {
136 queue(new CoordActionInputCheckXCommand(coordAction.getId(), coordAction.getJobId()), Math.max((nominalTime.getTime() - currentTime
137 .getTime()), getCoordInputCheckRequeueInterval()));
138 updateCoordAction(coordAction, false);
139 LOG.info("[" + actionId
140 + "]::ActionInputCheck:: nominal Time is newer than current time, so requeue and wait. Current="
141 + DateUtils.formatDateOozieTZ(currentTime) + ", nominal=" + DateUtils.formatDateOozieTZ(nominalTime));
142
143 return null;
144 }
145
146 StringBuilder actionXml = new StringBuilder(coordAction.getActionXml());
147 boolean isChangeInDependency = false;
148 try {
149 Configuration actionConf = new XConfiguration(new StringReader(coordAction.getRunConf()));
150 Date now = new Date();
151 if (coordJob.getExecutionOrder().equals(CoordinatorJobBean.Execution.LAST_ONLY)) {
152 Date nextNominalTime = computeNextNominalTime();
153 if (nextNominalTime != null) {
154 // If the current time is after the next action's nominal time, then we've passed the window where this action
155 // should be started; so set it to SKIPPED
156 if (now.after(nextNominalTime)) {
157 LOG.info("LAST_ONLY execution: Preparing to skip action [{0}] because the current time [{1}] is later than "
158 + "the nominal time [{2}] of the next action]", coordAction.getId(),
159 DateUtils.formatDateOozieTZ(now), DateUtils.formatDateOozieTZ(nextNominalTime));
160 queue(new CoordActionSkipXCommand(coordAction, coordJob.getUser(), coordJob.getAppName()));
161 return null;
162 } else {
163 LOG.debug("LAST_ONLY execution: Not skipping action [{0}] because the current time [{1}] is earlier than "
164 + "the nominal time [{2}] of the next action]", coordAction.getId(),
165 DateUtils.formatDateOozieTZ(now), DateUtils.formatDateOozieTZ(nextNominalTime));
166 }
167 }
168 }
169 else if (coordJob.getExecutionOrder().equals(CoordinatorJobBean.Execution.NONE)) {
170 // If the current time is after the nominal time of this action plus some tolerance,
171 // then we've passed the window where this action
172 // should be started; so set it to SKIPPED
173 Calendar cal = Calendar.getInstance(DateUtils.getTimeZone(coordJob.getTimeZone()));
174 cal.setTime(nominalTime);
175 cal.add(Calendar.MINUTE, Services.get().getConf().getInt("oozie.coord.execution.none.tolerance", 1));
176 nominalTime = cal.getTime();
177 if (now.after(nominalTime)) {
178 LOG.info("NONE execution: Preparing to skip action [{0}] because the current time [{1}] is later than "
179 + "the nominal time [{2}] of the current action]", coordAction.getId(),
180 DateUtils.formatDateOozieTZ(now), DateUtils.formatDateOozieTZ(nominalTime));
181 queue(new CoordActionSkipXCommand(coordAction, coordJob.getUser(), coordJob.getAppName()));
182 return null;
183 } else {
184 LOG.debug("NONE execution: Not skipping action [{0}] because the current time [{1}] is earlier than "
185 + "the nominal time [{2}] of the current action]", coordAction.getId(),
186 DateUtils.formatDateOozieTZ(now), DateUtils.formatDateOozieTZ(coordAction.getNominalTime()));
187 }
188 }
189
190 StringBuilder existList = new StringBuilder();
191 StringBuilder nonExistList = new StringBuilder();
192 StringBuilder nonResolvedList = new StringBuilder();
193 String firstMissingDependency = "";
194 String missingDeps = coordAction.getMissingDependencies();
195 CoordCommandUtils.getResolvedList(missingDeps, nonExistList, nonResolvedList);
196
197 // For clarity regarding which is the missing dependency in synchronous order
198 // instead of printing entire list, some of which, may be available
199 if(nonExistList.length() > 0) {
200 firstMissingDependency = nonExistList.toString().split(CoordELFunctions.INSTANCE_SEPARATOR)[0];
201 }
202 LOG.info("[" + actionId + "]::CoordActionInputCheck:: Missing deps:" + firstMissingDependency + " "
203 + nonResolvedList.toString());
204 // Updating the list of data dependencies that are available and those that are yet not
205 boolean status = checkInput(actionXml, existList, nonExistList, actionConf);
206 String pushDeps = coordAction.getPushMissingDependencies();
207 // Resolve latest/future only when all current missingDependencies and
208 // pushMissingDependencies are met
209 if (status && nonResolvedList.length() > 0) {
210 status = (pushDeps == null || pushDeps.length() == 0) ? checkUnResolvedInput(actionXml, actionConf)
211 : false;
212 }
213 coordAction.setLastModifiedTime(currentTime);
214 coordAction.setActionXml(actionXml.toString());
215 if (nonResolvedList.length() > 0 && status == false) {
216 nonExistList.append(CoordCommandUtils.RESOLVED_UNRESOLVED_SEPARATOR).append(nonResolvedList);
217 }
218 String nonExistListStr = nonExistList.toString();
219 if (!nonExistListStr.equals(missingDeps) || missingDeps.isEmpty()) {
220 // missingDeps null or empty means action should become READY
221 isChangeInDependency = true;
222 coordAction.setMissingDependencies(nonExistListStr);
223 }
224 if (status && (pushDeps == null || pushDeps.length() == 0)) {
225 String newActionXml = resolveCoordConfiguration(actionXml, actionConf, actionId);
226 actionXml.replace(0, actionXml.length(), newActionXml);
227 coordAction.setActionXml(actionXml.toString());
228 coordAction.setStatus(CoordinatorAction.Status.READY);
229 updateCoordAction(coordAction, true);
230 new CoordActionReadyXCommand(coordAction.getJobId()).call(getEntityKey());
231 }
232 else if (!isTimeout(currentTime)) {
233 if (status == false) {
234 queue(new CoordActionInputCheckXCommand(coordAction.getId(), coordAction.getJobId()),
235 getCoordInputCheckRequeueInterval());
236 }
237 updateCoordAction(coordAction, isChangeInDependency);
238 }
239 else {
240 if (!nonExistListStr.isEmpty() && pushDeps == null || pushDeps.length() == 0) {
241 queue(new CoordActionTimeOutXCommand(coordAction, coordJob.getUser(), coordJob.getAppName()));
242 }
243 else {
244 // Let CoordPushDependencyCheckXCommand queue the timeout
245 queue(new CoordPushDependencyCheckXCommand(coordAction.getId()));
246 }
247 updateCoordAction(coordAction, isChangeInDependency);
248 }
249 }
250 catch (Exception e) {
251 if (isTimeout(currentTime)) {
252 LOG.debug("Queueing timeout command");
253 // XCommand.queue() will not work when there is a Exception
254 Services.get().get(CallableQueueService.class)
255 .queue(new CoordActionTimeOutXCommand(coordAction, coordJob.getUser(), coordJob.getAppName()));
256 }
257 updateCoordAction(coordAction, isChangeInDependency);
258 throw new CommandException(ErrorCode.E1021, e.getMessage(), e);
259 }
260 return null;
261 }
262
263
264 static String resolveCoordConfiguration(StringBuilder actionXml, Configuration actionConf, String actionId) throws Exception {
265 Element eAction = XmlUtils.parseXml(actionXml.toString());
266 ELEvaluator eval = CoordELEvaluator.createDataEvaluator(eAction, actionConf, actionId);
267 materializeDataProperties(eAction, actionConf, eval);
268 return XmlUtils.prettyPrint(eAction).toString();
269 }
270
271 private boolean isTimeout(Date currentTime) {
272 long waitingTime = (currentTime.getTime() - Math.max(coordAction.getNominalTime().getTime(), coordAction
273 .getCreatedTime().getTime()))
274 / (60 * 1000);
275 int timeOut = coordAction.getTimeOut();
276 return (timeOut >= 0) && (waitingTime > timeOut);
277 }
278
279 private void updateCoordAction(CoordinatorActionBean coordAction, boolean isChangeInDependency)
280 throws CommandException {
281 coordAction.setLastModifiedTime(new Date());
282 if (jpaService != null) {
283 try {
284 if (isChangeInDependency) {
285 CoordActionQueryExecutor.getInstance().executeUpdate(
286 CoordActionQuery.UPDATE_COORD_ACTION_FOR_INPUTCHECK, coordAction);
287 if (EventHandlerService.isEnabled() && coordAction.getStatus() != CoordinatorAction.Status.READY) {
288 // since event is not to be generated unless action
289 // RUNNING via StartX
290 generateEvent(coordAction, coordJob.getUser(), coordJob.getAppName(), null);
291 }
292 }
293 else {
294 CoordActionQueryExecutor.getInstance().executeUpdate(
295 CoordActionQuery.UPDATE_COORD_ACTION_FOR_MODIFIED_DATE, coordAction);
296 }
297 }
298 catch (JPAExecutorException jex) {
299 throw new CommandException(ErrorCode.E1021, jex.getMessage(), jex);
300 }
301 }
302 }
303
304 /**
305 * This function reads the value of re-queue interval for coordinator input
306 * check command from the Oozie configuration provided by Configuration
307 * Service. If nothing defined in the configuration, it uses the code
308 * specified default value.
309 *
310 * @return re-queue interval in ms
311 */
312 public long getCoordInputCheckRequeueInterval() {
313 long requeueInterval = Services.get().getConf().getLong(CONF_COORD_INPUT_CHECK_REQUEUE_INTERVAL,
314 DEFAULT_COMMAND_REQUEUE_INTERVAL);
315 return requeueInterval;
316 }
317
318 /**
319 * To check the list of input paths if all of them exist
320 *
321 * @param actionXml action xml
322 * @param existList the list of existed paths
323 * @param nonExistList the list of non existed paths
324 * @param conf action configuration
325 * @return true if all input paths are existed
326 * @throws Exception thrown of unable to check input path
327 */
328 protected boolean checkInput(StringBuilder actionXml, StringBuilder existList, StringBuilder nonExistList,
329 Configuration conf) throws Exception {
330 Element eAction = XmlUtils.parseXml(actionXml.toString());
331 return checkResolvedUris(eAction, existList, nonExistList, conf);
332 }
333
334 protected boolean checkUnResolvedInput(StringBuilder actionXml, Configuration conf) throws Exception {
335 Element eAction = XmlUtils.parseXml(actionXml.toString());
336 LOG.debug("[" + actionId + "]::ActionInputCheck:: Checking Latest/future");
337 boolean allExist = checkUnresolvedInstances(eAction, conf);
338 if (allExist) {
339 actionXml.replace(0, actionXml.length(), XmlUtils.prettyPrint(eAction).toString());
340 }
341 return allExist;
342 }
343
344 /**
345 * Materialize data properties defined in <action> tag. it includes dataIn(<DS>) and dataOut(<DS>) it creates a list
346 * of files that will be needed.
347 *
348 * @param eAction action element
349 * @param conf action configuration
350 * @throws Exception thrown if failed to resolve data properties
351 * @update modify 'Action' element with appropriate list of files.
352 */
353 @SuppressWarnings("unchecked")
354 static void materializeDataProperties(Element eAction, Configuration conf, ELEvaluator eval) throws Exception {
355 Element configElem = eAction.getChild("action", eAction.getNamespace()).getChild("workflow",
356 eAction.getNamespace()).getChild("configuration", eAction.getNamespace());
357 if (configElem != null) {
358 for (Element propElem : (List<Element>) configElem.getChildren("property", configElem.getNamespace())) {
359 resolveTagContents("value", propElem, eval);
360 }
361 }
362 }
363
364 /**
365 * To resolve property value which contains el functions
366 *
367 * @param tagName tag name
368 * @param elem the child element of "property" element
369 * @param eval el functions evaluator
370 * @throws Exception thrown if unable to resolve tag value
371 */
372 private static void resolveTagContents(String tagName, Element elem, ELEvaluator eval) throws Exception {
373 if (elem == null) {
374 return;
375 }
376 Element tagElem = elem.getChild(tagName, elem.getNamespace());
377 if (tagElem != null) {
378 String updated = CoordELFunctions.evalAndWrap(eval, tagElem.getText());
379 tagElem.removeContent();
380 tagElem.addContent(updated);
381 }
382 else {
383 XLog.getLog(CoordActionInputCheckXCommand.class).warn(" Value NOT FOUND " + tagName);
384 }
385 }
386
387 /**
388 * Check if any unsolved paths under data output. Resolve the unresolved data input paths.
389 *
390 * @param eAction action element
391 * @param actionConf action configuration
392 * @return true if successful to resolve input and output paths
393 * @throws Exception thrown if failed to resolve data input and output paths
394 */
395 @SuppressWarnings("unchecked")
396 private boolean checkUnresolvedInstances(Element eAction, Configuration actionConf) throws Exception {
397 String strAction = XmlUtils.prettyPrint(eAction).toString();
398 Date nominalTime = DateUtils.parseDateOozieTZ(eAction.getAttributeValue("action-nominal-time"));
399 String actualTimeStr = eAction.getAttributeValue("action-actual-time");
400 Date actualTime = null;
401 if (actualTimeStr == null) {
402 LOG.debug("Unable to get action-actual-time from action xml, this job is submitted " +
403 "from previous version. Assign current date to actual time, action = " + actionId);
404 actualTime = new Date();
405 } else {
406 actualTime = DateUtils.parseDateOozieTZ(actualTimeStr);
407 }
408
409 StringBuffer resultedXml = new StringBuffer();
410
411 boolean ret;
412 Element inputList = eAction.getChild("input-events", eAction.getNamespace());
413 if (inputList != null) {
414 ret = materializeUnresolvedEvent(inputList.getChildren("data-in", eAction.getNamespace()), nominalTime,
415 actualTime, actionConf);
416 if (ret == false) {
417 resultedXml.append(strAction);
418 return false;
419 }
420 }
421
422 // Using latest() or future() in output-event is not intuitive.
423 // We need to make sure, this assumption is correct.
424 Element outputList = eAction.getChild("output-events", eAction.getNamespace());
425 if (outputList != null) {
426 for (Element dEvent : (List<Element>) outputList.getChildren("data-out", eAction.getNamespace())) {
427 if (dEvent.getChild(CoordCommandUtils.UNRESOLVED_INST_TAG, dEvent.getNamespace()) != null) {
428 throw new CommandException(ErrorCode.E1006, "coord:latest()/future()",
429 " not permitted in output-event ");
430 }
431 }
432 }
433 return true;
434 }
435
436 /**
437 * Resolve the list of data input paths
438 *
439 * @param eDataEvents the list of data input elements
440 * @param nominalTime action nominal time
441 * @param actualTime current time
442 * @param conf action configuration
443 * @return true if all unresolved URIs can be resolved
444 * @throws Exception thrown if failed to resolve data input paths
445 */
446 @SuppressWarnings("unchecked")
447 private boolean materializeUnresolvedEvent(List<Element> eDataEvents, Date nominalTime, Date actualTime,
448 Configuration conf) throws Exception {
449 for (Element dEvent : eDataEvents) {
450 if (dEvent.getChild(CoordCommandUtils.UNRESOLVED_INST_TAG, dEvent.getNamespace()) == null) {
451 continue;
452 }
453 ELEvaluator eval = CoordELEvaluator.createLazyEvaluator(actualTime, nominalTime, dEvent, conf);
454 String uresolvedInstance = dEvent.getChild(CoordCommandUtils.UNRESOLVED_INST_TAG, dEvent.getNamespace()).getTextTrim();
455 String unresolvedList[] = uresolvedInstance.split(CoordELFunctions.INSTANCE_SEPARATOR);
456 StringBuffer resolvedTmp = new StringBuffer();
457 for (int i = 0; i < unresolvedList.length; i++) {
458 String ret = CoordELFunctions.evalAndWrap(eval, unresolvedList[i]);
459 Boolean isResolved = (Boolean) eval.getVariable("is_resolved");
460 if (isResolved == false) {
461 LOG.info("[" + actionId + "]::Cannot resolve: " + ret);
462 return false;
463 }
464 if (resolvedTmp.length() > 0) {
465 resolvedTmp.append(CoordELFunctions.INSTANCE_SEPARATOR);
466 }
467 resolvedTmp.append((String) eval.getVariable("resolved_path"));
468 }
469 if (resolvedTmp.length() > 0) {
470 if (dEvent.getChild("uris", dEvent.getNamespace()) != null) {
471 resolvedTmp.append(CoordELFunctions.INSTANCE_SEPARATOR).append(
472 dEvent.getChild("uris", dEvent.getNamespace()).getTextTrim());
473 dEvent.removeChild("uris", dEvent.getNamespace());
474 }
475 Element uriInstance = new Element("uris", dEvent.getNamespace());
476 uriInstance.addContent(resolvedTmp.toString());
477 dEvent.getContent().add(1, uriInstance);
478 }
479 dEvent.removeChild(CoordCommandUtils.UNRESOLVED_INST_TAG, dEvent.getNamespace());
480 }
481
482 return true;
483 }
484
485 /**
486 * Check all resolved URIs existence
487 *
488 * @param eAction action element
489 * @param existList the list of existed paths
490 * @param nonExistList the list of paths to check existence
491 * @param conf action configuration
492 * @return true if all nonExistList paths exist
493 * @throws IOException thrown if unable to access the path
494 */
495 private boolean checkResolvedUris(Element eAction, StringBuilder existList, StringBuilder nonExistList,
496 Configuration conf) throws IOException {
497 Element inputList = eAction.getChild("input-events", eAction.getNamespace());
498 if (inputList != null) {
499 if (nonExistList.length() > 0) {
500 checkListOfPaths(existList, nonExistList, conf);
501 }
502 return nonExistList.length() == 0;
503 }
504 return true;
505 }
506
507 /**
508 * Check a list of non existed paths and add to exist list if it exists
509 *
510 * @param existList the list of existed paths
511 * @param nonExistList the list of paths to check existence
512 * @param conf action configuration
513 * @return true if all nonExistList paths exist
514 * @throws IOException thrown if unable to access the path
515 */
516 private boolean checkListOfPaths(StringBuilder existList, StringBuilder nonExistList, Configuration conf)
517 throws IOException {
518
519 String[] uriList = nonExistList.toString().split(CoordELFunctions.INSTANCE_SEPARATOR);
520 if (uriList[0] != null) {
521 LOG.info("[" + actionId + "]::ActionInputCheck:: In checkListOfPaths: " + uriList[0] + " is Missing.");
522 }
523
524 nonExistList.delete(0, nonExistList.length());
525 boolean allExists = true;
526 String existSeparator = "", nonExistSeparator = "";
527 String user = ParamChecker.notEmpty(conf.get(OozieClient.USER_NAME), OozieClient.USER_NAME);
528 for (int i = 0; i < uriList.length; i++) {
529 if (allExists) {
530 allExists = pathExists(uriList[i], conf, user);
531 LOG.info("[" + actionId + "]::ActionInputCheck:: File:" + uriList[i] + ", Exists? :" + allExists);
532 }
533 if (allExists) {
534 existList.append(existSeparator).append(uriList[i]);
535 existSeparator = CoordELFunctions.INSTANCE_SEPARATOR;
536 }
537 else {
538 nonExistList.append(nonExistSeparator).append(uriList[i]);
539 nonExistSeparator = CoordELFunctions.INSTANCE_SEPARATOR;
540 }
541 }
542 return allExists;
543 }
544
545 /**
546 * Check if given path exists
547 *
548 * @param sPath uri path
549 * @param actionConf action configuration
550 * @return true if path exists
551 * @throws IOException thrown if unable to access the path
552 */
553 protected boolean pathExists(String sPath, Configuration actionConf, String user) throws IOException {
554 LOG.debug("checking for the file " + sPath);
555 try {
556 URI uri = new URI(sPath);
557 URIHandlerService service = Services.get().get(URIHandlerService.class);
558 URIHandler handler = service.getURIHandler(uri);
559 return handler.exists(uri, actionConf, user);
560 }
561 catch (URIHandlerException e) {
562 coordAction.setErrorCode(e.getErrorCode().toString());
563 coordAction.setErrorMessage(e.getMessage());
564 throw new IOException(e);
565 } catch (URISyntaxException e) {
566 coordAction.setErrorCode(ErrorCode.E0906.toString());
567 coordAction.setErrorMessage(e.getMessage());
568 throw new IOException(e);
569 }
570 }
571
572 /**
573 * The function create a list of URIs separated by "," using the instances time stamp and URI-template
574 *
575 * @param event : <data-in> event
576 * @param instances : List of time stamp seprated by ","
577 * @param unresolvedInstances : list of instance with latest/future function
578 * @return : list of URIs separated by ",".
579 * @throws Exception thrown if failed to create URIs from unresolvedInstances
580 */
581 @SuppressWarnings("unused")
582 private String createURIs(Element event, String instances, StringBuilder unresolvedInstances) throws Exception {
583 if (instances == null || instances.length() == 0) {
584 return "";
585 }
586 String[] instanceList = instances.split(CoordELFunctions.INSTANCE_SEPARATOR);
587 StringBuilder uris = new StringBuilder();
588
589 for (int i = 0; i < instanceList.length; i++) {
590 int funcType = CoordCommandUtils.getFuncType(instanceList[i]);
591 if (funcType == CoordCommandUtils.LATEST || funcType == CoordCommandUtils.FUTURE) {
592 if (unresolvedInstances.length() > 0) {
593 unresolvedInstances.append(CoordELFunctions.INSTANCE_SEPARATOR);
594 }
595 unresolvedInstances.append(instanceList[i]);
596 continue;
597 }
598 ELEvaluator eval = CoordELEvaluator.createURIELEvaluator(instanceList[i]);
599 if (uris.length() > 0) {
600 uris.append(CoordELFunctions.INSTANCE_SEPARATOR);
601 }
602 uris.append(CoordELFunctions.evalAndWrap(eval, event.getChild("dataset", event.getNamespace()).getChild(
603 "uri-template", event.getNamespace()).getTextTrim()));
604 }
605 return uris.toString();
606 }
607
608 /**
609 * getting the error code of the coord action. (used mainly for unit testing)
610 */
611 protected String getCoordActionErrorCode() {
612 if (coordAction != null) {
613 return coordAction.getErrorCode();
614 }
615 return null;
616 }
617
618 /**
619 * getting the error message of the coord action. (used mainly for unit testing)
620 */
621 protected String getCoordActionErrorMsg() {
622 if (coordAction != null) {
623 return coordAction.getErrorMessage();
624 }
625 return null;
626 }
627
628 @Override
629 public String getEntityKey() {
630 return this.jobId;
631 }
632
633 @Override
634 protected boolean isLockRequired() {
635 return true;
636 }
637
638 @Override
639 protected void loadState() throws CommandException {
640 if (jpaService == null) {
641 jpaService = Services.get().get(JPAService.class);
642 }
643 try {
644 coordAction = jpaService.execute(new CoordActionGetForInputCheckJPAExecutor(actionId));
645 coordJob = CoordJobQueryExecutor.getInstance().get(CoordJobQuery.GET_COORD_JOB_INPUT_CHECK,
646 coordAction.getJobId());
647 }
648 catch (JPAExecutorException je) {
649 throw new CommandException(je);
650 }
651 LogUtils.setLogInfo(coordAction, logInfo);
652 }
653
654 @Override
655 protected void verifyPrecondition() throws CommandException, PreconditionException {
656 if (coordAction.getStatus() != CoordinatorActionBean.Status.WAITING) {
657 throw new PreconditionException(ErrorCode.E1100, "[" + actionId
658 + "]::CoordActionInputCheck:: Ignoring action. Should be in WAITING state, but state="
659 + coordAction.getStatus());
660 }
661
662 // if eligible to do action input check when running with backward support is true
663 if (StatusUtils.getStatusForCoordActionInputCheck(coordJob)) {
664 return;
665 }
666
667 if (coordJob.getStatus() != Job.Status.RUNNING && coordJob.getStatus() != Job.Status.RUNNINGWITHERROR && coordJob.getStatus() != Job.Status.PAUSED
668 && coordJob.getStatus() != Job.Status.PAUSEDWITHERROR) {
669 throw new PreconditionException(
670 ErrorCode.E1100, "["+ actionId + "]::CoordActionInputCheck:: Ignoring action." +
671 " Coordinator job is not in RUNNING/RUNNINGWITHERROR/PAUSED/PAUSEDWITHERROR state, but state="
672 + coordJob.getStatus());
673 }
674 }
675
676 @Override
677 public String getKey(){
678 return getName() + "_" + actionId;
679 }
680
681 }