@Inject public TriggerManager(final Props props, final TriggerLoader triggerLoader, final ExecutorManagerAdapter executorManagerAdapter) throws TriggerManagerException { requireNonNull(props); requireNonNull(executorManagerAdapter); this.triggerLoader = requireNonNull(triggerLoader); final long scannerInterval = props.getLong("trigger.scan.interval", DEFAULT_SCANNER_INTERVAL_MS); this.runnerThread = new TriggerScannerThread(scannerInterval); this.checkerTypeLoader = new CheckerTypeLoader(); this.actionTypeLoader = new ActionTypeLoader(); try { this.checkerTypeLoader.init(props); this.actionTypeLoader.init(props); } catch (final Exception e) { throw new TriggerManagerException(e); } Condition.setCheckerLoader(this.checkerTypeLoader); Trigger.setActionTypeLoader(this.actionTypeLoader); logger.info("TriggerManager loaded."); }
@Override public void start() throws TriggerManagerException { try { // expect loader to return valid triggers final List<Trigger> triggers = this.triggerLoader.loadTriggers(); for (final Trigger t : triggers) { this.runnerThread.addTrigger(t); triggerIdMap.put(t.getTriggerId(), t); } } catch (final Exception e) { logger.error(e); throw new TriggerManagerException(e); } this.runnerThread.start(); }
checkAllTriggers(); } catch (final Exception e) { e.printStackTrace(); logger.error("Trigger manager thread " + this.getName() + " is too busy!"); } else {
if(t.getStatus().equals(TriggerStatus.READY)) { if(t.triggerConditionMet()) { onTriggerTrigger(t); } else if (t.expireConditionMet()) { onTriggerExpire(t);
checkAllTriggers(); } catch (final Exception e) { e.printStackTrace(); logger.error("Trigger manager thread " + this.getName() + " is too busy!"); } else {
private void checkAllTriggers() throws TriggerManagerException { // sweep through the rest of them for (final Trigger t : this.triggers) { try { TriggerManager.this.scannerStage = "Checking for trigger " + t.getTriggerId(); if (t.getStatus().equals(TriggerStatus.READY)) { /** * Prior to this change, expiration condition should never be called though * we have some related code here. ExpireCondition used the same BasicTimeChecker * as triggerCondition do. As a consequence, we need to figure out a way to distinguish * the previous ExpireCondition and this commit's ExpireCondition. */ if (t.getExpireCondition().getExpression().contains("EndTimeChecker") && t .expireConditionMet()) { onTriggerPause(t); } else if (t.triggerConditionMet()) { onTriggerTrigger(t); } } if (t.getStatus().equals(TriggerStatus.EXPIRED) && t.getSource().equals("azkaban")) { removeTrigger(t); } else { t.updateNextCheckTime(); } } catch (final Throwable th) { //skip this trigger, moving on to the next one logger.error("Failed to process trigger with id : " + t, th); } } }
checkAllTriggers(); justFinishedFlows.clear(); } catch(Exception e) { logger.error("Trigger manager thread " + this.getName() + " is too busy!"); } else { syncObj.wait(runnerThreadIdleTime);
@Inject public TriggerManager(final Props props, final TriggerLoader triggerLoader, final ExecutorManager executorManager) throws TriggerManagerException { requireNonNull(props); requireNonNull(executorManager); this.triggerLoader = requireNonNull(triggerLoader); final long scannerInterval = props.getLong("trigger.scan.interval", DEFAULT_SCANNER_INTERVAL_MS); this.runnerThread = new TriggerScannerThread(scannerInterval); this.checkerTypeLoader = new CheckerTypeLoader(); this.actionTypeLoader = new ActionTypeLoader(); try { this.checkerTypeLoader.init(props); this.actionTypeLoader.init(props); } catch (final Exception e) { throw new TriggerManagerException(e); } Condition.setCheckerLoader(this.checkerTypeLoader); Trigger.setActionTypeLoader(this.actionTypeLoader); logger.info("TriggerManager loaded."); }
@Override public void start() throws TriggerManagerException{ try { // expect loader to return valid triggers List<Trigger> triggers = triggerLoader.loadTriggers(); for(Trigger t : triggers) { runnerThread.addTrigger(t); triggerIdMap.put(t.getTriggerId(), t); } }catch(Exception e) { e.printStackTrace(); throw new TriggerManagerException(e); } runnerThread.start(); }
public TriggerManager(Props props, TriggerLoader triggerLoader, ExecutorManager executorManager) throws TriggerManagerException { this.triggerLoader = triggerLoader; long scannerInterval = props.getLong("trigger.scan.interval", DEFAULT_SCANNER_INTERVAL_MS); runnerThread = new TriggerScannerThread(scannerInterval); checkerTypeLoader = new CheckerTypeLoader(); actionTypeLoader = new ActionTypeLoader(); try { checkerTypeLoader.init(props); actionTypeLoader.init(props); } catch (Exception e) { throw new TriggerManagerException(e); } Condition.setCheckerLoader(checkerTypeLoader); Trigger.setActionTypeLoader(actionTypeLoader); executorManager.addListener(listener); logger.info("TriggerManager loaded."); }
@Override public void start() throws TriggerManagerException { try { // expect loader to return valid triggers final List<Trigger> triggers = this.triggerLoader.loadTriggers(); for (final Trigger t : triggers) { this.runnerThread.addTrigger(t); triggerIdMap.put(t.getTriggerId(), t); } } catch (final Exception e) { logger.error(e); throw new TriggerManagerException(e); } this.runnerThread.start(); }
@Override public boolean isRunnerThreadActive() { return TriggerManager.this.runnerThread.isAlive(); }
@Override public void shutdown() { this.runnerThread.shutdown(); }
public void removeTrigger(final Trigger t) throws TriggerManagerException { logger.info("Removing trigger " + t + " from TriggerManager"); synchronized (this.syncObj) { this.runnerThread.deleteTrigger(t); triggerIdMap.remove(t.getTriggerId()); try { t.stopCheckers(); this.triggerLoader.removeTrigger(t); } catch (final TriggerLoaderException e) { throw new TriggerManagerException(e); } } }
public void updateTrigger(final Trigger t) throws TriggerManagerException { logger.info("Updating trigger " + t + " in TriggerManager"); synchronized (this.syncObj) { this.runnerThread.deleteTrigger(triggerIdMap.get(t.getTriggerId())); this.runnerThread.addTrigger(t); triggerIdMap.put(t.getTriggerId(), t); try { this.triggerLoader.updateTrigger(t); } catch (final TriggerLoaderException e) { throw new TriggerManagerException(e); } } }
@Override public boolean isRunnerThreadActive() { // TODO Auto-generated method stub return runnerThread.isAlive(); }
public void insertTrigger(Trigger t) throws TriggerManagerException { synchronized (syncObj) { try { triggerLoader.addTrigger(t); } catch (TriggerLoaderException e) { throw new TriggerManagerException(e); } runnerThread.addTrigger(t); triggerIdMap.put(t.getTriggerId(), t); } }
public TriggerScannerThread(long scannerInterval) { triggers = new PriorityBlockingQueue<Trigger>(1, new TriggerComparator()); justFinishedFlows = new ConcurrentHashMap<Integer, ExecutableFlow>(); this.setName("TriggerRunnerManager-Trigger-Scanner-Thread"); this.scannerInterval = scannerInterval; }
public void removeTrigger(Trigger t) throws TriggerManagerException { synchronized (syncObj) { runnerThread.deleteTrigger(t); triggerIdMap.remove(t.getTriggerId()); try { t.stopCheckers(); triggerLoader.removeTrigger(t); } catch (TriggerLoaderException e) { throw new TriggerManagerException(e); } } }
public void updateTrigger(Trigger t) throws TriggerManagerException { synchronized (syncObj) { runnerThread.deleteTrigger(triggerIdMap.get(t.getTriggerId())); runnerThread.addTrigger(t); triggerIdMap.put(t.getTriggerId(), t); } }