public static Task<Void> fail(final String name, final Throwable optionalError) { return Tasks.<Void>builder().dynamic(false).displayName(name).body(new Runnable() { @Override public void run() { if (optionalError!=null) throw Exceptions.propagate(optionalError); else throw new RuntimeException("Failed: "+name); } }).build(); } public static Task<Void> warning(final String message, final Throwable optionalError) {
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override protected <T> Task<T> runAtEntity(Map flags, Entity entity, Callable<T> c) { manageIfNecessary(entity, elvis(Arrays.asList(flags.get("displayName"), flags.get("description"), flags, c))); return runAtEntity(entity, Tasks.<T>builder().dynamic(true).body(c).flags(flags).build()); }
SshFetchTaskWrapper(SshFetchTaskFactory factory) { this.remoteFile = Preconditions.checkNotNull(factory.remoteFile, "remoteFile"); this.machine = Preconditions.checkNotNull(factory.machine, "machine"); TaskBuilder<String> tb = TaskBuilder.<String>builder().dynamic(false).displayName("ssh fetch "+factory.remoteFile); task = tb.body(new SshFetchJob()).build(); config = factory.getConfig(); }
@Override public Task<Void> call() { return Tasks.<Void>builder().dynamic(false).displayName("periodic-persister").body(new Callable<Void>() { @Override public Void call() { persistNowSafely(); return null; }}).build(); } };
SshPutTaskWrapper(SshPutTaskFactory constructor) { super(constructor); TaskBuilder<Void> tb = TaskBuilder.<Void>builder().dynamic(false).displayName(getSummary()); task = tb.body(new SshPutJob()).build(); }
@Override public Task<?> call() { return Tasks.builder().dynamic(false).body(job).displayName("HA poller task").tag(BrooklynTaskTags.TRANSIENT_TASK_TAG) .description("polls HA status to see whether this node should promote").build(); } };
private static <T> Task<T> newGoneTaskFor(Task<?> task) { Task<T> t = Tasks.<T>builder().dynamic(false).displayName(task.getDisplayName()) .description("Details of the original task "+task+" have been forgotten.") .body(Callables.returning((T)null)).build(); ((BasicTask<T>)t).ignoreIfNotRun(); return t; }
public static Task<Integer> addBasic(final Task<Integer> x, final int y) { return TaskBuilder.<Integer>builder() .displayName("add (not dynamic)") .dynamic(false) .body(new Callable<Integer>() { @Override public Integer call() { Preconditions.checkState(x.isSubmitted()); return x.getUnchecked()+y; } }).build(); }
/** creates the TaskBuilder which can be further customized; typically invoked by the initial {@link #newTask()} */ public TaskBuilder<Object> constructCustomizedTaskBuilder() { TaskBuilder<Object> tb = TaskBuilder.builder().dynamic(false).displayName("ssh: "+getSummary()); tb.tag(BrooklynTaskTags.tagForStream(BrooklynTaskTags.STREAM_STDIN, Streams.byteArrayOfString(Strings.join(commands, "\n")))); tb.tag(BrooklynTaskTags.tagForEnvStream(BrooklynTaskTags.STREAM_ENV, shellEnvironment)); return tb; }
@Test public void testInvokeEffectorStartFailing_MethodInTask() { Task<Void> task = app.getExecutionContext().submit(Tasks.<Void>builder().dynamic(false).body(new Callable<Void>() { @Override public Void call() throws Exception { testInvokeEffectorStartFailing_Method(); return null; } }).build()); assertTaskSucceeds(task); }
protected static TaskBuilder<Object> newEmptyTask(String name) { return Tasks.builder().displayName(name).dynamic(false).body(Callables.returning(null)); }
@Test public void testInvokeEffectorStartFailing_MethodInDynamicTask() { Task<Void> task = app.getExecutionContext().submit(Tasks.<Void>builder().dynamic(true).body(new Callable<Void>() { @Override public Void call() throws Exception { testInvokeEffectorStartFailing_Method(); return null; } }).build()); assertTaskSucceeds(task); assertTaskHasFailedChild(task); }
@Test public void testByDefaultChildrenFailureAbortsSecondaryFailsPrimaryButNotAbortsPrimary() { Task<String> t1 = monitorableTask(null, "1", new FailCallable()); Task<String> t = Tasks.<String>builder().dynamic(true) .body(monitorableJob("main")) .add(t1).add(monitorableTask("2")).build(); ec.submit(t); releaseAndWaitForMonitorableJob("1"); Assert.assertFalse(t.blockUntilEnded(TINY_TIME)); releaseMonitorableJob("main"); Assert.assertTrue(t.blockUntilEnded(TIMEOUT)); Assert.assertEquals(messages, MutableList.of("1", "main")); Assert.assertTrue(stopwatch.elapsed(TimeUnit.MILLISECONDS) < TIMEOUT.toMilliseconds(), "took too long: "+stopwatch); Assert.assertTrue(t.isError()); Assert.assertTrue(t1.isError()); }
@Test public void testChildrenRunConcurrentlyWithPrimary() { Task<String> t = Tasks.<String>builder().dynamic(true) .body(monitorableJob("main")) .add(monitorableTask("1")).add(monitorableTask("2")).build(); ec.submit(t); releaseAndWaitForMonitorableJob("1"); releaseAndWaitForMonitorableJob("main"); Assert.assertFalse(t.blockUntilEnded(TINY_TIME)); releaseMonitorableJob("2"); Assert.assertTrue(t.blockUntilEnded(TIMEOUT)); Assert.assertEquals(messages, MutableList.of("1", "main", "2")); Assert.assertTrue(stopwatch.elapsed(TimeUnit.MILLISECONDS) < TIMEOUT.toMilliseconds(), "took too long: "+stopwatch); Assert.assertFalse(t.isError()); }
public Task<V> build() { validate(); return Tasks.<V>builder().dynamic(false) .displayName("waiting on "+sensor.getName()) .description("Waiting on sensor "+sensor.getName()+" from "+source) .tag("attributeWhenReady") .tag(BrooklynTaskTags.TRANSIENT_TASK_TAG) .body(new WaitInTaskForAttributeReady<T,V>(this)) .build(); }
@Test public void testTaskBuilderUsingAddAllChildren() { Task<String> t = Tasks.<String>builder().dynamic(true) .body(monitorableJob("main")) .addAll(ImmutableList.of(monitorableTask("1"), monitorableTask("2"))) .build(); ec.submit(t); releaseAndWaitForMonitorableJob("1"); releaseAndWaitForMonitorableJob("2"); releaseAndWaitForMonitorableJob("main"); Assert.assertEquals(messages, MutableList.of("1", "2", "main")); } }
@Test public void testWhenSwallowingChildrenFailureDoesNotAbortSecondaryOrFailPrimary() { Task<String> t1 = monitorableTask(null, "1", new FailCallable()); Task<String> t = Tasks.<String>builder().dynamic(true) .body(monitorableJob("main")) .add(t1).add(monitorableTask("2")).swallowChildrenFailures(true).build(); ec.submit(t); releaseAndWaitForMonitorableJob("1"); Assert.assertFalse(t.blockUntilEnded(TINY_TIME)); releaseAndWaitForMonitorableJob("2"); Assert.assertFalse(t.blockUntilEnded(TINY_TIME)); releaseMonitorableJob("main"); Assert.assertTrue(t.blockUntilEnded(TIMEOUT)); Assert.assertEquals(messages, MutableList.of("1", "2", "main")); Assert.assertTrue(stopwatch.elapsed(TimeUnit.MILLISECONDS) < TIMEOUT.toMilliseconds(), "took too long: "+stopwatch); Assert.assertFalse(t.isError()); Assert.assertTrue(t1.isError()); }
@Test public void testInessentialChildrenFailureDoesNotAbortSecondaryOrFailPrimary() { Task<String> t1 = monitorableTask(null, "1", new FailCallable()); TaskTags.markInessential(t1); Task<String> t = Tasks.<String>builder().dynamic(true) .body(monitorableJob("main")) .add(t1).add(monitorableTask("2")).build(); ec.submit(t); releaseAndWaitForMonitorableJob("1"); Assert.assertFalse(t.blockUntilEnded(TINY_TIME)); releaseAndWaitForMonitorableJob("2"); Assert.assertFalse(t.blockUntilEnded(TINY_TIME)); releaseMonitorableJob("main"); Assert.assertTrue(t.blockUntilEnded(TIMEOUT)); Assert.assertEquals(messages, MutableList.of("1", "2", "main")); Assert.assertTrue(stopwatch.elapsed(TimeUnit.MILLISECONDS) < TIMEOUT.toMilliseconds(), "took too long: "+stopwatch); Assert.assertFalse(t.isError()); Assert.assertTrue(t1.isError()); }
@Test public void testTaskBuilderUsingAddVarargChildren() { Task<String> t = Tasks.<String>builder().dynamic(true) .body(monitorableJob("main")) .add(monitorableTask("1"), monitorableTask("2")) .build(); ec.submit(t); releaseAndWaitForMonitorableJob("1"); releaseAndWaitForMonitorableJob("2"); releaseAndWaitForMonitorableJob("main"); Assert.assertEquals(messages, MutableList.of("1", "2", "main")); }
public void testGcDynamicTaskAtNormalTagLimit() throws Exception { TestEntity e = app.createAndManageChild(EntitySpec.create(TestEntity.class)); ((BrooklynProperties)app.getManagementContext().getConfig()).put( BrooklynGarbageCollector.MAX_TASKS_PER_TAG, 2); AtomicBoolean stopCondition = new AtomicBoolean(); scheduleRecursiveTemporaryTask(stopCondition, e, "foo"); scheduleRecursiveTemporaryTask(stopCondition, e, "foo"); for (int count=0; count<5; count++) { TaskBuilder<Object> tb = Tasks.builder().displayName("task-"+count).dynamic(true).body(new Runnable() { @Override public void run() {}}) .tag(ManagementContextInternal.NON_TRANSIENT_TASK_TAG).tag("foo"); ((EntityInternal)e).getExecutionContext().submit(tb.build()).getUnchecked(); } // Makes sure there's a GC while the transient tasks are running forceGc(); stopCondition.set(true); // might need an eventually here, if the internal job completion and GC is done in the background // (if there are no test failures for a few months, since Sept 2014, then we can remove this comment) assertTaskMaxCountForEntityEventually(e, 2); }