Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.brooklyn.util.core.task; import static com.google.common.base.Preconditions.checkNotNull; import groovy.lang.Closure; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.Callable; import java.util.concurrent.CancellationException; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.ExecutorService; import java.util.concurrent.Future; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.SynchronousQueue; import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; import org.apache.brooklyn.api.mgmt.ExecutionManager; import org.apache.brooklyn.api.mgmt.HasTaskChildren; import org.apache.brooklyn.api.mgmt.Task; import org.apache.brooklyn.api.mgmt.TaskAdaptable; import org.apache.brooklyn.core.BrooklynFeatureEnablement; import org.apache.brooklyn.core.config.Sanitizer; import org.apache.brooklyn.core.mgmt.BrooklynTaskTags; import org.apache.brooklyn.util.collections.MutableList; import org.apache.brooklyn.util.core.task.TaskInternal.TaskCancellationMode; import org.apache.brooklyn.util.exceptions.Exceptions; import org.apache.brooklyn.util.exceptions.RuntimeInterruptedException; import org.apache.brooklyn.util.text.Identifiers; import org.apache.brooklyn.util.text.Strings; import org.apache.brooklyn.util.time.CountdownTimer; import org.apache.brooklyn.util.time.Duration; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.annotations.Beta; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.CaseFormat; import com.google.common.base.Function; import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import com.google.common.collect.Sets; import com.google.common.util.concurrent.ExecutionList; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.ThreadFactoryBuilder; /** * Manages the execution of atomic tasks and scheduled (recurring) tasks, * including setting tags and invoking callbacks. */ public class BasicExecutionManager implements ExecutionManager { private static final Logger log = LoggerFactory.getLogger(BasicExecutionManager.class); private static final boolean RENAME_THREADS = BrooklynFeatureEnablement .isEnabled(BrooklynFeatureEnablement.FEATURE_RENAME_THREADS); private static class PerThreadCurrentTaskHolder { public static final ThreadLocal<Task<?>> perThreadCurrentTask = new ThreadLocal<Task<?>>(); } public static ThreadLocal<Task<?>> getPerThreadCurrentTask() { return PerThreadCurrentTaskHolder.perThreadCurrentTask; } private final ThreadFactory threadFactory; private final ThreadFactory daemonThreadFactory; private final ExecutorService runner; private final ScheduledExecutorService delayedRunner; // TODO Could have a set of all knownTasks; but instead we're having a separate set per tag, // so the same task could be listed multiple times if it has multiple tags... //access to this field AND to members in this field is synchronized, //to allow us to preserve order while guaranteeing thread-safe //(but more testing is needed before we are completely sure it is thread-safe!) //synch blocks are as finely grained as possible for efficiency; //NB CopyOnWriteArraySet is a perf bottleneck, and the simple map makes it easier to remove when a tag is empty private Map<Object, Set<Task<?>>> tasksByTag = new HashMap<Object, Set<Task<?>>>(); private ConcurrentMap<String, Task<?>> tasksById = new ConcurrentHashMap<String, Task<?>>(); private ConcurrentMap<Object, TaskScheduler> schedulerByTag = new ConcurrentHashMap<Object, TaskScheduler>(); /** count of all tasks submitted, including finished */ private final AtomicLong totalTaskCount = new AtomicLong(); /** tasks submitted but not yet done (or in cases of interruption/cancelled not yet GC'd) */ private Map<String, String> incompleteTaskIds = new ConcurrentHashMap<String, String>(); /** tasks started but not yet finished */ private final AtomicInteger activeTaskCount = new AtomicInteger(); private final List<ExecutionListener> listeners = new CopyOnWriteArrayList<ExecutionListener>(); private final static ThreadLocal<String> threadOriginalName = new ThreadLocal<String>() { protected String initialValue() { // should not happen, as only access is in _afterEnd with a check that _beforeStart was invoked log.warn("No original name recorded for thread " + Thread.currentThread().getName() + "; task " + Tasks.current()); return "brooklyn-thread-pool-" + Identifiers.makeRandomId(8); } }; public BasicExecutionManager(String contextid) { threadFactory = newThreadFactory(contextid); daemonThreadFactory = new ThreadFactoryBuilder().setThreadFactory(threadFactory).setDaemon(true).build(); // use Executors.newCachedThreadPool(daemonThreadFactory), but timeout of 1s rather than 60s for better shutdown! runner = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 10L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), daemonThreadFactory); delayedRunner = new ScheduledThreadPoolExecutor(1, daemonThreadFactory); } private final static class UncaughtExceptionHandlerImplementation implements Thread.UncaughtExceptionHandler { @Override public void uncaughtException(Thread t, Throwable e) { log.error("Uncaught exception in thread " + t.getName(), e); } } /** * For use by overriders to use custom thread factory. * But be extremely careful: called by constructor, so before sub-class' constructor will * have been invoked! */ protected ThreadFactory newThreadFactory(String contextid) { return new ThreadFactoryBuilder().setNameFormat("brooklyn-execmanager-" + contextid + "-%d") .setUncaughtExceptionHandler(new UncaughtExceptionHandlerImplementation()).build(); } public void shutdownNow() { shutdownNow(null); } /** shuts down the executor, and if a duration is supplied awaits termination for that long. * @return whether everything is terminated */ @Beta public boolean shutdownNow(Duration howLongToWaitForTermination) { runner.shutdownNow(); delayedRunner.shutdownNow(); if (howLongToWaitForTermination != null) { CountdownTimer timer = howLongToWaitForTermination.countdownTimer(); try { runner.awaitTermination(timer.getDurationRemaining().toMilliseconds(), TimeUnit.MILLISECONDS); if (timer.isLive()) delayedRunner.awaitTermination(timer.getDurationRemaining().toMilliseconds(), TimeUnit.MILLISECONDS); } catch (InterruptedException e) { throw Exceptions.propagate(e); } } return runner.isTerminated() && delayedRunner.isTerminated(); } public void addListener(ExecutionListener listener) { listeners.add(listener); } public void removeListener(ExecutionListener listener) { listeners.remove(listener); } /** * Deletes the given tag, including all tasks using this tag. * * Useful, for example, if an entity is being expunged so that we don't keep holding * a reference to it as a tag. */ public void deleteTag(Object tag) { Set<Task<?>> tasks; synchronized (tasksByTag) { tasks = tasksByTag.remove(tag); } if (tasks != null) { for (Task<?> task : tasks) { deleteTask(task); } } } public void deleteTask(Task<?> task) { boolean removed = deleteTaskNonRecursive(task); if (!removed) return; if (task instanceof HasTaskChildren) { List<Task<?>> children = ImmutableList.copyOf(((HasTaskChildren) task).getChildren()); for (Task<?> child : children) { deleteTask(child); } } } protected boolean deleteTaskNonRecursive(Task<?> task) { Set<?> tags = checkNotNull(task, "task").getTags(); for (Object tag : tags) { synchronized (tasksByTag) { Set<Task<?>> tasks = tasksWithTagLiveOrNull(tag); if (tasks != null) { tasks.remove(task); if (tasks.isEmpty()) { tasksByTag.remove(tag); } } } } Task<?> removed = tasksById.remove(task.getId()); incompleteTaskIds.remove(task.getId()); if (removed != null && removed.isSubmitted() && !removed.isDone()) { log.warn("Deleting submitted task before completion: " + removed + "; this task will continue to run in the background outwith " + this + ", but perhaps it should have been cancelled?"); } return removed != null; } public boolean isShutdown() { return runner.isShutdown(); } /** count of all tasks submitted */ public long getTotalTasksSubmitted() { return totalTaskCount.get(); } /** count of tasks submitted but not ended */ public long getNumIncompleteTasks() { return incompleteTaskIds.size(); } /** count of tasks started but not ended */ public long getNumActiveTasks() { return activeTaskCount.get(); } /** count of tasks kept in memory, often including ended tasks */ public long getNumInMemoryTasks() { return tasksById.size(); } private Set<Task<?>> tasksWithTagCreating(Object tag) { Preconditions.checkNotNull(tag); synchronized (tasksByTag) { Set<Task<?>> result = tasksWithTagLiveOrNull(tag); if (result == null) { result = Collections.synchronizedSet(new LinkedHashSet<Task<?>>()); tasksByTag.put(tag, result); } return result; } } /** exposes live view, for internal use only */ @Beta public Set<Task<?>> tasksWithTagLiveOrNull(Object tag) { synchronized (tasksByTag) { return tasksByTag.get(tag); } } @Override public Task<?> getTask(String id) { return tasksById.get(id); } /** not on interface because potentially expensive */ public List<Task<?>> getAllTasks() { // not sure if synching makes any difference; have not observed CME's yet // (and so far this is only called when a CME was caught on a previous operation) synchronized (tasksById) { return MutableList.copyOf(tasksById.values()); } } @Override public Set<Task<?>> getTasksWithTag(Object tag) { Set<Task<?>> result = tasksWithTagLiveOrNull(tag); if (result == null) return Collections.emptySet(); synchronized (result) { return (Set<Task<?>>) Collections.unmodifiableSet(new LinkedHashSet<Task<?>>(result)); } } @Override public Set<Task<?>> getTasksWithAnyTag(Iterable<?> tags) { Set<Task<?>> result = new LinkedHashSet<Task<?>>(); Iterator<?> ti = tags.iterator(); while (ti.hasNext()) { Set<Task<?>> tasksForTag = tasksWithTagLiveOrNull(ti.next()); if (tasksForTag != null) { synchronized (tasksForTag) { result.addAll(tasksForTag); } } } return Collections.unmodifiableSet(result); } /** only works with at least one tag; returns empty if no tags */ @Override public Set<Task<?>> getTasksWithAllTags(Iterable<?> tags) { //NB: for this method retrieval for multiple tags could be made (much) more efficient (if/when it is used with multiple tags!) //by first looking for the least-used tag, getting those tasks, and then for each of those tasks //checking whether it contains the other tags (looking for second-least used, then third-least used, etc) Set<Task<?>> result = new LinkedHashSet<Task<?>>(); boolean first = true; Iterator<?> ti = tags.iterator(); while (ti.hasNext()) { Object tag = ti.next(); if (first) { first = false; result.addAll(getTasksWithTag(tag)); } else { result.retainAll(getTasksWithTag(tag)); } } return Collections.unmodifiableSet(result); } /** live view of all tasks, for internal use only */ @Beta public Collection<Task<?>> allTasksLive() { return tasksById.values(); } public Set<Object> getTaskTags() { synchronized (tasksByTag) { return Collections.unmodifiableSet(Sets.newLinkedHashSet(tasksByTag.keySet())); } } public Task<?> submit(Runnable r) { return submit(new LinkedHashMap<Object, Object>(1), r); } public Task<?> submit(Map<?, ?> flags, Runnable r) { return submit(flags, new BasicTask<Void>(flags, r)); } public <T> Task<T> submit(Callable<T> c) { return submit(new LinkedHashMap<Object, Object>(1), c); } public <T> Task<T> submit(Map<?, ?> flags, Callable<T> c) { return submit(flags, new BasicTask<T>(flags, c)); } public <T> Task<T> submit(TaskAdaptable<T> t) { return submit(new LinkedHashMap<Object, Object>(1), t); } public <T> Task<T> submit(Map<?, ?> flags, TaskAdaptable<T> task) { if (!(task instanceof Task)) task = task.asTask(); synchronized (task) { if (((TaskInternal<?>) task).getInternalFuture() != null) return (Task<T>) task; return submitNewTask(flags, (Task<T>) task); } } public <T> Task<T> scheduleWith(Task<T> task) { return scheduleWith(Collections.emptyMap(), task); } public <T> Task<T> scheduleWith(Map<?, ?> flags, Task<T> task) { synchronized (task) { if (((TaskInternal<?>) task).getInternalFuture() != null) return task; return submitNewTask(flags, task); } } protected Task<?> submitNewScheduledTask(final Map<?, ?> flags, final ScheduledTask task) { tasksById.put(task.getId(), task); totalTaskCount.incrementAndGet(); beforeSubmitScheduledTaskAllIterations(flags, task); return submitSubsequentScheduledTask(flags, task); } protected Task<?> submitSubsequentScheduledTask(final Map<?, ?> flags, final ScheduledTask task) { if (!task.isDone()) { task.internalFuture = delayedRunner.schedule(new ScheduledTaskCallable(task, flags), task.delay.toNanoseconds(), TimeUnit.NANOSECONDS); } else { afterEndScheduledTaskAllIterations(flags, task); } return task; } protected class ScheduledTaskCallable implements Callable<Object> { public ScheduledTask task; public Map<?, ?> flags; public ScheduledTaskCallable(ScheduledTask task, Map<?, ?> flags) { this.task = task; this.flags = flags; } @SuppressWarnings({ "rawtypes", "unchecked" }) public Object call() { if (task.startTimeUtc == -1) task.startTimeUtc = System.currentTimeMillis(); TaskInternal<?> taskScheduled = null; try { beforeStartScheduledTaskSubmissionIteration(flags, task); taskScheduled = (TaskInternal<?>) task.newTask(); taskScheduled.setSubmittedByTask(task); final Callable<?> oldJob = taskScheduled.getJob(); final TaskInternal<?> taskScheduledF = taskScheduled; taskScheduled.setJob(new Callable() { public Object call() { boolean shouldResubmit = true; task.recentRun = taskScheduledF; try { synchronized (task) { task.notifyAll(); } Object result; try { result = oldJob.call(); task.lastThrownType = null; } catch (Exception e) { shouldResubmit = shouldResubmitOnException(oldJob, e); throw Exceptions.propagate(e); } return result; } finally { // do in finally block in case we were interrupted if (shouldResubmit) { resubmit(); } else { afterEndScheduledTaskAllIterations(flags, task); } } } }); task.nextRun = taskScheduled; BasicExecutionContext ec = BasicExecutionContext.getCurrentExecutionContext(); if (ec != null) return ec.submit(taskScheduled); else return submit(taskScheduled); } finally { afterEndScheduledTaskSubmissionIteration(flags, task, taskScheduled); } } private void resubmit() { task.runCount++; if (task.period != null && !task.isCancelled()) { task.delay = task.period; submitSubsequentScheduledTask(flags, task); } } private boolean shouldResubmitOnException(Callable<?> oldJob, Exception e) { String message = "Error executing " + oldJob + " (scheduled job of " + task + " - " + task.getDescription() + ")"; if (Tasks.isInterrupted()) { log.debug(message + "; cancelling scheduled execution: " + e); return false; } else if (task.cancelOnException) { log.warn(message + "; cancelling scheduled execution.", e); return false; } else { message += "; resubmitting task and throwing: " + e; if (!e.getClass().equals(task.lastThrownType)) { task.lastThrownType = e.getClass(); message += " (logging subsequent exceptions at trace)"; log.debug(message); } else { message += " (repeat exception)"; log.trace(message); } return true; } } @Override public String toString() { return "ScheduledTaskCallable[" + task + "," + flags + "]"; } } private final class SubmissionCallable<T> implements Callable<T> { private final Map<?, ?> flags; private final Task<T> task; private SubmissionCallable(Map<?, ?> flags, Task<T> task) { this.flags = flags; this.task = task; } 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); } beforeStartAtomicTask(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); } afterEndAtomicTask(flags, task); } if (error != null) { /* we throw, after logging debug. * the throw means the error is available for task submitters to monitor. * however it is possible no one is monitoring it, in which case we will have debug logging only for errors. * (the alternative, of warn-level logging in lots of places where we don't want it, seems worse!) */ if (log.isDebugEnabled()) { // debug only here, because most submitters will handle failures if (error instanceof InterruptedException || error instanceof RuntimeInterruptedException) { log.debug("Detected interruption on task " + task + " (rethrowing)" + (Strings.isNonBlank(error.getMessage()) ? ": " + error.getMessage() : "")); } else { log.debug("Exception running task " + task + " (rethrowing): " + error); } if (log.isTraceEnabled()) { log.trace("Trace for exception running task " + task + " (rethrowing): " + error, error); } } throw Exceptions.propagate(error); } return result; } finally { ((TaskInternal<?>) task).runListeners(); } } @Override public String toString() { return "BEM.call(" + task + "," + flags + ")"; } } @SuppressWarnings("deprecation") // TODO do we even need a listenable future here? possibly if someone wants to interrogate the future it might // be interesting, so possibly it is useful that we implement ListenableFuture... private final static class CancellingListenableForwardingFutureForTask<T> extends ListenableForwardingFuture<T> { private final Task<T> task; private BasicExecutionManager execMgmt; private CancellingListenableForwardingFutureForTask(BasicExecutionManager execMgmt, Future<T> delegate, ExecutionList list, Task<T> task) { super(delegate, list); this.execMgmt = execMgmt; this.task = task; } @Override public boolean cancel(TaskCancellationMode mode) { boolean result = false; if (log.isTraceEnabled()) { log.trace("CLFFT cancelling " + task + " mode " + mode); } if (!task.isCancelled()) result |= ((TaskInternal<T>) task).cancel(mode); result |= delegate().cancel(mode.isAllowedToInterruptTask()); if (mode.isAllowedToInterruptAllSubmittedTasks() || mode.isAllowedToInterruptDependentSubmittedTasks()) { int subtasksFound = 0; int subtasksReallyCancelled = 0; if (task instanceof HasTaskChildren) { // cancel tasks in reverse order -- // it should be the case that if child1 is cancelled, // a parentTask should NOT call a subsequent child2, // but just in case, we cancel child2 first // NB: DST and others may apply their own recursive cancel behaviour MutableList<Task<?>> childrenReversed = MutableList .copyOf(((HasTaskChildren) task).getChildren()); Collections.reverse(childrenReversed); for (Task<?> child : childrenReversed) { if (log.isTraceEnabled()) { log.trace("Cancelling " + child + " on recursive cancellation of " + task); } subtasksFound++; if (((TaskInternal<?>) child).cancel(mode)) { result = true; subtasksReallyCancelled++; } } } // TODO this is inefficient; might want to keep an index on submitted-by for (Task<?> t : execMgmt.getAllTasks()) { if (task.equals(t.getSubmittedByTask())) { if (mode.isAllowedToInterruptAllSubmittedTasks() || BrooklynTaskTags.isTransient(t)) { if (log.isTraceEnabled()) { log.trace("Cancelling " + t + " on recursive cancellation of " + task); } subtasksFound++; if (((TaskInternal<?>) t).cancel(mode)) { result = true; subtasksReallyCancelled++; } } } } if (log.isTraceEnabled()) { log.trace("On cancel of " + task + ", applicable subtask count " + subtasksFound + ", of which " + subtasksReallyCancelled + " were actively cancelled"); } } ((TaskInternal<?>) task).runListeners(); return result; } } private final class SubmissionListenerToCallOtherListeners<T> implements Runnable { private final Task<T> task; private SubmissionListenerToCallOtherListeners(Task<T> task) { this.task = task; } @Override public void run() { try { ((TaskInternal<?>) task).runListeners(); } catch (Exception e) { log.warn("Error running task listeners for task " + task + " done", e); } for (ExecutionListener listener : listeners) { try { listener.onTaskDone(task); } catch (Exception e) { log.warn("Error running execution listener " + listener + " of task " + task + " done", e); } } } } @SuppressWarnings("unchecked") protected <T> Task<T> submitNewTask(final Map<?, ?> flags, final Task<T> task) { if (log.isTraceEnabled()) { log.trace("Submitting task {} ({}), with flags {}, and tags {}, job {}; caller {}", new Object[] { task.getId(), task, Sanitizer.sanitize(flags), task.getTags(), (task instanceof TaskInternal ? ((TaskInternal<T>) task).getJob() : "<unavailable>"), Tasks.current() }); if (Tasks.current() == null && BrooklynTaskTags.isTransient(task)) { log.trace("Stack trace for unparented submission of transient " + task, new Throwable("trace only (not an error)")); } } if (task instanceof ScheduledTask) return (Task<T>) submitNewScheduledTask(flags, (ScheduledTask) task); tasksById.put(task.getId(), task); totalTaskCount.incrementAndGet(); beforeSubmitAtomicTask(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 SubmissionCallable<T>(flags, task); // 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); } // SubmissionCallable (above) invokes the listeners on completion; // this future allows a caller to add custom listeners // (it does not notify the listeners; that's our job); // except on cancel we want to listen ListenableFuture<T> listenableFuture = new CancellingListenableForwardingFutureForTask<T>(this, future, ((TaskInternal<T>) task).getListeners(), task); // and we want to make sure *our* (manager) listeners are given suitable callback ((TaskInternal<T>) task).addListener(new SubmissionListenerToCallOtherListeners<T>(task), runner); // NB: can the above mean multiple callbacks to TaskInternal#runListeners? // finally expose the future to callers ((TaskInternal<T>) task).initInternalFuture(listenableFuture); return task; } protected void beforeSubmitScheduledTaskAllIterations(Map<?, ?> flags, Task<?> task) { internalBeforeSubmit(flags, task); } protected void beforeSubmitAtomicTask(Map<?, ?> flags, Task<?> task) { internalBeforeSubmit(flags, task); } /** invoked when a task is submitted */ protected void internalBeforeSubmit(Map<?, ?> flags, Task<?> task) { incompleteTaskIds.put(task.getId(), task.getId()); Task<?> currentTask = Tasks.current(); if (currentTask != null) ((TaskInternal<?>) task).setSubmittedByTask(currentTask); ((TaskInternal<?>) task).setSubmitTimeUtc(System.currentTimeMillis()); if (flags.get("tag") != null) ((TaskInternal<?>) task).getMutableTags().add(flags.remove("tag")); if (flags.get("tags") != null) ((TaskInternal<?>) task).getMutableTags().addAll((Collection<?>) flags.remove("tags")); for (Object tag : ((TaskInternal<?>) task).getTags()) { tasksWithTagCreating(tag).add(task); } } protected void beforeStartScheduledTaskSubmissionIteration(Map<?, ?> flags, Task<?> task) { internalBeforeStart(flags, task); } protected void beforeStartAtomicTask(Map<?, ?> flags, Task<?> task) { internalBeforeStart(flags, task); } /** invoked in a task's thread when a task is starting to run (may be some time after submitted), * but before doing any of the task's work, so that we can update bookkeeping and notify callbacks */ protected void internalBeforeStart(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()) { Thread thread = Thread.currentThread(); ((TaskInternal<?>) task).setThread(thread); if (RENAME_THREADS) { threadOriginalName.set(thread.getName()); String newThreadName = "brooklyn-" + CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, task.getDisplayName().replace(" ", "")) + "-" + task.getId().substring(0, 8); thread.setName(newThreadName); } PerThreadCurrentTaskHolder.perThreadCurrentTask.set(task); ((TaskInternal<?>) task).setStartTimeUtc(System.currentTimeMillis()); } invokeCallback(flags.get("newTaskStartCallback"), task); } @SuppressWarnings({ "unchecked", "rawtypes" }) // not ideal, such loose typing on the callback -- should prefer Function<Task,Object> // but at least it's package-private static Object invokeCallback(Object callable, Task<?> task) { if (callable instanceof Closure) return ((Closure<?>) callable).call(task); if (callable instanceof Callable) { try { return ((Callable<?>) callable).call(); } catch (Throwable t) { throw Exceptions.propagate(t); } } if (callable instanceof Runnable) { ((Runnable) callable).run(); return null; } if (callable instanceof Function) { return ((Function) callable).apply(task); } if (callable == null) return null; throw new IllegalArgumentException("Cannot invoke unexpected callback object " + callable + " of type " + callable.getClass() + " on " + task); } /** normally (if not interrupted) called once for each call to {@link #beforeSubmitScheduledTaskAllIterations(Map, Task)} */ protected void afterEndScheduledTaskAllIterations(Map<?, ?> flags, Task<?> task) { internalAfterEnd(flags, task, false, true); } /** called once for each call to {@link #beforeStartScheduledTaskSubmissionIteration(Map, Task)}, * with a per-iteration task generated by the surrounding scheduled task */ protected void afterEndScheduledTaskSubmissionIteration(Map<?, ?> flags, Task<?> scheduledTask, Task<?> taskIteration) { internalAfterEnd(flags, scheduledTask, true, false); } /** called once for each task on which {@link #beforeStartAtomicTask(Map, Task)} is invoked, * and normally (if not interrupted prior to start) * called once for each task on which {@link #beforeSubmitAtomicTask(Map, Task)} */ protected void afterEndAtomicTask(Map<?, ?> flags, Task<?> task) { internalAfterEnd(flags, task, true, true); } /** normally (if not interrupted) called once for each call to {@link #internalBeforeSubmit(Map, Task)}, * and, for atomic tasks and scheduled-task submission iterations where * always called once if {@link #internalBeforeStart(Map, Task)} is invoked and in the same thread as that method */ protected void internalAfterEnd(Map<?, ?> flags, Task<?> task, boolean startedInThisThread, boolean isEndingAllIterations) { if (log.isTraceEnabled()) log.trace(this + " afterEnd, task: " + task); if (startedInThisThread) { activeTaskCount.decrementAndGet(); } if (isEndingAllIterations) { incompleteTaskIds.remove(task.getId()); invokeCallback(flags.get("newTaskEndCallback"), task); ((TaskInternal<?>) task).setEndTimeUtc(System.currentTimeMillis()); } if (startedInThisThread) { PerThreadCurrentTaskHolder.perThreadCurrentTask.remove(); //clear thread _after_ endTime set, so we won't get a null thread when there is no end-time if (RENAME_THREADS && startedInThisThread) { Thread thread = task.getThread(); if (thread == null) { log.warn("BasicTask.afterEnd invoked without corresponding beforeStart"); } else { thread.setName(threadOriginalName.get()); threadOriginalName.remove(); } } ((TaskInternal<?>) task).setThread(null); } synchronized (task) { task.notifyAll(); } } public TaskScheduler getTaskSchedulerForTag(Object tag) { return schedulerByTag.get(tag); } public void setTaskSchedulerForTag(Object tag, Class<? extends TaskScheduler> scheduler) { synchronized (schedulerByTag) { TaskScheduler old = getTaskSchedulerForTag(tag); if (old != null) { if (scheduler.isAssignableFrom(old.getClass())) { /* already have such an instance */ return; } //might support multiple in future... throw new IllegalStateException( "Not allowed to set multiple TaskSchedulers on ExecutionManager tag (tag " + tag + ", has " + old + ", setting new " + scheduler + ")"); } try { TaskScheduler schedulerI = scheduler.newInstance(); // allow scheduler to have a nice name, for logging etc if (schedulerI instanceof CanSetName) ((CanSetName) schedulerI).setName("" + tag); setTaskSchedulerForTag(tag, schedulerI); } catch (InstantiationException e) { throw Exceptions.propagate(e); } catch (IllegalAccessException e) { throw Exceptions.propagate(e); } } } /** * Defines a {@link TaskScheduler} to run on all subsequently submitted jobs with the given tag. * * Maximum of one allowed currently. Resubmissions of the same scheduler (or scheduler class) * allowed. If changing, you must call {@link #clearTaskSchedulerForTag(Object)} between the two. * * @see #setTaskSchedulerForTag(Object, Class) */ public void setTaskSchedulerForTag(Object tag, TaskScheduler scheduler) { synchronized (schedulerByTag) { scheduler.injectExecutor(runner); Object old = schedulerByTag.put(tag, scheduler); if (old != null && old != scheduler) { //might support multiple in future... throw new IllegalStateException( "Not allowed to set multiple TaskSchedulers on ExecutionManager tag (tag " + tag + ")"); } } } /** * Forgets that any scheduler was associated with a tag. * * @see #setTaskSchedulerForTag(Object, TaskScheduler) * @see #setTaskSchedulerForTag(Object, Class) */ public boolean clearTaskSchedulerForTag(Object tag) { synchronized (schedulerByTag) { Object old = schedulerByTag.remove(tag); return (old != null); } } @VisibleForTesting public ConcurrentMap<Object, TaskScheduler> getSchedulerByTag() { return schedulerByTag; } }