@SuppressWarnings("deprecation") protected void beforeStart(Map flags, Task<?> task) { activeTaskCount.incrementAndGet(); // set thread _before_ start time, so we won't get a null thread when there is a start-time if (log.isTraceEnabled()) log.trace("" + this + " beforeStart, task: " + task); if (!task.isCancelled()) { ((BasicTask) task).thread = Thread.currentThread(); if (RENAME_THREADS) { String newThreadName = "brooklyn-" + CaseFormat.LOWER_HYPHEN.to( CaseFormat.LOWER_CAMEL, task.getDisplayName().replace(" ", "")) + "-" + task.getId().substring(0, 8); ((BasicTask) task).thread.setName(newThreadName); } PerThreadCurrentTaskHolder.perThreadCurrentTask.set(task); ((BasicTask) task).startTimeUtc = System.currentTimeMillis(); } for (Object to : (Collection) flags.get("tagLinkedPreprocessors")) { TaskPreprocessor t = (TaskPreprocessor) to; t.onStart(flags, task); } ExecutionUtils.invoke(flags.get("newTaskStartCallback"), task); }
protected boolean deleteTaskNonRecursive(Task<?> task) { Set<?> tags = checkNotNull(task, "task").getTags(); for (Object tag : tags) { Set<Task<?>> tasks = getMutableTasksWithTagOrNull(tag); if (tasks != null) tasks.remove(task); } Task<?> removed = tasksById.remove(task.getId()); return removed != null; }
protected void beforeStart(Map<?, ?> flags, Task<?> task) { activeTaskCount.incrementAndGet(); // set thread _before_ start time, so we won't get a null thread when there is a start-time if (log.isTraceEnabled()) log.trace("" + this + " beforeStart, task: " + task); if (!task.isCancelled()) { ((TaskInternal<?>) task).setThread(Thread.currentThread()); if (RENAME_THREADS) { String newThreadName = "brooklyn-" + CaseFormat.LOWER_HYPHEN.to( CaseFormat.LOWER_CAMEL, task.getDisplayName().replace(" ", "")) + "-" + task.getId().substring(0, 8); task.getThread().setName(newThreadName); } PerThreadCurrentTaskHolder.perThreadCurrentTask.set(task); ((TaskInternal<?>) task).setStartTimeUtc(System.currentTimeMillis()); } ExecutionUtils.invoke(flags.get("newTaskStartCallback"), task); }
@SuppressWarnings("unchecked") protected <T> Task<T> submitNewTask(final Map<?, ?> flags, final Task<T> task) { if (task instanceof ScheduledTask) return (Task<T>) submitNewScheduledTask(flags, (ScheduledTask) task); tasksById.put(task.getId(), task); totalTaskCount.incrementAndGet(); beforeSubmit(flags, task); if (((TaskInternal<T>) task).getJob() == null) throw new NullPointerException( "Task " + task + " submitted with with null job: job must be supplied."); Callable<T> job = new Callable<T>() { public T call() { try { T result = null; Throwable error = null; String oldThreadName = Thread.currentThread().getName(); try { if (RENAME_THREADS) { String newThreadName = oldThreadName + "-" + task.getDisplayName() + "[" + task.getId().substring(0, 8) + "]"; Thread.currentThread().setName(newThreadName); } beforeStart(flags, task); if (!task.isCancelled()) { result = ((TaskInternal<T>) task).getJob().call(); } else throw new CancellationException(); } catch (Throwable e) { error = e; } finally { if (RENAME_THREADS) { Thread.currentThread().setName(oldThreadName); } afterEnd(flags, task); } if (error != null) { if (log.isDebugEnabled()) { // debug only here, because we rethrow log.debug( "Exception running task " + task + " (rethrowing): " + error.getMessage(), error); if (log.isTraceEnabled()) log.trace( "Trace for exception running task " + task + " (rethrowing): " + error.getMessage(), error); } throw Exceptions.propagate(error); } return result; } finally { ((TaskInternal<?>) task).runListeners(); } } }; // If there's a scheduler then use that; otherwise execute it directly Set<TaskScheduler> schedulers = null; for (Object tago : task.getTags()) { TaskScheduler scheduler = getTaskSchedulerForTag(tago); if (scheduler != null) { if (schedulers == null) schedulers = new LinkedHashSet<TaskScheduler>(2); schedulers.add(scheduler); } } Future<T> future; if (schedulers != null && !schedulers.isEmpty()) { if (schedulers.size() > 1) log.warn( "multiple schedulers detected, using only the first, for " + task + ": " + schedulers); future = schedulers.iterator().next().submit(job); } else { future = runner.submit(job); } // on completion, listeners get triggered above; here, below we ensure they get triggered on // cancel // (and we make sure the same ExecutionList is used in the future as in the task) ListenableFuture<T> listenableFuture = new ListenableForwardingFuture<T>(future, ((TaskInternal<T>) task).getListeners()) { @Override public boolean cancel(boolean mayInterruptIfRunning) { boolean result = false; if (!task.isCancelled()) result |= task.cancel(mayInterruptIfRunning); result |= super.cancel(mayInterruptIfRunning); ((TaskInternal<?>) task).runListeners(); return result; } }; ((TaskInternal<T>) task).initResult(listenableFuture); return task; }