You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@aurora.apache.org by wf...@apache.org on 2015/04/21 20:54:50 UTC
[1/3] aurora git commit: Require non-default primitive values in
StorageEntityUtil.
Repository: aurora
Updated Branches:
refs/heads/master 3380572a9 -> 449a835e9
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/mem/MemTaskStoreTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/mem/MemTaskStoreTest.java b/src/test/java/org/apache/aurora/scheduler/storage/mem/MemTaskStoreTest.java
index 83b238f..20c9204 100644
--- a/src/test/java/org/apache/aurora/scheduler/storage/mem/MemTaskStoreTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/storage/mem/MemTaskStoreTest.java
@@ -19,43 +19,46 @@ import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
-import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.twitter.common.inject.Bindings;
+import com.twitter.common.inject.Bindings.KeyFactory;
import com.twitter.common.quantity.Amount;
import com.twitter.common.quantity.Time;
import com.twitter.common.util.concurrent.ExecutorServiceShutdown;
-import org.apache.aurora.gen.AssignedTask;
-import org.apache.aurora.gen.Constraint;
+import org.apache.aurora.gen.Attribute;
+import org.apache.aurora.gen.Container;
import org.apache.aurora.gen.ExecutorConfig;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.JobKey;
-import org.apache.aurora.gen.Metadata;
+import org.apache.aurora.gen.HostAttributes;
+import org.apache.aurora.gen.MaintenanceMode;
+import org.apache.aurora.gen.MesosContainer;
import org.apache.aurora.gen.ScheduleStatus;
import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
-import org.apache.aurora.gen.TaskConstraint;
-import org.apache.aurora.gen.TaskEvent;
import org.apache.aurora.gen.TaskQuery;
-import org.apache.aurora.gen.ValueConstraint;
import org.apache.aurora.scheduler.base.JobKeys;
import org.apache.aurora.scheduler.base.Query;
import org.apache.aurora.scheduler.base.Tasks;
+import org.apache.aurora.scheduler.storage.AttributeStore;
+import org.apache.aurora.scheduler.storage.Storage;
import org.apache.aurora.scheduler.storage.TaskStore.Mutable.TaskMutation;
+import org.apache.aurora.scheduler.storage.db.DbModule;
+import org.apache.aurora.scheduler.storage.entities.IHostAttributes;
import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
import org.apache.aurora.scheduler.storage.testing.StorageEntityUtil;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import static org.apache.aurora.gen.ScheduleStatus.RUNNING;
+import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTask;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
@@ -63,38 +66,126 @@ import static org.junit.Assert.assertTrue;
public class MemTaskStoreTest {
- private static final IScheduledTask TASK_A = makeTask("a");
- private static final IScheduledTask TASK_B = makeTask("b");
- private static final IScheduledTask TASK_C = makeTask("c");
- private static final IScheduledTask TASK_D = makeTask("d");
-
- private MemTaskStore store;
+ private static final IHostAttributes HOST_A = IHostAttributes.build(
+ new HostAttributes(
+ "hostA",
+ ImmutableSet.of(new Attribute("zone", ImmutableSet.of("1a"))))
+ .setSlaveId("slaveIdA")
+ .setMode(MaintenanceMode.NONE));
+ private static final IHostAttributes HOST_B = IHostAttributes.build(
+ new HostAttributes(
+ "hostB",
+ ImmutableSet.of(new Attribute("zone", ImmutableSet.of("1a"))))
+ .setSlaveId("slaveIdB")
+ .setMode(MaintenanceMode.NONE));
+ private static final IScheduledTask TASK_A = createTask("a");
+ private static final IScheduledTask TASK_B =
+ setContainer(createTask("b"), Container.mesos(new MesosContainer()));
+ private static final IScheduledTask TASK_C = createTask("c");
+ private static final IScheduledTask TASK_D = createTask("d");
+
+ private Storage storage;
@Before
public void setUp() {
- store = new MemTaskStore();
+ Injector injector = Guice.createInjector(
+ new MemStorageModule(KeyFactory.PLAIN),
+ DbModule.testModule(Bindings.annotatedKeyFactory(MemStorage.Delegated.class)));
+ storage = injector.getInstance(Storage.class);
+ storage.prepare();
+
+ storage.write(new Storage.MutateWork.NoResult.Quiet() {
+ @Override
+ protected void execute(Storage.MutableStoreProvider storeProvider) {
+ AttributeStore.Mutable attributeStore = storeProvider.getAttributeStore();
+ attributeStore.saveHostAttributes(HOST_A);
+ attributeStore.saveHostAttributes(HOST_B);
+ }
+ });
+ }
+
+ private Iterable<IScheduledTask> fetchTasks(final Query.Builder query) {
+ return storage.read(new Storage.Work.Quiet<Iterable<IScheduledTask>>() {
+ @Override
+ public Iterable<IScheduledTask> apply(Storage.StoreProvider storeProvider) {
+ return storeProvider.getTaskStore().fetchTasks(query);
+ }
+ });
+ }
+
+ private void saveTasks(final IScheduledTask... tasks) {
+ saveTasks(ImmutableSet.copyOf(tasks));
+ }
+
+ private void saveTasks(final Set<IScheduledTask> tasks) {
+ storage.write(new Storage.MutateWork.NoResult.Quiet() {
+ @Override
+ protected void execute(Storage.MutableStoreProvider storeProvider) {
+ storeProvider.getUnsafeTaskStore().saveTasks(ImmutableSet.copyOf(tasks));
+ }
+ });
+ }
+
+ private ImmutableSet<IScheduledTask> mutateTasks(
+ final Query.Builder query,
+ final TaskMutation mutation) {
+
+ return storage.write(new Storage.MutateWork.Quiet<ImmutableSet<IScheduledTask>>() {
+ @Override
+ public ImmutableSet<IScheduledTask> apply(Storage.MutableStoreProvider storeProvider) {
+ return storeProvider.getUnsafeTaskStore().mutateTasks(query, mutation);
+ }
+ });
+ }
+
+ private boolean unsafeModifyInPlace(final String taskId, final ITaskConfig taskConfiguration) {
+ return storage.write(new Storage.MutateWork.Quiet<Boolean>() {
+ @Override
+ public Boolean apply(Storage.MutableStoreProvider storeProvider) {
+ return storeProvider.getUnsafeTaskStore().unsafeModifyInPlace(taskId, taskConfiguration);
+ }
+ });
+ }
+
+ private void deleteTasks(final String... taskIds) {
+ storage.write(new Storage.MutateWork.NoResult.Quiet() {
+ @Override
+ protected void execute(Storage.MutableStoreProvider storeProvider) {
+ storeProvider.getUnsafeTaskStore().deleteTasks(ImmutableSet.copyOf(taskIds));
+ }
+ });
+ }
+
+ private void deleteAllTasks() {
+ storage.write(new Storage.MutateWork.NoResult.Quiet() {
+ @Override
+ protected void execute(Storage.MutableStoreProvider storeProvider) {
+ storeProvider.getUnsafeTaskStore().deleteAllTasks();
+ }
+ });
}
@Test
public void testSave() {
- StorageEntityUtil.assertFullyPopulated(TASK_A.newBuilder());
- store.saveTasks(ImmutableSet.of(TASK_A, TASK_B));
- assertStoreContents(TASK_A, TASK_B);
+ IScheduledTask aWithHost = setHost(TASK_A, HOST_A);
+ StorageEntityUtil.assertFullyPopulated(aWithHost.newBuilder());
- store.saveTasks(ImmutableSet.of(TASK_C, TASK_D));
- assertStoreContents(TASK_A, TASK_B, TASK_C, TASK_D);
+ saveTasks(aWithHost, TASK_B);
+ assertStoreContents(aWithHost, TASK_B);
+
+ saveTasks(TASK_C, TASK_D);
+ assertStoreContents(aWithHost, TASK_B, TASK_C, TASK_D);
// Saving the same task should overwrite.
- IScheduledTask taskAModified =
- IScheduledTask.build(TASK_A.newBuilder().setStatus(RUNNING));
- store.saveTasks(ImmutableSet.of(taskAModified));
+ IScheduledTask taskAModified = IScheduledTask.build(aWithHost.newBuilder().setStatus(RUNNING));
+ saveTasks(taskAModified);
assertStoreContents(taskAModified, TASK_B, TASK_C, TASK_D);
}
@Test
public void testQuery() {
assertStoreContents();
- store.saveTasks(ImmutableSet.of(TASK_A, TASK_B, TASK_C, TASK_D));
+ saveTasks(TASK_A, TASK_B, TASK_C, TASK_D);
assertQueryResults(Query.taskScoped("b"), TASK_B);
assertQueryResults(Query.taskScoped("a", "d"), TASK_A, TASK_D);
@@ -105,7 +196,7 @@ public class MemTaskStoreTest {
Query.unscoped().byStatus(ScheduleStatus.PENDING),
TASK_A, TASK_B, TASK_C, TASK_D);
assertQueryResults(
- Query.instanceScoped(JobKeys.from("role-a", "env-a", "job-a"), 0).active(), TASK_A);
+ Query.instanceScoped(JobKeys.from("role-a", "env-a", "job-a"), 2).active(), TASK_A);
assertQueryResults(Query.jobScoped(JobKeys.from("role-b", "env-b", "job-b")).active(), TASK_B);
assertQueryResults(Query.jobScoped(JobKeys.from("role-b", "devel", "job-b")).active());
@@ -122,21 +213,34 @@ public class MemTaskStoreTest {
}
@Test
+ public void testQueryMultipleInstances() {
+ ImmutableSet.Builder<IScheduledTask> tasksBuilder = ImmutableSet.builder();
+ for (int i = 0; i < 100; i++) {
+ ScheduledTask builder = TASK_A.newBuilder();
+ builder.getAssignedTask()
+ .setTaskId("id" + i)
+ .setInstanceId(i);
+ tasksBuilder.add(IScheduledTask.build(builder));
+ }
+ Set<IScheduledTask> tasks = tasksBuilder.build();
+ saveTasks(tasks);
+ assertQueryResults(Query.unscoped(), tasks);
+ }
+
+ @Test
public void testQueryBySlaveHost() {
- String hostA = "slaveA";
- String hostB = "slaveB";
- final IScheduledTask a = setHost(makeTask("a", "role", "env", "job"), Optional.of(hostA));
- final IScheduledTask b = setHost(makeTask("b", "role", "env", "job"), Optional.of(hostB));
- store.saveTasks(ImmutableSet.of(a, b));
+ IScheduledTask a = setHost(makeTask("a", JobKeys.from("role", "env", "job")), HOST_A);
+ IScheduledTask b = setHost(makeTask("b", JobKeys.from("role", "env", "job")), HOST_B);
+ saveTasks(a, b);
- assertQueryResults(Query.slaveScoped(hostA), a);
- assertQueryResults(Query.slaveScoped(hostA, hostB), a, b);
+ assertQueryResults(Query.slaveScoped(HOST_A.getHost()), a);
+ assertQueryResults(Query.slaveScoped(HOST_A.getHost(), HOST_B.getHost()), a, b);
}
@Test
public void testQueryByJobKeys() {
assertStoreContents();
- store.saveTasks(ImmutableSet.of(TASK_A, TASK_B, TASK_C, TASK_D));
+ saveTasks(TASK_A, TASK_B, TASK_C, TASK_D);
assertQueryResults(
Query.jobScoped(ImmutableSet.of(
@@ -147,8 +251,8 @@ public class MemTaskStoreTest {
// Conflicting jobs will produce the result from the last added JobKey
assertQueryResults(
- Query.jobScoped(JobKeys.from("role-a", "env-a", "job-a"))
- .byJobKeys(ImmutableSet.of(JobKeys.from("role-b", "env-b", "job-b"))),
+ Query.jobScoped(JobKeys.from("role-a", "env-a", "job-a"))
+ .byJobKeys(ImmutableSet.of(JobKeys.from("role-b", "env-b", "job-b"))),
TASK_B);
// The .byJobKeys will override the previous scoping and OR all of the keys.
@@ -170,10 +274,10 @@ public class MemTaskStoreTest {
@Test
public void testMutate() {
- store.saveTasks(ImmutableSet.of(TASK_A, TASK_B, TASK_C, TASK_D));
+ saveTasks(TASK_A, TASK_B, TASK_C, TASK_D);
assertQueryResults(Query.statusScoped(RUNNING));
- store.mutateTasks(Query.taskScoped("a"), new TaskMutation() {
+ mutateTasks(Query.taskScoped("a"), new TaskMutation() {
@Override
public IScheduledTask apply(IScheduledTask task) {
return IScheduledTask.build(task.newBuilder().setStatus(RUNNING));
@@ -184,7 +288,7 @@ public class MemTaskStoreTest {
Query.statusScoped(RUNNING),
IScheduledTask.build(TASK_A.newBuilder().setStatus(RUNNING)));
- store.mutateTasks(Query.unscoped(), new TaskMutation() {
+ mutateTasks(Query.unscoped(), new TaskMutation() {
@Override
public IScheduledTask apply(IScheduledTask task) {
return IScheduledTask.build(task.newBuilder().setStatus(ScheduleStatus.ASSIGNED));
@@ -207,59 +311,59 @@ public class MemTaskStoreTest {
.setExecutorConfig(new ExecutorConfig("aurora", "new_config")));
String taskId = Tasks.id(TASK_A);
- assertFalse(store.unsafeModifyInPlace(taskId, updated));
+ assertFalse(unsafeModifyInPlace(taskId, updated));
- store.saveTasks(ImmutableSet.of(TASK_A));
- assertTrue(store.unsafeModifyInPlace(taskId, updated));
+ saveTasks(TASK_A);
+ assertTrue(unsafeModifyInPlace(taskId, updated));
Query.Builder query = Query.taskScoped(taskId);
ITaskConfig stored =
- Iterables.getOnlyElement(store.fetchTasks(query)).getAssignedTask().getTask();
+ Iterables.getOnlyElement(fetchTasks(query)).getAssignedTask().getTask();
assertEquals(updated, stored);
- store.deleteTasks(ImmutableSet.of(taskId));
- assertFalse(store.unsafeModifyInPlace(taskId, updated));
+ deleteTasks(taskId);
+ assertFalse(unsafeModifyInPlace(taskId, updated));
}
@Test
public void testDelete() {
- store.saveTasks(ImmutableSet.of(TASK_A, TASK_B, TASK_C, TASK_D));
- store.deleteTasks(ImmutableSet.of("a"));
+ saveTasks(TASK_A, TASK_B, TASK_C, TASK_D);
+ deleteTasks("a");
assertStoreContents(TASK_B, TASK_C, TASK_D);
- store.deleteTasks(ImmutableSet.of("c"));
+ deleteTasks("c");
assertStoreContents(TASK_B, TASK_D);
- store.deleteTasks(ImmutableSet.of("b", "d"));
+ deleteTasks("b", "d");
assertStoreContents();
}
@Test
public void testDeleteAll() {
- store.saveTasks(ImmutableSet.of(TASK_A, TASK_B, TASK_C, TASK_D));
- store.deleteAllTasks();
+ saveTasks(TASK_A, TASK_B, TASK_C, TASK_D);
+ deleteAllTasks();
assertStoreContents();
}
@Test
public void testConsistentJobIndex() {
- final IScheduledTask a = makeTask("a", "jim", "test", "job");
- final IScheduledTask b = makeTask("b", "jim", "test", "job");
- final IScheduledTask c = makeTask("c", "jim", "test", "job2");
- final IScheduledTask d = makeTask("d", "joe", "test", "job");
- final IScheduledTask e = makeTask("e", "jim", "prod", "job");
+ final IScheduledTask a = makeTask("a", JobKeys.from("jim", "test", "job"));
+ final IScheduledTask b = makeTask("b", JobKeys.from("jim", "test", "job"));
+ final IScheduledTask c = makeTask("c", JobKeys.from("jim", "test", "job2"));
+ final IScheduledTask d = makeTask("d", JobKeys.from("joe", "test", "job"));
+ final IScheduledTask e = makeTask("e", JobKeys.from("jim", "prod", "job"));
final Query.Builder jimsJob = Query.jobScoped(JobKeys.from("jim", "test", "job"));
final Query.Builder jimsJob2 = Query.jobScoped(JobKeys.from("jim", "test", "job2"));
final Query.Builder joesJob = Query.jobScoped(JobKeys.from("joe", "test", "job"));
- store.saveTasks(ImmutableSet.of(a, b, c, d, e));
+ saveTasks(a, b, c, d, e);
assertQueryResults(jimsJob, a, b);
assertQueryResults(jimsJob2, c);
assertQueryResults(joesJob, d);
- store.deleteTasks(ImmutableSet.of(Tasks.id(b)));
+ deleteTasks(Tasks.id(b));
assertQueryResults(jimsJob, a);
assertQueryResults(jimsJob2, c);
assertQueryResults(joesJob, d);
- store.mutateTasks(jimsJob, new TaskMutation() {
+ mutateTasks(jimsJob, new TaskMutation() {
@Override
public IScheduledTask apply(IScheduledTask task) {
return IScheduledTask.build(task.newBuilder().setStatus(RUNNING));
@@ -270,15 +374,15 @@ public class MemTaskStoreTest {
assertQueryResults(jimsJob2, c);
assertQueryResults(joesJob, d);
- store.deleteTasks(ImmutableSet.of(Tasks.id(d)));
+ deleteTasks(Tasks.id(d));
assertQueryResults(joesJob);
- store.deleteTasks(ImmutableSet.of(Tasks.id(d)));
+ deleteTasks(Tasks.id(d));
assertQueryResults(jimsJob, aRunning);
assertQueryResults(jimsJob2, c);
assertQueryResults(joesJob);
- store.saveTasks(ImmutableSet.of(b));
+ saveTasks(b);
assertQueryResults(jimsJob, aRunning, b);
assertQueryResults(jimsJob2, c);
assertQueryResults(joesJob);
@@ -286,13 +390,13 @@ public class MemTaskStoreTest {
@Test
public void testCanonicalTaskConfigs() {
- IScheduledTask a = makeTask("a", "role", "env", "job");
- IScheduledTask b = makeTask("a", "role", "env", "job");
- IScheduledTask c = makeTask("a", "role", "env", "job");
+ IScheduledTask a = createTask("a");
+ IScheduledTask b = createTask("a");
+ IScheduledTask c = createTask("a");
+ saveTasks(a, b, c);
Set<IScheduledTask> inserted = ImmutableSet.of(a, b, c);
- store.saveTasks(inserted);
- Set<ITaskConfig> storedConfigs = FluentIterable.from(store.fetchTasks(Query.unscoped()))
+ Set<ITaskConfig> storedConfigs = FluentIterable.from(fetchTasks(Query.unscoped()))
.transform(Tasks.SCHEDULED_TO_INFO)
.toSet();
assertEquals(
@@ -307,9 +411,19 @@ public class MemTaskStoreTest {
identityMap);
}
- private static IScheduledTask setHost(IScheduledTask task, Optional<String> host) {
+ private static IScheduledTask setHost(IScheduledTask task, IHostAttributes host) {
ScheduledTask builder = task.newBuilder();
- builder.getAssignedTask().setSlaveHost(host.orNull());
+ builder.getAssignedTask()
+ .setSlaveHost(host.getHost())
+ .setSlaveId(host.getSlaveId());
+ return IScheduledTask.build(builder);
+ }
+
+ private static IScheduledTask unsetHost(IScheduledTask task) {
+ ScheduledTask builder = task.newBuilder();
+ builder.getAssignedTask()
+ .setSlaveHost(null)
+ .setSlaveId(null);
return IScheduledTask.build(builder);
}
@@ -321,14 +435,13 @@ public class MemTaskStoreTest {
@Test
public void testAddSlaveHost() {
- final IScheduledTask a = makeTask("a", "role", "env", "job");
- store.saveTasks(ImmutableSet.of(a));
- String host = "slaveA";
- assertQueryResults(Query.slaveScoped(host));
-
- final IScheduledTask b = setHost(a, Optional.of(host));
- Set<IScheduledTask> result = store.mutateTasks(Query.taskScoped(Tasks.id(a)),
- new Function<IScheduledTask, IScheduledTask>() {
+ final IScheduledTask a = createTask("a");
+ saveTasks(a);
+ assertQueryResults(Query.slaveScoped(HOST_A.getHost()));
+
+ final IScheduledTask b = setHost(a, HOST_A);
+ Set<IScheduledTask> result = mutateTasks(Query.taskScoped(Tasks.id(a)),
+ new TaskMutation() {
@Override
public IScheduledTask apply(IScheduledTask task) {
assertEquals(a, task);
@@ -336,13 +449,12 @@ public class MemTaskStoreTest {
}
});
assertEquals(ImmutableSet.of(b), result);
- assertQueryResults(Query.slaveScoped(host), b);
+ assertQueryResults(Query.slaveScoped(HOST_A.getHost()), b);
// Unrealistic behavior, but proving that the secondary index can handle key mutations.
- String host2 = "slaveA2";
- final IScheduledTask c = setHost(b, Optional.of(host2));
- Set<IScheduledTask> result2 = store.mutateTasks(Query.taskScoped(Tasks.id(a)),
- new Function<IScheduledTask, IScheduledTask>() {
+ final IScheduledTask c = setHost(b, HOST_B);
+ Set<IScheduledTask> result2 = mutateTasks(Query.taskScoped(Tasks.id(a)),
+ new TaskMutation() {
@Override
public IScheduledTask apply(IScheduledTask task) {
assertEquals(b, task);
@@ -350,24 +462,23 @@ public class MemTaskStoreTest {
}
});
assertEquals(ImmutableSet.of(c), result2);
- assertQueryResults(Query.slaveScoped(host2), c);
+ assertQueryResults(Query.slaveScoped(HOST_B.getHost()), c);
- store.deleteTasks(ImmutableSet.of(Tasks.id(a)));
- assertQueryResults(Query.slaveScoped(host));
+ deleteTasks(Tasks.id(a));
+ assertQueryResults(Query.slaveScoped(HOST_B.getHost()));
}
@Test
public void testUnsetSlaveHost() {
// Unrealistic behavior, but proving that the secondary index does not become stale.
- String host = "slaveA";
- final IScheduledTask a = setHost(makeTask("a", "role", "env", "job"), Optional.of(host));
- store.saveTasks(ImmutableSet.of(a));
- assertQueryResults(Query.slaveScoped(host), a);
+ final IScheduledTask a = setHost(createTask("a"), HOST_A);
+ saveTasks(a);
+ assertQueryResults(Query.slaveScoped(HOST_A.getHost()), a);
- final IScheduledTask b = setHost(a, Optional.<String>absent());
- Set<IScheduledTask> result = store.mutateTasks(Query.taskScoped(Tasks.id(a)),
- new Function<IScheduledTask, IScheduledTask>() {
+ final IScheduledTask b = unsetHost(a);
+ Set<IScheduledTask> result = mutateTasks(Query.taskScoped(Tasks.id(a)),
+ new TaskMutation() {
@Override
public IScheduledTask apply(IScheduledTask task) {
assertEquals(a, task);
@@ -375,17 +486,16 @@ public class MemTaskStoreTest {
}
});
assertEquals(ImmutableSet.of(b), result);
- assertQueryResults(Query.slaveScoped(host));
+ assertQueryResults(Query.slaveScoped(HOST_A.getHost()));
assertQueryResults(Query.taskScoped(Tasks.id(b)), b);
}
@Test
public void testTasksOnSameHost() {
- String host = "slaveA";
- final IScheduledTask a = setHost(makeTask("a", "role", "env", "job"), Optional.of(host));
- final IScheduledTask b = setHost(makeTask("b", "role", "env", "job"), Optional.of(host));
- store.saveTasks(ImmutableSet.of(a, b));
- assertQueryResults(Query.slaveScoped(host), a, b);
+ final IScheduledTask a = setHost(createTask("a"), HOST_A);
+ final IScheduledTask b = setHost(createTask("b"), HOST_A);
+ saveTasks(a, b);
+ assertQueryResults(Query.slaveScoped(HOST_A.getHost()), a, b);
}
@Test
@@ -393,16 +503,16 @@ public class MemTaskStoreTest {
// Ensures that saving a task with an existing task ID is effectively the same as a mutate,
// and does not result in a duplicate object in the primary or secondary index.
- String host = "slaveA";
- final IScheduledTask a = setHost(makeTask("a", "role", "env", "job"), Optional.of(host));
- store.saveTasks(ImmutableSet.of(a));
+ final IScheduledTask a = setHost(createTask("a"), HOST_A);
+ saveTasks(a);
final IScheduledTask updated = setConfigData(a, "new config data");
- store.saveTasks(ImmutableSet.of(updated));
+ saveTasks(updated);
assertQueryResults(Query.taskScoped(Tasks.id(a)), updated);
- assertQueryResults(Query.slaveScoped(host), updated);
+ assertQueryResults(Query.slaveScoped(HOST_A.getHost()), updated);
}
+ @Ignore
@Test
public void testReadSecondaryIndexMultipleThreads() throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(4,
@@ -414,10 +524,10 @@ public class MemTaskStoreTest {
final int numJobs = 100;
for (int j = 0; j < numJobs; j++) {
for (int t = 0; t < numTasks; t++) {
- builder.add(makeTask("" + j + "-" + t, "role", "env", "name" + j));
+ builder.add(makeTask("" + j + "-" + t, JobKeys.from("role", "env", "name" + j)));
}
}
- store.saveTasks(builder.build());
+ saveTasks(builder.build());
final CountDownLatch read = new CountDownLatch(numJobs);
for (int j = 0; j < numJobs; j++) {
@@ -425,15 +535,14 @@ public class MemTaskStoreTest {
executor.submit(new Runnable() {
@Override
public void run() {
- assertNotNull(store.fetchTasks(Query.jobScoped(
- JobKeys.from("role", "env", "name" + id))));
+ assertNotNull(fetchTasks(Query.jobScoped(JobKeys.from("role", "env", "name" + id))));
read.countDown();
}
});
executor.submit(new Runnable() {
@Override
public void run() {
- store.saveTasks(ImmutableSet.of(makeTask("TaskNew1" + id)));
+ saveTasks(createTask("TaskNew1" + id));
}
});
}
@@ -453,50 +562,20 @@ public class MemTaskStoreTest {
}
private void assertQueryResults(Query.Builder query, IScheduledTask... tasks) {
- assertEquals(
- ImmutableSet.<IScheduledTask>builder().add(tasks).build(),
- store.fetchTasks(query));
- }
-
- private static IScheduledTask makeTask(String id, String role, String env, String jobName) {
- return IScheduledTask.build(new ScheduledTask()
- .setStatus(ScheduleStatus.PENDING)
- .setTaskEvents(ImmutableList.of(
- new TaskEvent(100L, ScheduleStatus.ASSIGNED)
- .setMessage("message")
- .setScheduler("scheduler")))
- .setAncestorId("ancestor")
- .setAssignedTask(new AssignedTask()
- .setInstanceId(0)
- .setTaskId(id)
- .setSlaveId("slave")
- .setSlaveHost("slavehost")
- .setAssignedPorts(ImmutableMap.of("http", 1000))
- .setTask(new TaskConfig()
- .setJob(new JobKey(role, env, jobName))
- .setJobName(jobName)
- .setEnvironment(env)
- .setOwner(new Identity(role, role))
- .setIsService(true)
- .setNumCpus(1.0)
- .setRamMb(1024)
- .setDiskMb(1024)
- .setPriority(1)
- .setMaxTaskFailures(-1)
- .setProduction(true)
- .setConstraints(ImmutableSet.of(
- new Constraint(
- "name",
- TaskConstraint.value(
- new ValueConstraint(false, ImmutableSet.of("value"))))))
- .setRequestedPorts(ImmutableSet.of("http"))
- .setTaskLinks(ImmutableMap.of("http", "link"))
- .setContactEmail("foo@bar.com")
- .setMetadata(ImmutableSet.of(new Metadata("key", "value")))
- .setExecutorConfig(new ExecutorConfig("name", "config")))));
- }
-
- private static IScheduledTask makeTask(String id) {
- return makeTask(id, "role-" + id, "env-" + id, "job-" + id);
+ assertQueryResults(query, ImmutableSet.copyOf(tasks));
+ }
+
+ private void assertQueryResults(Query.Builder query, Set<IScheduledTask> tasks) {
+ assertEquals(tasks, fetchTasks(query));
+ }
+
+ private static IScheduledTask createTask(String id) {
+ return makeTask(id, JobKeys.from("role-" + id, "env-" + id, "job-" + id));
+ }
+
+ private static IScheduledTask setContainer(IScheduledTask task, Container container) {
+ ScheduledTask builder = task.newBuilder();
+ builder.getAssignedTask().getTask().setContainer(container);
+ return IScheduledTask.build(builder);
}
}
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/testing/StorageEntityUtil.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/testing/StorageEntityUtil.java b/src/test/java/org/apache/aurora/scheduler/storage/testing/StorageEntityUtil.java
index b26ddd3..0bde4d8 100644
--- a/src/test/java/org/apache/aurora/scheduler/storage/testing/StorageEntityUtil.java
+++ b/src/test/java/org/apache/aurora/scheduler/storage/testing/StorageEntityUtil.java
@@ -19,11 +19,13 @@ import java.util.Collection;
import java.util.Map;
import java.util.Set;
+import com.google.common.base.Defaults;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableSet;
import com.google.gson.internal.Primitives;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
/**
@@ -49,20 +51,29 @@ public final class StorageEntityUtil {
assertFullyPopulated(name + " key", entry.getKey(), ignoredFields);
assertFullyPopulated(name + "[" + entry.getKey() + "]", entry.getValue(), ignoredFields);
}
- } else if (!Primitives.isPrimitive(object.getClass())
- && !Primitives.isWrapperType(object.getClass())) {
-
+ } else if (!(object instanceof String) && !(object instanceof Enum)) {
for (Field field : object.getClass().getDeclaredFields()) {
if (!Modifier.isStatic(field.getModifiers())) {
try {
field.setAccessible(true);
String fullName = name + "." + field.getName();
- Object value = field.get(object);
- if (!ignoredFields.contains(field)) {
- assertNotNull(fullName + " is null", value);
+ Object fieldValue = field.get(object);
+ boolean mustBeSet = !ignoredFields.contains(field);
+ if (mustBeSet) {
+ assertNotNull(fullName + " is null", fieldValue);
}
- if (value != null) {
- assertFullyPopulated(fullName, value, ignoredFields);
+ if (fieldValue != null) {
+ if (Primitives.isWrapperType(fieldValue.getClass())) {
+ // Special-case the mutable hash code field.
+ if (mustBeSet && !fullName.endsWith("cachedHashCode")) {
+ assertNotEquals(
+ "Primitive value must not be default: " + fullName,
+ Defaults.defaultValue(Primitives.unwrap(fieldValue.getClass())),
+ fieldValue);
+ }
+ } else {
+ assertFullyPopulated(fullName, fieldValue, ignoredFields);
+ }
}
} catch (IllegalAccessException e) {
throw Throwables.propagate(e);
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/updater/InstanceUpdaterTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/updater/InstanceUpdaterTest.java b/src/test/java/org/apache/aurora/scheduler/updater/InstanceUpdaterTest.java
index 3f1f72b..1128303 100644
--- a/src/test/java/org/apache/aurora/scheduler/updater/InstanceUpdaterTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/updater/InstanceUpdaterTest.java
@@ -13,16 +13,22 @@
*/
package org.apache.aurora.scheduler.updater;
+import java.util.List;
+import java.util.Objects;
+
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
import com.twitter.common.quantity.Amount;
import com.twitter.common.quantity.Time;
import com.twitter.common.util.testing.FakeClock;
+import org.apache.aurora.gen.AssignedTask;
import org.apache.aurora.gen.ScheduleStatus;
import org.apache.aurora.gen.ScheduledTask;
import org.apache.aurora.gen.TaskConfig;
import org.apache.aurora.gen.TaskEvent;
+import org.apache.aurora.scheduler.base.Tasks;
import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
import org.junit.Test;
@@ -263,4 +269,33 @@ public class InstanceUpdaterTest {
f.advanceTime(MIN_RUNNING_TIME);
f.evaluateCurrentState(SUCCEEDED);
}
+
+ static final class TaskUtil {
+ private final FakeClock clock;
+
+ TaskUtil(FakeClock clock) {
+ this.clock = Objects.requireNonNull(clock);
+ }
+
+ IScheduledTask makeTask(ITaskConfig config, ScheduleStatus status) {
+ List<TaskEvent> events = Lists.newArrayList();
+ if (status != PENDING) {
+ events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(PENDING));
+ }
+ if (Tasks.isTerminated(status) || status == KILLING) {
+ events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(ASSIGNED));
+ events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(RUNNING));
+ }
+
+ events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(status));
+
+ return IScheduledTask.build(
+ new ScheduledTask()
+ .setStatus(status)
+ .setTaskEvents(ImmutableList.copyOf(events))
+ .setAssignedTask(
+ new AssignedTask()
+ .setTask(config.newBuilder())));
+ }
+ }
}
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/updater/JobUpdaterIT.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/updater/JobUpdaterIT.java b/src/test/java/org/apache/aurora/scheduler/updater/JobUpdaterIT.java
index dd4c940..6be0efa 100644
--- a/src/test/java/org/apache/aurora/scheduler/updater/JobUpdaterIT.java
+++ b/src/test/java/org/apache/aurora/scheduler/updater/JobUpdaterIT.java
@@ -43,10 +43,7 @@ import com.twitter.common.testing.easymock.EasyMockTest;
import com.twitter.common.util.Clock;
import com.twitter.common.util.TruncatedBinaryBackoff;
-import org.apache.aurora.gen.ExecutorConfig;
-import org.apache.aurora.gen.Identity;
import org.apache.aurora.gen.InstanceTaskConfig;
-import org.apache.aurora.gen.JobKey;
import org.apache.aurora.gen.JobUpdate;
import org.apache.aurora.gen.JobUpdateAction;
import org.apache.aurora.gen.JobUpdateEvent;
@@ -67,6 +64,7 @@ import org.apache.aurora.scheduler.async.RescheduleCalculator;
import org.apache.aurora.scheduler.async.RescheduleCalculator.RescheduleCalculatorImpl;
import org.apache.aurora.scheduler.base.JobKeys;
import org.apache.aurora.scheduler.base.Query;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
import org.apache.aurora.scheduler.base.Tasks;
import org.apache.aurora.scheduler.events.EventSink;
import org.apache.aurora.scheduler.events.PubsubEvent;
@@ -146,8 +144,8 @@ public class JobUpdaterIT extends EasyMockTest {
private static final Amount<Long, Time> FLAPPING_THRESHOLD = Amount.of(1L, Time.MILLISECONDS);
private static final Amount<Long, Time> ONE_DAY = Amount.of(1L, Time.DAYS);
private static final ITaskConfig OLD_CONFIG =
- ITaskConfig.build(makeTaskConfig().setExecutorConfig(new ExecutorConfig().setName("new")));
- private static final ITaskConfig NEW_CONFIG = ITaskConfig.build(makeTaskConfig());
+ setExecutorData(TaskTestUtil.makeConfig(JOB), "olddata");
+ private static final ITaskConfig NEW_CONFIG = setExecutorData(OLD_CONFIG, "newdata");
private static final long PULSE_TIMEOUT_MS = 10000;
private FakeScheduledExecutor clock;
@@ -159,6 +157,12 @@ public class JobUpdaterIT extends EasyMockTest {
private StateManager stateManager;
private JobUpdateEventSubscriber subscriber;
+ private static ITaskConfig setExecutorData(ITaskConfig task, String executorData) {
+ TaskConfig builder = task.newBuilder();
+ builder.getExecutorConfig().setData(executorData);
+ return ITaskConfig.build(builder);
+ }
+
@Before
public void setUp() {
// Avoid console spam due to stats registered multiple times.
@@ -1327,15 +1331,4 @@ public class JobUpdaterIT extends EasyMockTest {
.setInstances(ImmutableSet.of(new Range(start, end)))
.setTask(config.newBuilder()));
}
-
- private static TaskConfig makeTaskConfig() {
- return new TaskConfig()
- .setJob(new JobKey(JOB.newBuilder()))
- .setJobName(JOB.getName())
- .setEnvironment(JOB.getEnvironment())
- .setOwner(new Identity(JOB.getRole(), "user"))
- .setIsService(true)
- .setExecutorConfig(new ExecutorConfig().setName("old"))
- .setNumCpus(1);
- }
}
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/updater/TaskUtil.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/updater/TaskUtil.java b/src/test/java/org/apache/aurora/scheduler/updater/TaskUtil.java
deleted file mode 100644
index 0e67f91..0000000
--- a/src/test/java/org/apache/aurora/scheduler/updater/TaskUtil.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
- * Licensed 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.aurora.scheduler.updater;
-
-import java.util.List;
-import java.util.Objects;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-import com.twitter.common.util.testing.FakeClock;
-
-import org.apache.aurora.gen.AssignedTask;
-import org.apache.aurora.gen.ScheduleStatus;
-import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskEvent;
-import org.apache.aurora.scheduler.base.Tasks;
-import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
-import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
-
-import static org.apache.aurora.gen.ScheduleStatus.ASSIGNED;
-import static org.apache.aurora.gen.ScheduleStatus.KILLING;
-import static org.apache.aurora.gen.ScheduleStatus.PENDING;
-import static org.apache.aurora.gen.ScheduleStatus.RUNNING;
-
-final class TaskUtil {
-
- private final FakeClock clock;
-
- TaskUtil(FakeClock clock) {
- this.clock = Objects.requireNonNull(clock);
- }
-
- IScheduledTask makeTask(ITaskConfig config, ScheduleStatus status) {
- List<TaskEvent> events = Lists.newArrayList();
- if (status != PENDING) {
- events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(PENDING));
- }
- if (Tasks.isTerminated(status) || status == KILLING) {
- events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(ASSIGNED));
- events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(RUNNING));
- }
-
- events.add(new TaskEvent().setTimestamp(clock.nowMillis()).setStatus(status));
-
- return IScheduledTask.build(
- new ScheduledTask()
- .setStatus(status)
- .setTaskEvents(ImmutableList.copyOf(events))
- .setAssignedTask(
- new AssignedTask()
- .setTask(config.newBuilder())));
- }
-}
[3/3] aurora git commit: Require non-default primitive values in
StorageEntityUtil.
Posted by wf...@apache.org.
Require non-default primitive values in StorageEntityUtil.
Reviewed at https://reviews.apache.org/r/33200/
Project: http://git-wip-us.apache.org/repos/asf/aurora/repo
Commit: http://git-wip-us.apache.org/repos/asf/aurora/commit/449a835e
Tree: http://git-wip-us.apache.org/repos/asf/aurora/tree/449a835e
Diff: http://git-wip-us.apache.org/repos/asf/aurora/diff/449a835e
Branch: refs/heads/master
Commit: 449a835e9a446987cd9033345eb580030ed35cfa
Parents: 3380572
Author: Bill Farner <wf...@apache.org>
Authored: Tue Apr 21 11:51:51 2015 -0700
Committer: Bill Farner <wf...@apache.org>
Committed: Tue Apr 21 11:51:51 2015 -0700
----------------------------------------------------------------------
.../java/org/apache/aurora/benchmark/Tasks.java | 39 +-
.../aurora/scheduler/base/TaskTestUtil.java | 113 ++
.../scheduler/async/TaskSchedulerImplTest.java | 25 +-
.../scheduler/async/TaskSchedulerTest.java | 93 +-
.../apache/aurora/scheduler/base/JobsTest.java | 5 +-
.../aurora/scheduler/base/TaskTestUtil.java | 66 --
.../apache/aurora/scheduler/base/TasksTest.java | 21 +-
.../scheduler/state/StateManagerImplTest.java | 135 +--
.../scheduler/stats/ResourceCounterTest.java | 21 +-
.../scheduler/storage/StorageBackfillTest.java | 140 +--
.../scheduler/storage/backup/RecoveryTest.java | 25 +-
.../storage/db/DBJobUpdateStoreTest.java | 1076 ------------------
.../storage/db/DbJobUpdateStoreTest.java | 1061 +++++++++++++++++
.../scheduler/storage/mem/MemTaskStoreTest.java | 391 ++++---
.../storage/testing/StorageEntityUtil.java | 27 +-
.../scheduler/updater/InstanceUpdaterTest.java | 35 +
.../aurora/scheduler/updater/JobUpdaterIT.java | 25 +-
.../aurora/scheduler/updater/TaskUtil.java | 64 --
18 files changed, 1665 insertions(+), 1697 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/jmh/java/org/apache/aurora/benchmark/Tasks.java
----------------------------------------------------------------------
diff --git a/src/jmh/java/org/apache/aurora/benchmark/Tasks.java b/src/jmh/java/org/apache/aurora/benchmark/Tasks.java
index 23827ab..b4da057 100644
--- a/src/jmh/java/org/apache/aurora/benchmark/Tasks.java
+++ b/src/jmh/java/org/apache/aurora/benchmark/Tasks.java
@@ -20,17 +20,16 @@ import com.google.common.collect.Lists;
import com.twitter.common.quantity.Amount;
import com.twitter.common.quantity.Data;
-import org.apache.aurora.gen.AssignedTask;
import org.apache.aurora.gen.Constraint;
-import org.apache.aurora.gen.Identity;
import org.apache.aurora.gen.JobKey;
import org.apache.aurora.gen.LimitConstraint;
import org.apache.aurora.gen.ScheduleStatus;
import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
import org.apache.aurora.gen.TaskConstraint;
import org.apache.aurora.gen.TaskEvent;
import org.apache.aurora.gen.ValueConstraint;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
+import org.apache.aurora.scheduler.storage.entities.IJobKey;
import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
/**
@@ -134,25 +133,23 @@ final class Tasks {
String taskId =
jobKey.getRole() + "-" + jobKey.getEnvironment() + "-" + i + "-" + (uuidStart + i);
- tasks.add(IScheduledTask.build(new ScheduledTask()
- .setTaskEvents(Lists.newArrayList(new TaskEvent(0, ScheduleStatus.PENDING)))
+ ScheduledTask builder = TaskTestUtil.makeTask(taskId, IJobKey.build(jobKey))
+ .newBuilder()
.setStatus(scheduleStatus)
- .setAssignedTask(new AssignedTask()
- .setInstanceId(i)
- .setTaskId(taskId)
- .setTask(new TaskConfig()
- .setConstraints(constraints.build())
- .setNumCpus(cpu)
- .setRamMb(ram.as(Data.MB))
- .setDiskMb(disk.as(Data.MB))
- .setProduction(isProduction)
- .setRequestedPorts(ImmutableSet.<String>of())
- .setJob(jobKey)
- .setJobName(jobKey.getName())
- .setEnvironment(jobKey.getEnvironment())
- .setOwner(new Identity()
- .setRole(jobKey.getRole())
- .setUser(String.format(USER_FORMAT, taskId)))))));
+ .setTaskEvents(Lists.newArrayList(
+ new TaskEvent(0, ScheduleStatus.PENDING),
+ new TaskEvent(1, scheduleStatus)));
+ builder.getAssignedTask()
+ .setInstanceId(i)
+ .setTaskId(taskId);
+ builder.getAssignedTask().getTask()
+ .setConstraints(constraints.build())
+ .setNumCpus(cpu)
+ .setRamMb(ram.as(Data.MB))
+ .setDiskMb(disk.as(Data.MB))
+ .setProduction(isProduction)
+ .setRequestedPorts(ImmutableSet.<String>of());
+ tasks.add(IScheduledTask.build(builder));
}
return tasks.build();
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/main/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/aurora/scheduler/base/TaskTestUtil.java b/src/main/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
new file mode 100644
index 0000000..2f42851
--- /dev/null
+++ b/src/main/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
@@ -0,0 +1,113 @@
+/**
+ * Licensed 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.aurora.scheduler.base;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+
+import org.apache.aurora.gen.AssignedTask;
+import org.apache.aurora.gen.Constraint;
+import org.apache.aurora.gen.Container;
+import org.apache.aurora.gen.DockerContainer;
+import org.apache.aurora.gen.ExecutorConfig;
+import org.apache.aurora.gen.Identity;
+import org.apache.aurora.gen.LimitConstraint;
+import org.apache.aurora.gen.Metadata;
+import org.apache.aurora.gen.ScheduleStatus;
+import org.apache.aurora.gen.ScheduledTask;
+import org.apache.aurora.gen.TaskConfig;
+import org.apache.aurora.gen.TaskConstraint;
+import org.apache.aurora.gen.TaskEvent;
+import org.apache.aurora.gen.ValueConstraint;
+import org.apache.aurora.scheduler.storage.entities.IJobKey;
+import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
+import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
+
+/**
+ * Convenience methods for working with tasks.
+ * <p>
+ * TODO(wfarner): This lives in under src/main only so benchmarks can access it. Reconsider the
+ * project layout so this is not necessary.
+ */
+public final class TaskTestUtil {
+
+ public static final IJobKey JOB = JobKeys.from("role", "env", "job");
+
+ private TaskTestUtil() {
+ // Utility class.
+ }
+
+ public static ITaskConfig makeConfig(IJobKey job) {
+ return ITaskConfig.build(new TaskConfig()
+ .setJob(job.newBuilder())
+ .setJobName(job.getName())
+ .setEnvironment(job.getEnvironment())
+ .setOwner(new Identity(job.getRole(), job.getRole() + "-user"))
+ .setIsService(true)
+ .setNumCpus(1.0)
+ .setRamMb(1024)
+ .setDiskMb(1024)
+ .setPriority(1)
+ .setMaxTaskFailures(-1)
+ .setProduction(true)
+ .setConstraints(ImmutableSet.of(
+ new Constraint(
+ "valueConstraint",
+ TaskConstraint.value(
+ new ValueConstraint(false, ImmutableSet.of("value1", "value2")))),
+ new Constraint(
+ "limitConstraint",
+ TaskConstraint.limit(new LimitConstraint(5)))))
+ .setRequestedPorts(ImmutableSet.of("http"))
+ .setTaskLinks(ImmutableMap.of("http", "link", "admin", "otherLink"))
+ .setContactEmail("foo@bar.com")
+ .setMetadata(ImmutableSet.of(new Metadata("key", "value")))
+ .setExecutorConfig(new ExecutorConfig("name", "config"))
+ .setContainer(Container.docker(new DockerContainer("imagename"))));
+ }
+
+ public static IScheduledTask makeTask(String id, IJobKey job) {
+ return IScheduledTask.build(new ScheduledTask()
+ .setStatus(ScheduleStatus.PENDING)
+ .setTaskEvents(ImmutableList.of(
+ new TaskEvent(100L, ScheduleStatus.PENDING)
+ .setMessage("message")
+ .setScheduler("scheduler"),
+ new TaskEvent(101L, ScheduleStatus.ASSIGNED)
+ .setMessage("message")
+ .setScheduler("scheduler2")))
+ .setAncestorId("ancestor")
+ .setFailureCount(3)
+ .setAssignedTask(new AssignedTask()
+ .setInstanceId(2)
+ .setTaskId(id)
+ .setAssignedPorts(ImmutableMap.of("http", 1000))
+ .setTask(makeConfig(job).newBuilder())));
+ }
+
+ public static IScheduledTask addStateTransition(
+ IScheduledTask task,
+ ScheduleStatus status,
+ long timestamp) {
+
+ ScheduledTask builder = task.newBuilder();
+ builder.setStatus(status);
+ builder.addToTaskEvents(new TaskEvent()
+ .setTimestamp(timestamp)
+ .setStatus(status)
+ .setScheduler("scheduler"));
+ return IScheduledTask.build(builder);
+ }
+}
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerImplTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerImplTest.java b/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerImplTest.java
index d879d33..bd1aaa1 100644
--- a/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerImplTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerImplTest.java
@@ -20,24 +20,21 @@ import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.TypeLiteral;
-
import com.twitter.common.stats.StatsProvider;
import com.twitter.common.testing.easymock.EasyMockTest;
import com.twitter.common.util.Clock;
-import org.apache.aurora.gen.AssignedTask;
import org.apache.aurora.gen.HostAttributes;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.JobKey;
import org.apache.aurora.gen.MaintenanceMode;
import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
import org.apache.aurora.scheduler.HostOffer;
import org.apache.aurora.scheduler.async.TaskScheduler.TaskSchedulerImpl;
import org.apache.aurora.scheduler.async.preemptor.BiCache;
import org.apache.aurora.scheduler.async.preemptor.Preemptor;
+import org.apache.aurora.scheduler.base.JobKeys;
import org.apache.aurora.scheduler.base.Query;
import org.apache.aurora.scheduler.base.TaskGroupKey;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
import org.apache.aurora.scheduler.base.Tasks;
import org.apache.aurora.scheduler.events.EventSink;
import org.apache.aurora.scheduler.events.PubsubEvent.TaskStateChange;
@@ -75,8 +72,10 @@ import static org.junit.Assert.assertTrue;
public class TaskSchedulerImplTest extends EasyMockTest {
- private static final IScheduledTask TASK_A = makeTask("a");
- private static final IScheduledTask TASK_B = makeTask("b");
+ private static final IScheduledTask TASK_A =
+ TaskTestUtil.makeTask("a", JobKeys.from("a", "a", "a"));
+ private static final IScheduledTask TASK_B =
+ TaskTestUtil.makeTask("b", JobKeys.from("b", "b", "b"));
private static final HostOffer OFFER = new HostOffer(
Offers.makeOffer("OFFER_A", "HOST_A"),
IHostAttributes.build(new HostAttributes().setMode(MaintenanceMode.NONE)));
@@ -276,18 +275,6 @@ public class TaskSchedulerImplTest extends EasyMockTest {
assignAndAssert(Result.SUCCESS, GROUP_A, OFFER, assignment);
}
- private static IScheduledTask makeTask(String taskId) {
- return IScheduledTask.build(new ScheduledTask()
- .setAssignedTask(new AssignedTask()
- .setInstanceId(0)
- .setTaskId(taskId)
- .setTask(new TaskConfig()
- .setJob(new JobKey("role-" + taskId, "env-" + taskId, "job-" + taskId))
- .setJobName("job-" + taskId)
- .setOwner(new Identity().setRole("role-" + taskId).setUser("user-" + taskId))
- .setEnvironment("env-" + taskId))));
- }
-
private static class AssignmentCapture {
public Capture<Function<HostOffer, Assignment>> assigner = createCapture();
public Capture<TaskGroupKey> groupKey = createCapture();
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerTest.java b/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerTest.java
index 798ff6e..9035484 100644
--- a/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/async/TaskSchedulerTest.java
@@ -17,6 +17,8 @@ import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
@@ -28,11 +30,8 @@ import com.twitter.common.quantity.Time;
import com.twitter.common.testing.easymock.EasyMockTest;
import com.twitter.common.util.BackoffStrategy;
-import org.apache.aurora.gen.AssignedTask;
import org.apache.aurora.gen.Attribute;
import org.apache.aurora.gen.HostAttributes;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.JobKey;
import org.apache.aurora.gen.MaintenanceMode;
import org.apache.aurora.gen.ScheduleStatus;
import org.apache.aurora.gen.ScheduledTask;
@@ -43,8 +42,10 @@ import org.apache.aurora.scheduler.async.OfferManager.OfferReturnDelay;
import org.apache.aurora.scheduler.async.TaskScheduler.TaskSchedulerImpl;
import org.apache.aurora.scheduler.async.preemptor.BiCache;
import org.apache.aurora.scheduler.async.preemptor.Preemptor;
+import org.apache.aurora.scheduler.base.JobKeys;
import org.apache.aurora.scheduler.base.Query;
import org.apache.aurora.scheduler.base.TaskGroupKey;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
import org.apache.aurora.scheduler.base.Tasks;
import org.apache.aurora.scheduler.events.PubsubEvent;
import org.apache.aurora.scheduler.events.PubsubEvent.TaskStateChange;
@@ -61,6 +62,7 @@ import org.apache.aurora.scheduler.storage.Storage.MutableStoreProvider;
import org.apache.aurora.scheduler.storage.Storage.MutateWork;
import org.apache.aurora.scheduler.storage.Storage.StorageException;
import org.apache.aurora.scheduler.storage.TaskStore;
+import org.apache.aurora.scheduler.storage.entities.IAssignedTask;
import org.apache.aurora.scheduler.storage.entities.IHostAttributes;
import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
@@ -85,6 +87,7 @@ import static org.apache.aurora.gen.ScheduleStatus.KILLED;
import static org.apache.aurora.gen.ScheduleStatus.LOST;
import static org.apache.aurora.gen.ScheduleStatus.PENDING;
import static org.apache.aurora.gen.ScheduleStatus.RUNNING;
+import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTask;
import static org.apache.aurora.scheduler.filter.AttributeAggregate.EMPTY;
import static org.apache.mesos.Protos.Offer;
import static org.easymock.EasyMock.capture;
@@ -221,37 +224,33 @@ public class TaskSchedulerTest extends EasyMockTest {
public void testNoOffers() {
Capture<Runnable> timeoutCapture = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
expectTaskGroupBackoff(FIRST_SCHEDULE_DELAY_MS, 10);
- IScheduledTask task = makeTask("a");
- expectPreemptorCall(task);
+ IScheduledTask task = createTask("a");
+ expectPreemptorCall(task.getAssignedTask());
expectReservationCheck(task);
replayAndCreateScheduler();
- changeState(makeTask("a"), INIT, PENDING);
+ changeState(task, INIT, PENDING);
timeoutCapture.getValue().run();
}
- private IScheduledTask makeTask(String taskId) {
- return IScheduledTask.build(new ScheduledTask()
- .setAssignedTask(new AssignedTask()
- .setInstanceId(0)
- .setTaskId(taskId)
- .setTask(new TaskConfig()
- .setJob(new JobKey("role-" + taskId, "env-" + taskId, "job-" + taskId))
- .setJobName("job-" + taskId)
- .setOwner(new Identity().setRole("role-" + taskId).setUser("user-" + taskId))
- .setEnvironment("env-" + taskId))));
+ private IScheduledTask createTask(String taskId) {
+ return createTask(taskId, null);
+ }
+
+ private IScheduledTask createTask(String taskId, @Nullable ScheduleStatus status) {
+ return setStatus(makeTask(taskId, TaskTestUtil.JOB), status);
}
- private IScheduledTask makeTask(String taskId, ScheduleStatus status) {
- return IScheduledTask.build(makeTask(taskId).newBuilder().setStatus(status));
+ private IScheduledTask setStatus(IScheduledTask task, @Nullable ScheduleStatus status) {
+ return IScheduledTask.build(task.newBuilder().setStatus(status));
}
@Test
public void testLoadFromStorage() {
- final IScheduledTask a = makeTask("a", KILLED);
- final IScheduledTask b = makeTask("b", PENDING);
- final IScheduledTask c = makeTask("c", RUNNING);
+ final IScheduledTask a = createTask("a", KILLED);
+ final IScheduledTask b = createTask("b", PENDING);
+ final IScheduledTask c = createTask("c", RUNNING);
expect(rescheduleCalculator.getStartupScheduleDelayMs(b)).andReturn(10L);
expectTaskRetryIn(10);
@@ -276,7 +275,7 @@ public class TaskSchedulerTest extends EasyMockTest {
replayAndCreateScheduler();
- taskGroups.taskChangedState(TaskStateChange.transition(makeTask("a", PENDING), INIT));
+ taskGroups.taskChangedState(TaskStateChange.transition(createTask("a", PENDING), INIT));
timeoutCapture.getValue().run();
}
@@ -306,40 +305,40 @@ public class TaskSchedulerTest extends EasyMockTest {
expectAnyMaintenanceCalls();
expectOfferDeclineIn(10);
- IScheduledTask task = makeTask("a", PENDING);
- TaskInfo mesosTask = makeTaskInfo(task);
+ IScheduledTask taskA = createTask("a", PENDING);
+ TaskInfo mesosTask = makeTaskInfo(taskA);
Capture<Runnable> timeoutCapture = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
expectNoReservation(SLAVE_A).times(2);
- expectReservationCheck(task);
- expectMaybeAssign(OFFER_A, task, EMPTY).andReturn(Assignment.failure());
- expectPreemptorCall(task);
+ expectReservationCheck(taskA);
+ expectMaybeAssign(OFFER_A, taskA, EMPTY).andReturn(Assignment.failure());
+ expectPreemptorCall(taskA.getAssignedTask());
Capture<Runnable> timeoutCapture2 = expectTaskGroupBackoff(FIRST_SCHEDULE_DELAY_MS, 10);
- expectMaybeAssign(OFFER_A, task, EMPTY).andReturn(Assignment.success(mesosTask));
+ expectMaybeAssign(OFFER_A, taskA, EMPTY).andReturn(Assignment.success(mesosTask));
driver.launchTask(OFFER_A.getOffer().getId(), mesosTask);
Capture<Runnable> timeoutCapture3 = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
expectTaskGroupBackoff(FIRST_SCHEDULE_DELAY_MS, 10);
- IScheduledTask taskB = makeTask("b");
+ IScheduledTask taskB = createTask("b");
expectReservationCheck(taskB);
- expectPreemptorCall(taskB);
+ expectPreemptorCall(taskB.getAssignedTask());
replayAndCreateScheduler();
offerManager.addOffer(OFFER_A);
- changeState(task, INIT, PENDING);
+ changeState(taskA, INIT, PENDING);
timeoutCapture.getValue().run();
timeoutCapture2.getValue().run();
// Ensure the offer was consumed.
- changeState(makeTask("b"), INIT, PENDING);
+ changeState(taskB, INIT, PENDING);
timeoutCapture3.getValue().run();
}
@Test
public void testDriverNotReady() {
- IScheduledTask task = makeTask("a", PENDING);
+ IScheduledTask task = createTask("a", PENDING);
TaskInfo mesosTask = TaskInfo.newBuilder()
.setName(Tasks.id(task))
.setTaskId(TaskID.newBuilder().setValue(Tasks.id(task)))
@@ -370,7 +369,7 @@ public class TaskSchedulerTest extends EasyMockTest {
@Test
public void testStorageException() {
- IScheduledTask task = makeTask("a", PENDING);
+ IScheduledTask task = createTask("a", PENDING);
TaskInfo mesosTask = TaskInfo.newBuilder()
.setName(Tasks.id(task))
.setTaskId(TaskID.newBuilder().setValue(Tasks.id(task)))
@@ -398,7 +397,7 @@ public class TaskSchedulerTest extends EasyMockTest {
@Test
public void testExpiration() {
- IScheduledTask task = makeTask("a", PENDING);
+ IScheduledTask task = createTask("a", PENDING);
Capture<Runnable> timeoutCapture = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
Capture<Runnable> offerExpirationCapture = expectOfferDeclineIn(10);
@@ -407,10 +406,10 @@ public class TaskSchedulerTest extends EasyMockTest {
expectReservationCheck(task).times(2);
expectMaybeAssign(OFFER_A, task, EMPTY).andReturn(Assignment.failure());
Capture<Runnable> timeoutCapture2 = expectTaskGroupBackoff(FIRST_SCHEDULE_DELAY_MS, 10);
- expectPreemptorCall(task);
+ expectPreemptorCall(task.getAssignedTask());
driver.declineOffer(OFFER_A.getOffer().getId());
expectTaskGroupBackoff(10, 20);
- expectPreemptorCall(task);
+ expectPreemptorCall(task.getAssignedTask());
replayAndCreateScheduler();
@@ -465,14 +464,14 @@ public class TaskSchedulerTest extends EasyMockTest {
expectOffer();
expectOffer();
- IScheduledTask taskA = makeTask("A", PENDING);
+ IScheduledTask taskA = createTask("A", PENDING);
TaskInfo mesosTaskA = makeTaskInfo(taskA);
expectNoReservation(SLAVE_A);
expectMaybeAssign(OFFER_A, taskA, EMPTY).andReturn(Assignment.success(mesosTaskA));
driver.launchTask(OFFER_A.getOffer().getId(), mesosTaskA);
Capture<Runnable> captureA = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
- IScheduledTask taskB = makeTask("B", PENDING);
+ IScheduledTask taskB = createTask("B", PENDING);
TaskInfo mesosTaskB = makeTaskInfo(taskB);
expectNoReservation(SLAVE_B);
expectMaybeAssign(OFFER_B, taskB, EMPTY).andReturn(Assignment.success(mesosTaskB));
@@ -499,14 +498,14 @@ public class TaskSchedulerTest extends EasyMockTest {
expectOffer();
expectOffer();
- IScheduledTask taskA = makeTask("A", PENDING);
+ IScheduledTask taskA = createTask("A", PENDING);
TaskInfo mesosTaskA = makeTaskInfo(taskA);
expectNoReservation(SLAVE_B);
expectMaybeAssign(OFFER_B, taskA, EMPTY).andReturn(Assignment.success(mesosTaskA));
driver.launchTask(OFFER_B.getOffer().getId(), mesosTaskA);
Capture<Runnable> captureA = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
- IScheduledTask taskB = makeTask("B", PENDING);
+ IScheduledTask taskB = createTask("B", PENDING);
TaskInfo mesosTaskB = makeTaskInfo(taskB);
HostOffer updatedOfferC = new HostOffer(
OFFER_C.getOffer(),
@@ -554,7 +553,7 @@ public class TaskSchedulerTest extends EasyMockTest {
expectAnyMaintenanceCalls();
- IScheduledTask jobA0 = makeTask("a0", PENDING);
+ IScheduledTask jobA0 = setStatus(makeTask("a0", JobKeys.from("a", "b", "c")), PENDING);
ScheduledTask jobA1Builder = jobA0.newBuilder();
jobA1Builder.getAssignedTask().setTaskId("a1");
@@ -566,7 +565,7 @@ public class TaskSchedulerTest extends EasyMockTest {
jobA2Builder.getAssignedTask().setInstanceId(2);
IScheduledTask jobA2 = IScheduledTask.build(jobA2Builder);
- IScheduledTask jobB0 = makeTask("b0", PENDING);
+ IScheduledTask jobB0 = setStatus(makeTask("b0", JobKeys.from("d", "e", "f")), PENDING);
expectNoReservation(SLAVE_A);
expectNoReservation(SLAVE_B);
@@ -607,14 +606,14 @@ public class TaskSchedulerTest extends EasyMockTest {
expectAnyMaintenanceCalls();
expectOfferDeclineIn(10);
- final IScheduledTask task = makeTask("a", PENDING);
+ final IScheduledTask task = createTask("a", PENDING);
Capture<Runnable> timeoutCapture = expectTaskRetryIn(FIRST_SCHEDULE_DELAY_MS);
expectNoReservation(SLAVE_A);
expectMaybeAssign(OFFER_A, task, EMPTY).andReturn(Assignment.failure());
expectTaskGroupBackoff(FIRST_SCHEDULE_DELAY_MS, 20);
expectReservationCheck(task);
- expectPreemptorCall(task);
+ expectPreemptorCall(task.getAssignedTask());
replayAndCreateScheduler();
@@ -662,9 +661,9 @@ public class TaskSchedulerTest extends EasyMockTest {
.setMode(mode)));
}
- private void expectPreemptorCall(IScheduledTask task) {
+ private void expectPreemptorCall(IAssignedTask task) {
expect(preemptor.attemptPreemptionFor(
- eq(task.getAssignedTask()),
+ eq(task),
eq(EMPTY),
EasyMock.<MutableStoreProvider>anyObject())).andReturn(Optional.<String>absent());
}
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/base/JobsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/base/JobsTest.java b/src/test/java/org/apache/aurora/scheduler/base/JobsTest.java
index a170fb6..986fd01 100644
--- a/src/test/java/org/apache/aurora/scheduler/base/JobsTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/base/JobsTest.java
@@ -25,12 +25,11 @@ import org.apache.aurora.scheduler.storage.entities.IJobStats;
import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
import org.junit.Test;
+import static org.apache.aurora.scheduler.base.TaskTestUtil.addStateTransition;
import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTask;
-import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTaskEvents;
import static org.junit.Assert.assertEquals;
public class JobsTest {
-
@Test
public void testGetJobStats() {
ImmutableList<IScheduledTask> tasks =
@@ -39,7 +38,7 @@ public class JobsTest {
.transform(new Function<ScheduleStatus, IScheduledTask>() {
@Override
public IScheduledTask apply(ScheduleStatus status) {
- return makeTask(status, makeTaskEvents(100, status));
+ return addStateTransition(makeTask("id", TaskTestUtil.JOB), status, 100L);
}
}).toList();
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/base/TaskTestUtil.java b/src/test/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
deleted file mode 100644
index b8b9c1b..0000000
--- a/src/test/java/org/apache/aurora/scheduler/base/TaskTestUtil.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/**
- * Licensed 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.aurora.scheduler.base;
-
-import java.util.List;
-
-import com.google.common.collect.ImmutableList;
-
-import org.apache.aurora.gen.AssignedTask;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.ScheduleStatus;
-import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
-import org.apache.aurora.gen.TaskEvent;
-import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
-
-/**
- * Convenience methods for working with tasks.
- */
-public final class TaskTestUtil {
-
- private TaskTestUtil() {
- // Utility class.
- }
-
- public static IScheduledTask makeTask(ScheduleStatus status, List<TaskEvent> taskEvents) {
- return IScheduledTask.build(new ScheduledTask()
- .setStatus(status)
- .setAssignedTask(new AssignedTask()
- .setTaskId("task_id")
- .setSlaveHost("host1")
- .setTask(new TaskConfig()
- .setJobName("job_a")
- .setOwner(new Identity("role_a", "role_a" + "-user"))))
- .setTaskEvents(taskEvents));
- }
-
- public static List<TaskEvent> makeTaskEvents(
- long startTs,
- ScheduleStatus status,
- ScheduleStatus... statuses) {
-
- ImmutableList.Builder<TaskEvent> taskEvents = ImmutableList.builder();
- taskEvents.add(makeTaskEvent(startTs, status));
- long increment = startTs;
- for (ScheduleStatus st : statuses) {
- taskEvents.add(makeTaskEvent(startTs + increment++, st));
- }
- return taskEvents.build();
- }
-
- private static TaskEvent makeTaskEvent(long ts, ScheduleStatus status) {
- return new TaskEvent().setTimestamp(ts).setStatus(status);
- }
-}
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/base/TasksTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/base/TasksTest.java b/src/test/java/org/apache/aurora/scheduler/base/TasksTest.java
index 2866b20..ed9a287 100644
--- a/src/test/java/org/apache/aurora/scheduler/base/TasksTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/base/TasksTest.java
@@ -22,8 +22,6 @@ import org.junit.Test;
import static org.apache.aurora.gen.ScheduleStatus.FINISHED;
import static org.apache.aurora.gen.ScheduleStatus.RUNNING;
-import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTask;
-import static org.apache.aurora.scheduler.base.TaskTestUtil.makeTaskEvents;
import static org.apache.aurora.scheduler.base.Tasks.getLatestActiveTask;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
@@ -43,12 +41,12 @@ public class TasksTest {
@Test
public void testLatestTransitionedTasks() {
- IScheduledTask f1 = makeTask(FINISHED, makeTaskEvents(100, FINISHED));
- IScheduledTask f2 = makeTask(FINISHED, makeTaskEvents(200, FINISHED));
- IScheduledTask f3 = makeTask(FINISHED, makeTaskEvents(300, FINISHED));
- IScheduledTask r1 = makeTask(RUNNING, makeTaskEvents(400, RUNNING));
- IScheduledTask r2 = makeTask(RUNNING, makeTaskEvents(500, RUNNING));
- IScheduledTask r3 = makeTask(RUNNING, makeTaskEvents(600, RUNNING));
+ IScheduledTask f1 = makeTask(FINISHED, 100);
+ IScheduledTask f2 = makeTask(FINISHED, 200);
+ IScheduledTask f3 = makeTask(FINISHED, 300);
+ IScheduledTask r1 = makeTask(RUNNING, 400);
+ IScheduledTask r2 = makeTask(RUNNING, 500);
+ IScheduledTask r3 = makeTask(RUNNING, 600);
try {
getLatestActiveTask(ImmutableList.<IScheduledTask>of());
@@ -78,4 +76,11 @@ public class TasksTest {
private void assertLatestTask(IScheduledTask expectedLatest, IScheduledTask... tasks) {
assertEquals(expectedLatest, getLatestActiveTask(ImmutableList.copyOf(tasks)));
}
+
+ private IScheduledTask makeTask(ScheduleStatus status, long timestamp) {
+ return TaskTestUtil.addStateTransition(
+ TaskTestUtil.makeTask("id-" + timestamp, TaskTestUtil.JOB),
+ status,
+ timestamp);
+ }
}
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/state/StateManagerImplTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/state/StateManagerImplTest.java b/src/test/java/org/apache/aurora/scheduler/state/StateManagerImplTest.java
index 7234fd3..c7fd3e5 100644
--- a/src/test/java/org/apache/aurora/scheduler/state/StateManagerImplTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/state/StateManagerImplTest.java
@@ -29,22 +29,25 @@ import com.twitter.common.testing.easymock.EasyMockTest;
import com.twitter.common.util.testing.FakeClock;
import org.apache.aurora.gen.AssignedTask;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.JobKey;
+import org.apache.aurora.gen.Attribute;
+import org.apache.aurora.gen.HostAttributes;
+import org.apache.aurora.gen.MaintenanceMode;
import org.apache.aurora.gen.ScheduleStatus;
import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
import org.apache.aurora.gen.TaskEvent;
import org.apache.aurora.scheduler.TaskIdGenerator;
import org.apache.aurora.scheduler.async.RescheduleCalculator;
import org.apache.aurora.scheduler.base.Query;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
import org.apache.aurora.scheduler.base.Tasks;
import org.apache.aurora.scheduler.events.EventSink;
import org.apache.aurora.scheduler.events.PubsubEvent;
import org.apache.aurora.scheduler.events.PubsubEvent.TaskStateChange;
import org.apache.aurora.scheduler.events.PubsubEvent.TasksDeleted;
import org.apache.aurora.scheduler.mesos.Driver;
+import org.apache.aurora.scheduler.storage.AttributeStore;
import org.apache.aurora.scheduler.storage.Storage;
+import org.apache.aurora.scheduler.storage.entities.IHostAttributes;
import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
import org.apache.aurora.scheduler.storage.mem.MemStorage;
@@ -75,9 +78,15 @@ import static org.junit.Assert.assertTrue;
public class StateManagerImplTest extends EasyMockTest {
- private static final String HOST_A = "host_a";
- private static final Identity JIM = new Identity("jim", "jim-user");
- private static final String MY_JOB = "myJob";
+ private static final IHostAttributes HOST_A = IHostAttributes.build(
+ new HostAttributes(
+ "hostA",
+ ImmutableSet.of(new Attribute("zone", ImmutableSet.of("1a"))))
+ .setSlaveId("slaveIdA")
+ .setMode(MaintenanceMode.NONE));
+ private static final ITaskConfig NON_SERVICE_CONFIG =
+ setIsService(TaskTestUtil.makeConfig(TaskTestUtil.JOB), false);
+ private static final ITaskConfig SERVICE_CONFIG = setIsService(NON_SERVICE_CONFIG, true);
private Driver driver;
private TaskIdGenerator taskIdGenerator;
@@ -101,6 +110,13 @@ public class StateManagerImplTest extends EasyMockTest {
taskIdGenerator,
eventSink,
rescheduleCalculator);
+ storage.write(new Storage.MutateWork.NoResult.Quiet() {
+ @Override
+ protected void execute(Storage.MutableStoreProvider storeProvider) {
+ AttributeStore.Mutable attributeStore = storeProvider.getAttributeStore();
+ attributeStore.saveHostAttributes(HOST_A);
+ }
+ });
}
private static class StateChangeMatcher implements IArgumentMatcher {
@@ -167,14 +183,13 @@ public class StateManagerImplTest extends EasyMockTest {
@Test
public void testAddTasks() {
- ITaskConfig task = makeTask(JIM, MY_JOB);
String taskId = "a";
- expect(taskIdGenerator.generate(task, 3)).andReturn(taskId);
+ expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 3)).andReturn(taskId);
expectStateTransitions(taskId, INIT, PENDING);
control.replay();
- insertTask(task, 3);
+ insertTask(NON_SERVICE_CONFIG, 3);
ScheduledTask expected = new ScheduledTask()
.setStatus(PENDING)
.setTaskEvents(ImmutableList.of(new TaskEvent()
@@ -184,37 +199,36 @@ public class StateManagerImplTest extends EasyMockTest {
.setAssignedTask(new AssignedTask()
.setInstanceId(3)
.setTaskId(taskId)
- .setTask(task.newBuilder()));
- assertEquals(ImmutableSet.of(IScheduledTask.build(expected)),
+ .setTask(NON_SERVICE_CONFIG.newBuilder()));
+ assertEquals(
+ ImmutableSet.of(IScheduledTask.build(expected)),
Storage.Util.fetchTasks(storage, Query.taskScoped(taskId)));
}
@Test
public void testKillPendingTask() {
- ITaskConfig task = makeTask(JIM, MY_JOB);
String taskId = "a";
- expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+ expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
expectStateTransitions(taskId, INIT, PENDING);
eventSink.post(matchTasksDeleted(taskId));
control.replay();
- insertTask(task, 0);
+ insertTask(NON_SERVICE_CONFIG, 0);
assertEquals(true, changeState(taskId, KILLING));
assertEquals(false, changeState(taskId, KILLING));
}
@Test
public void testKillRunningTask() {
- ITaskConfig task = makeTask(JIM, MY_JOB);
String taskId = "a";
- expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+ expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, RUNNING, KILLING, KILLED);
driver.killTask(EasyMock.<String>anyObject());
control.replay();
- insertTask(task, 0);
+ insertTask(NON_SERVICE_CONFIG, 0);
assignTask(taskId, HOST_A);
assertEquals(true, changeState(taskId, RUNNING));
assertEquals(true, changeState(taskId, KILLING));
@@ -224,16 +238,15 @@ public class StateManagerImplTest extends EasyMockTest {
@Test
public void testLostKillingTask() {
- ITaskConfig task = makeTask(JIM, MY_JOB);
String taskId = "a";
- expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+ expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, RUNNING, KILLING, LOST);
driver.killTask(EasyMock.<String>anyObject());
control.replay();
- insertTask(task, 0);
+ insertTask(NON_SERVICE_CONFIG, 0);
assignTask(taskId, HOST_A);
changeState(taskId, RUNNING);
@@ -244,8 +257,7 @@ public class StateManagerImplTest extends EasyMockTest {
@Test
public void testNestedEvents() {
final String id = "a";
- ITaskConfig task = makeTask(JIM, MY_JOB);
- expect(taskIdGenerator.generate(task, 0)).andReturn(id);
+ expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(id);
// Trigger an event that produces a side-effect and a PubSub event .
eventSink.post(matchStateChange(id, INIT, PENDING));
@@ -262,26 +274,29 @@ public class StateManagerImplTest extends EasyMockTest {
control.replay();
- insertTask(task, 0);
+ insertTask(NON_SERVICE_CONFIG, 0);
}
@Test
public void testDeletePendingTask() {
- ITaskConfig task = makeTask(JIM, MY_JOB);
String taskId = "a";
- expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+ expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
expectStateTransitions(taskId, INIT, PENDING);
eventSink.post(matchTasksDeleted(taskId));
control.replay();
- insertTask(task, 0);
+ insertTask(NON_SERVICE_CONFIG, 0);
changeState(taskId, KILLING);
}
+ private static ITaskConfig setIsService(ITaskConfig config, boolean service) {
+ return ITaskConfig.build(config.newBuilder().setIsService(service));
+ }
+
@Test
public void testThrottleTask() {
- ITaskConfig task = ITaskConfig.build(makeTask(JIM, MY_JOB).newBuilder().setIsService(true));
+ ITaskConfig task = setIsService(NON_SERVICE_CONFIG, true);
String taskId = "a";
expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, RUNNING, FAILED);
@@ -317,19 +332,18 @@ public class StateManagerImplTest extends EasyMockTest {
@Test
public void testIncrementFailureCount() {
- ITaskConfig task = ITaskConfig.build(makeTask(JIM, MY_JOB).newBuilder().setIsService(true));
String taskId = "a";
- expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+ expect(taskIdGenerator.generate(SERVICE_CONFIG, 0)).andReturn(taskId);
expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, RUNNING, FAILED);
String taskId2 = "a2";
- expect(taskIdGenerator.generate(task, 0)).andReturn(taskId2);
+ expect(taskIdGenerator.generate(SERVICE_CONFIG, 0)).andReturn(taskId2);
noFlappingPenalty();
expectStateTransitions(taskId2, INIT, PENDING);
control.replay();
- insertTask(task, 0);
+ insertTask(SERVICE_CONFIG, 0);
assignTask(taskId, HOST_A);
changeState(taskId, RUNNING);
@@ -340,16 +354,20 @@ public class StateManagerImplTest extends EasyMockTest {
assertEquals(1, rescheduledTask.getFailureCount());
}
+ private static ITaskConfig setMaxFailures(ITaskConfig config, int maxFailures) {
+ return ITaskConfig.build(config.newBuilder().setMaxTaskFailures(maxFailures));
+ }
+
@Test
public void testCasTaskPresent() {
- ITaskConfig task = makeTask(JIM, MY_JOB);
String taskId = "a";
- expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+ ITaskConfig config = setMaxFailures(NON_SERVICE_CONFIG, 1);
+ expect(taskIdGenerator.generate(config, 0)).andReturn(taskId);
expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, FAILED);
control.replay();
- insertTask(task, 0);
+ insertTask(config, 0);
assignTask(taskId, HOST_A);
assertFalse(changeState(
taskId,
@@ -376,15 +394,14 @@ public class StateManagerImplTest extends EasyMockTest {
@Test
public void testDeleteTasks() {
- ITaskConfig task = makeTask(JIM, MY_JOB);
final String taskId = "a";
- expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+ expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
expectStateTransitions(taskId, INIT, PENDING, ASSIGNED, RUNNING, FINISHED);
eventSink.post(matchTasksDeleted(taskId));
control.replay();
- insertTask(task, 0);
+ insertTask(NON_SERVICE_CONFIG, 0);
assignTask(taskId, HOST_A);
changeState(taskId, RUNNING);
changeState(taskId, FINISHED);
@@ -394,14 +411,16 @@ public class StateManagerImplTest extends EasyMockTest {
stateManager.deleteTasks(storeProvider, ImmutableSet.of(taskId));
}
});
+ }
+ private static ITaskConfig setRequestedPorts(ITaskConfig config, Set<String> portNames) {
+ return ITaskConfig.build(config.newBuilder().setRequestedPorts(portNames));
}
@Test
public void testPortResource() throws Exception {
Set<String> requestedPorts = ImmutableSet.of("one", "two", "three");
- ITaskConfig task = ITaskConfig.build(makeTask(JIM, MY_JOB).newBuilder()
- .setRequestedPorts(requestedPorts));
+ ITaskConfig task = setRequestedPorts(NON_SERVICE_CONFIG, requestedPorts);
String taskId = "a";
expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
@@ -423,8 +442,7 @@ public class StateManagerImplTest extends EasyMockTest {
@Test
public void testPortResourceResetAfterReschedule() throws Exception {
Set<String> requestedPorts = ImmutableSet.of("one");
- ITaskConfig task = ITaskConfig.build(makeTask(JIM, MY_JOB).newBuilder()
- .setRequestedPorts(requestedPorts));
+ ITaskConfig task = setRequestedPorts(NON_SERVICE_CONFIG, requestedPorts);
String taskId = "a";
expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
@@ -458,7 +476,7 @@ public class StateManagerImplTest extends EasyMockTest {
protected void execute(Storage.MutableStoreProvider storeProvider) {
stateManager.insertPendingTasks(
storeProvider,
- makeTask(JIM, MY_JOB),
+ NON_SERVICE_CONFIG,
ImmutableSet.<Integer>of());
}
});
@@ -466,26 +484,24 @@ public class StateManagerImplTest extends EasyMockTest {
@Test(expected = IllegalArgumentException.class)
public void insertPendingInstancesInstanceCollision() {
- ITaskConfig task = makeTask(JIM, MY_JOB);
String taskId = "a";
- expect(taskIdGenerator.generate(task, 0)).andReturn(taskId).times(2);
+ expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId).times(2);
expectStateTransitions(taskId, INIT, PENDING);
control.replay();
- insertTask(task, 0);
+ insertTask(NON_SERVICE_CONFIG, 0);
Iterables.getOnlyElement(Storage.Util.fetchTasks(storage, Query.taskScoped(taskId)));
- insertTask(task, 0);
+ insertTask(NON_SERVICE_CONFIG, 0);
}
@Test
public void testAssignTaskPubsub() {
// This test ensures the pubsub events emitted by assigning tasks have slave id and host set.
- ITaskConfig task = makeTask(JIM, MY_JOB);
String taskId = "a";
- expect(taskIdGenerator.generate(task, 0)).andReturn(taskId);
+ expect(taskIdGenerator.generate(NON_SERVICE_CONFIG, 0)).andReturn(taskId);
expectStateTransitions(taskId, INIT, PENDING);
@@ -494,13 +510,13 @@ public class StateManagerImplTest extends EasyMockTest {
control.replay();
- insertTask(task, 0);
+ insertTask(NON_SERVICE_CONFIG, 0);
assignTask(taskId, HOST_A);
TaskStateChange change = taskStateChangeCapture.getValue();
assertEquals(ASSIGNED, change.getNewState());
- assertEquals(HOST_A, change.getTask().getAssignedTask().getSlaveHost());
- assertEquals(HOST_A, change.getTask().getAssignedTask().getSlaveId());
+ assertEquals(HOST_A.getHost(), change.getTask().getAssignedTask().getSlaveHost());
+ assertEquals(HOST_A.getSlaveId(), change.getTask().getAssignedTask().getSlaveId());
}
private void expectStateTransitions(
@@ -561,22 +577,13 @@ public class StateManagerImplTest extends EasyMockTest {
Optional.<String>absent());
}
- private static ITaskConfig makeTask(Identity owner, String job) {
- return ITaskConfig.build(new TaskConfig()
- .setJob(new JobKey(owner.getRole(), "devel", job))
- .setOwner(owner)
- .setEnvironment("devel")
- .setJobName(job)
- .setRequestedPorts(ImmutableSet.<String>of()));
- }
-
- private void assignTask(String taskId, String host) {
+ private void assignTask(String taskId, IHostAttributes host) {
assignTask(taskId, host, ImmutableMap.<String, Integer>of());
}
private void assignTask(
final String taskId,
- final String host,
+ final IHostAttributes host,
final Map<String, Integer> ports) {
storage.write(new Storage.MutateWork.NoResult.Quiet() {
@@ -585,8 +592,8 @@ public class StateManagerImplTest extends EasyMockTest {
stateManager.assignTask(
storeProvider,
taskId,
- host,
- SlaveID.newBuilder().setValue(host).build(),
+ host.getHost(),
+ SlaveID.newBuilder().setValue(host.getSlaveId()).build(),
ports);
}
});
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/stats/ResourceCounterTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/stats/ResourceCounterTest.java b/src/test/java/org/apache/aurora/scheduler/stats/ResourceCounterTest.java
index e5f3adf..82e9c76 100644
--- a/src/test/java/org/apache/aurora/scheduler/stats/ResourceCounterTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/stats/ResourceCounterTest.java
@@ -21,10 +21,7 @@ import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
-import org.apache.aurora.gen.AssignedTask;
import org.apache.aurora.gen.Constraint;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.JobKey;
import org.apache.aurora.gen.ResourceAggregate;
import org.apache.aurora.gen.ScheduleStatus;
import org.apache.aurora.gen.ScheduledTask;
@@ -33,6 +30,7 @@ import org.apache.aurora.gen.TaskConstraint;
import org.apache.aurora.gen.ValueConstraint;
import org.apache.aurora.scheduler.base.JobKeys;
import org.apache.aurora.scheduler.base.Query;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
import org.apache.aurora.scheduler.configuration.ConfigurationManager;
import org.apache.aurora.scheduler.storage.Storage;
import org.apache.aurora.scheduler.storage.entities.IJobKey;
@@ -167,28 +165,21 @@ public class ResourceCounterTest {
ScheduleStatus status,
Optional<String> dedicated) {
- TaskConfig task = new TaskConfig()
- .setJob(new JobKey(role, "test", job))
- .setOwner(new Identity().setRole(role))
- .setEnvironment("test")
- .setJobName(job)
+ ScheduledTask task = TaskTestUtil.makeTask(id, JobKeys.from(role, "test", job)).newBuilder();
+ TaskConfig config = task.getAssignedTask().getTask()
.setNumCpus(numCpus)
.setRamMb(ramMb)
.setDiskMb(diskMb)
.setProduction(production);
if (dedicated.isPresent()) {
- task.addToConstraints(new Constraint(
+ config.addToConstraints(new Constraint(
ConfigurationManager.DEDICATED_ATTRIBUTE,
TaskConstraint.value(new ValueConstraint(false, ImmutableSet.of(dedicated.get())))));
}
- return IScheduledTask.build(new ScheduledTask()
- .setStatus(status)
- .setAssignedTask(
- new AssignedTask()
- .setTaskId(id)
- .setTask(task)));
+ task.setStatus(status);
+ return IScheduledTask.build(task);
}
private void insertTasks(final IScheduledTask... tasks) {
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/StorageBackfillTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/StorageBackfillTest.java b/src/test/java/org/apache/aurora/scheduler/storage/StorageBackfillTest.java
index 90a05ba..254b231 100644
--- a/src/test/java/org/apache/aurora/scheduler/storage/StorageBackfillTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/storage/StorageBackfillTest.java
@@ -15,50 +15,34 @@ package org.apache.aurora.scheduler.storage;
import java.util.Set;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import org.apache.aurora.gen.AssignedTask;
-import org.apache.aurora.gen.Constraint;
import org.apache.aurora.gen.Container;
-import org.apache.aurora.gen.ExecutorConfig;
-import org.apache.aurora.gen.Identity;
import org.apache.aurora.gen.JobConfiguration;
-import org.apache.aurora.gen.JobKey;
import org.apache.aurora.gen.MesosContainer;
import org.apache.aurora.gen.ScheduledTask;
import org.apache.aurora.gen.TaskConfig;
-import org.apache.aurora.gen.TaskEvent;
-import org.apache.aurora.scheduler.base.JobKeys;
import org.apache.aurora.scheduler.base.Query;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
import org.apache.aurora.scheduler.configuration.ConfigurationManager;
import org.apache.aurora.scheduler.configuration.SanitizedConfiguration;
import org.apache.aurora.scheduler.storage.entities.IJobConfiguration;
-import org.apache.aurora.scheduler.storage.entities.IJobKey;
import org.apache.aurora.scheduler.storage.entities.IScheduledTask;
-import org.apache.aurora.scheduler.storage.entities.ITaskConfig;
import org.apache.aurora.scheduler.storage.mem.MemStorage;
import org.junit.Before;
import org.junit.Test;
-import static org.apache.aurora.gen.ScheduleStatus.PENDING;
-import static org.apache.aurora.gen.ScheduleStatus.RUNNING;
import static org.junit.Assert.assertEquals;
+/**
+ * TODO(wfarner): Data store constraints (not null, valid relations) have made this test of little
+ * value other than for coverage. Rethink.
+ */
public class StorageBackfillTest {
- private static final String ROLE = "Test_Role_A";
- private static final String USER = "Test_User_A";
- private static final Identity OWNER = new Identity(ROLE, USER);
- private static final String ENV = "Test_Env";
- private static final String JOB_NAME = "Test_Job";
- private static final IJobKey JOB_KEY = JobKeys.from(ROLE, ENV, JOB_NAME);
- private static final int ONE_GB = 1024;
- private static final String TASK_ID = "task_id";
- private static final ExecutorConfig EXECUTOR_CONFIG =
- new ExecutorConfig("AuroraExecutor", "executorConfig");
+ // By default, only the mesos container is allowed by ConfigurationManager.
+ private static final IScheduledTask TASK =
+ setMesosContainer(TaskTestUtil.makeTask("task_id", TaskTestUtil.JOB));
private Storage storage;
@@ -68,40 +52,14 @@ public class StorageBackfillTest {
}
@Test
- public void testLoadTasksFromStorage() throws Exception {
- final TaskConfig storedTask = defaultTask();
-
- storage.write(new Storage.MutateWork.NoResult.Quiet() {
- @Override
- protected void execute(Storage.MutableStoreProvider storeProvider) {
- storeProvider.getUnsafeTaskStore().saveTasks(ImmutableSet.of(
- IScheduledTask.build(new ScheduledTask()
- .setStatus(PENDING)
- .setTaskEvents(ImmutableList.of(new TaskEvent(100, PENDING)))
- .setAssignedTask(new AssignedTask()
- .setTaskId(TASK_ID)
- .setInstanceId(0)
- .setTask(storedTask)))));
- }
- });
-
- backfill();
-
- // Since task fields are backfilled with defaults, additional flags should be filled.
- ITaskConfig expected = ITaskConfig.build(new TaskConfig(storedTask)
- .setJob(JOB_KEY.newBuilder())
- .setProduction(false)
- .setMaxTaskFailures(1)
- .setExecutorConfig(EXECUTOR_CONFIG)
- .setContainer(Container.mesos(new MesosContainer()))
- .setConstraints(ImmutableSet.of(ConfigurationManager.hostLimitConstraint(1))));
-
- assertEquals(expected, getTask(TASK_ID).getAssignedTask().getTask());
- }
-
- @Test
public void testJobConfigurationBackfill() throws Exception {
- final JobConfiguration config = makeJobConfig(JOB_KEY, defaultTask(), 1);
+ TaskConfig task = TASK.getAssignedTask().getTask().newBuilder();
+ final JobConfiguration config = new JobConfiguration()
+ .setOwner(task.getOwner())
+ .setKey(task.getJob())
+ .setInstanceCount(1)
+ .setTaskConfig(task);
+
SanitizedConfiguration expected =
SanitizedConfiguration.fromUnsanitized(IJobConfiguration.build(config));
@@ -128,25 +86,11 @@ public class StorageBackfillTest {
}
@Test
- public void testBackfillTaskJob() throws Exception {
- TaskConfig task = defaultTask();
- ConfigurationManager.applyDefaultsIfUnset(task);
- task.unsetJob();
-
- IScheduledTask noJobKey = IScheduledTask.build(new ScheduledTask()
- .setStatus(RUNNING)
- .setAssignedTask(new AssignedTask()
- .setInstanceId(0)
- .setTaskId("nojobkey")
- .setTask(task)));
- IScheduledTask nullJobKeyFields = IScheduledTask.build(new ScheduledTask()
- .setStatus(RUNNING)
- .setAssignedTask(new AssignedTask()
- .setInstanceId(1)
- .setTaskId("nulled_fields")
- .setTask(task.setJob(new JobKey()))));
-
- final Set<IScheduledTask> backfilledTasks = ImmutableSet.of(noJobKey, nullJobKeyFields);
+ public void testBackfillTask() throws Exception {
+ ScheduledTask task = TASK.newBuilder();
+ ConfigurationManager.applyDefaultsIfUnset(task.getAssignedTask().getTask());
+
+ final Set<IScheduledTask> backfilledTasks = ImmutableSet.of(IScheduledTask.build(task));
storage.write(new Storage.MutateWork.NoResult.Quiet() {
@Override
protected void execute(Storage.MutableStoreProvider storeProvider) {
@@ -155,18 +99,9 @@ public class StorageBackfillTest {
});
backfill();
- ScheduledTask noJobKeyBackfilled = noJobKey.newBuilder();
- noJobKeyBackfilled.getAssignedTask().getTask()
- .setJob(new JobKey(OWNER.getRole(), ENV, JOB_NAME));
-
- ScheduledTask nullJobKeyFieldsBackfilled = nullJobKeyFields.newBuilder();
- nullJobKeyFieldsBackfilled.getAssignedTask().getTask()
- .setJob(new JobKey(OWNER.getRole(), ENV, JOB_NAME));
assertEquals(
- ImmutableSet.of(
- IScheduledTask.build(noJobKeyBackfilled),
- IScheduledTask.build(nullJobKeyFieldsBackfilled)),
+ ImmutableSet.of(IScheduledTask.build(task)),
Storage.Util.fetchTasks(storage, Query.unscoped()));
}
@@ -179,34 +114,9 @@ public class StorageBackfillTest {
});
}
- private static JobConfiguration makeJobConfig(IJobKey jobKey, TaskConfig task, int numTasks) {
- return new JobConfiguration()
- .setOwner(OWNER)
- .setKey(jobKey.newBuilder())
- .setInstanceCount(numTasks)
- .setTaskConfig(new TaskConfig(task)
- .setOwner(OWNER)
- .setEnvironment(jobKey.getEnvironment())
- .setJobName(jobKey.getName()));
- }
-
- private static TaskConfig defaultTask() {
- return new TaskConfig()
- .setOwner(OWNER)
- .setJobName(JOB_NAME)
- .setEnvironment(ENV)
- .setNumCpus(1.0)
- .setRamMb(ONE_GB)
- .setDiskMb(500)
- .setExecutorConfig(EXECUTOR_CONFIG)
- .setRequestedPorts(Sets.<String>newHashSet())
- .setConstraints(Sets.<Constraint>newHashSet())
- .setTaskLinks(Maps.<String, String>newHashMap());
- }
-
- private IScheduledTask getTask(String taskId) {
- return Iterables.getOnlyElement(Storage.Util.fetchTasks(
- storage,
- Query.taskScoped(taskId)));
+ private static IScheduledTask setMesosContainer(IScheduledTask task) {
+ ScheduledTask builder = task.newBuilder();
+ builder.getAssignedTask().getTask().setContainer(Container.mesos(new MesosContainer()));
+ return IScheduledTask.build(builder);
}
}
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/backup/RecoveryTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/backup/RecoveryTest.java b/src/test/java/org/apache/aurora/scheduler/storage/backup/RecoveryTest.java
index 5853c03..09e4208 100644
--- a/src/test/java/org/apache/aurora/scheduler/storage/backup/RecoveryTest.java
+++ b/src/test/java/org/apache/aurora/scheduler/storage/backup/RecoveryTest.java
@@ -25,18 +25,15 @@ import com.twitter.common.quantity.Time;
import com.twitter.common.testing.easymock.EasyMockTest;
import com.twitter.common.util.testing.FakeClock;
-import org.apache.aurora.gen.AssignedTask;
import org.apache.aurora.gen.HostAttributes;
-import org.apache.aurora.gen.Identity;
import org.apache.aurora.gen.Lock;
-import org.apache.aurora.gen.ScheduledTask;
-import org.apache.aurora.gen.TaskConfig;
import org.apache.aurora.gen.storage.QuotaConfiguration;
import org.apache.aurora.gen.storage.SchedulerMetadata;
import org.apache.aurora.gen.storage.Snapshot;
import org.apache.aurora.gen.storage.StoredCronJob;
import org.apache.aurora.gen.storage.StoredJobUpdateDetails;
import org.apache.aurora.scheduler.base.Query;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
import org.apache.aurora.scheduler.base.Tasks;
import org.apache.aurora.scheduler.storage.DistributedSnapshotStore;
import org.apache.aurora.scheduler.storage.SnapshotStore;
@@ -62,8 +59,8 @@ import static org.junit.Assert.assertEquals;
public class RecoveryTest extends EasyMockTest {
private static final Amount<Long, Time> INTERVAL = Amount.of(1L, Time.HOURS);
- private static final ScheduledTask TASK1 = makeTask("task1");
- private static final ScheduledTask TASK2 = makeTask("task2");
+ private static final IScheduledTask TASK1 = TaskTestUtil.makeTask("task1", TaskTestUtil.JOB);
+ private static final IScheduledTask TASK2 = TaskTestUtil.makeTask("task2", TaskTestUtil.JOB);
private static final Snapshot SNAPSHOT1 = makeSnapshot(TASK1, TASK2);
private SnapshotStore<Snapshot> snapshotStore;
@@ -129,7 +126,7 @@ public class RecoveryTest extends EasyMockTest {
@Test
public void testModifySnapshotBeforeCommit() throws Exception {
expect(snapshotStore.createSnapshot()).andReturn(SNAPSHOT1);
- Snapshot modified = SNAPSHOT1.deepCopy().setTasks(ImmutableSet.of(TASK1));
+ Snapshot modified = SNAPSHOT1.deepCopy().setTasks(ImmutableSet.of(TASK1.newBuilder()));
Capture<MutateWork<Object, Exception>> transaction = createCapture();
expect(primaryStorage.write(capture(transaction))).andReturn(null);
distributedStore.persist(modified);
@@ -164,24 +161,14 @@ public class RecoveryTest extends EasyMockTest {
recovery.commit();
}
- private static Snapshot makeSnapshot(ScheduledTask... tasks) {
+ private static Snapshot makeSnapshot(IScheduledTask... tasks) {
return new Snapshot()
.setHostAttributes(ImmutableSet.<HostAttributes>of())
.setCronJobs(ImmutableSet.<StoredCronJob>of())
.setSchedulerMetadata(new SchedulerMetadata().setVersion(CURRENT_API_VERSION))
.setQuotaConfigurations(ImmutableSet.<QuotaConfiguration>of())
- .setTasks(ImmutableSet.<ScheduledTask>builder().add(tasks).build())
+ .setTasks(IScheduledTask.toBuildersSet(ImmutableSet.copyOf(tasks)))
.setLocks(ImmutableSet.<Lock>of())
.setJobUpdateDetails(ImmutableSet.<StoredJobUpdateDetails>of());
}
-
- private static ScheduledTask makeTask(String taskId) {
- return new ScheduledTask().setAssignedTask(
- new AssignedTask()
- .setTaskId(taskId)
- .setTask(new TaskConfig()
- .setJobName("job-" + taskId)
- .setEnvironment("test")
- .setOwner(new Identity().setRole("role-" + taskId).setUser("user-" + taskId))));
- }
}
[2/3] aurora git commit: Require non-default primitive values in
StorageEntityUtil.
Posted by wf...@apache.org.
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/db/DBJobUpdateStoreTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/db/DBJobUpdateStoreTest.java b/src/test/java/org/apache/aurora/scheduler/storage/db/DBJobUpdateStoreTest.java
deleted file mode 100644
index 1f50515..0000000
--- a/src/test/java/org/apache/aurora/scheduler/storage/db/DBJobUpdateStoreTest.java
+++ /dev/null
@@ -1,1076 +0,0 @@
-/**
- * Licensed 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.aurora.scheduler.storage.db;
-
-import java.util.List;
-import java.util.Set;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
-
-import org.apache.aurora.gen.Constraint;
-import org.apache.aurora.gen.ExecutorConfig;
-import org.apache.aurora.gen.Identity;
-import org.apache.aurora.gen.InstanceTaskConfig;
-import org.apache.aurora.gen.JobInstanceUpdateEvent;
-import org.apache.aurora.gen.JobKey;
-import org.apache.aurora.gen.JobUpdate;
-import org.apache.aurora.gen.JobUpdateAction;
-import org.apache.aurora.gen.JobUpdateDetails;
-import org.apache.aurora.gen.JobUpdateEvent;
-import org.apache.aurora.gen.JobUpdateInstructions;
-import org.apache.aurora.gen.JobUpdateKey;
-import org.apache.aurora.gen.JobUpdateQuery;
-import org.apache.aurora.gen.JobUpdateSettings;
-import org.apache.aurora.gen.JobUpdateState;
-import org.apache.aurora.gen.JobUpdateStatus;
-import org.apache.aurora.gen.JobUpdateSummary;
-import org.apache.aurora.gen.Lock;
-import org.apache.aurora.gen.LockKey;
-import org.apache.aurora.gen.Metadata;
-import org.apache.aurora.gen.Range;
-import org.apache.aurora.gen.TaskConfig;
-import org.apache.aurora.gen.TaskConstraint;
-import org.apache.aurora.gen.ValueConstraint;
-import org.apache.aurora.gen.storage.StoredJobUpdateDetails;
-import org.apache.aurora.scheduler.base.JobKeys;
-import org.apache.aurora.scheduler.storage.Storage;
-import org.apache.aurora.scheduler.storage.Storage.MutableStoreProvider;
-import org.apache.aurora.scheduler.storage.Storage.MutateWork;
-import org.apache.aurora.scheduler.storage.Storage.StorageException;
-import org.apache.aurora.scheduler.storage.Storage.Work.Quiet;
-import org.apache.aurora.scheduler.storage.entities.IJobInstanceUpdateEvent;
-import org.apache.aurora.scheduler.storage.entities.IJobKey;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdate;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateDetails;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateEvent;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateInstructions;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateKey;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateQuery;
-import org.apache.aurora.scheduler.storage.entities.IJobUpdateSummary;
-import org.apache.aurora.scheduler.storage.entities.ILock;
-import org.apache.aurora.scheduler.storage.testing.StorageEntityUtil;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLBACK_FAILED;
-import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLED_BACK;
-import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLING_BACK;
-import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_UPDATED;
-import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_UPDATING;
-import static org.apache.aurora.gen.JobUpdateStatus.ABORTED;
-import static org.apache.aurora.gen.JobUpdateStatus.ERROR;
-import static org.apache.aurora.gen.JobUpdateStatus.FAILED;
-import static org.apache.aurora.gen.JobUpdateStatus.ROLLED_BACK;
-import static org.apache.aurora.gen.JobUpdateStatus.ROLLING_BACK;
-import static org.apache.aurora.gen.JobUpdateStatus.ROLLING_FORWARD;
-import static org.apache.aurora.gen.JobUpdateStatus.ROLL_BACK_PAUSED;
-import static org.apache.aurora.gen.JobUpdateStatus.ROLL_FORWARD_PAUSED;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
-public class DBJobUpdateStoreTest {
-
- private static final IJobKey JOB = JobKeys.from("testRole", "testEnv", "job");
- private static final IJobUpdateKey UPDATE1 =
- IJobUpdateKey.build(new JobUpdateKey(JOB.newBuilder(), "update1"));
- private static final IJobUpdateKey UPDATE2 = IJobUpdateKey.build(
- new JobUpdateKey(JobKeys.from("testRole", "testEnv", "job2").newBuilder(), "update2"));
- private static final long CREATED_MS = 111L;
- private static final IJobUpdateEvent FIRST_EVENT =
- makeJobUpdateEvent(ROLLING_FORWARD, CREATED_MS);
-
- private Storage storage;
-
- @Before
- public void setUp() throws Exception {
- storage = DbUtil.createStorage();
- }
-
- @After
- public void tearDown() throws Exception {
- truncateUpdates();
- }
-
- @Test
- public void testSaveJobUpdates() {
- IJobUpdateKey updateId1 = makeKey(JobKeys.from("role", "env", "name1"), "u1");
- IJobUpdateKey updateId2 = makeKey(JobKeys.from("role", "env", "name2"), "u2");
-
- IJobUpdate update1 = makeJobUpdate(updateId1);
- IJobUpdate update2 = makeJobUpdate(updateId2);
-
- assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId1));
- assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId2));
-
- StorageEntityUtil.assertFullyPopulated(
- update1,
- StorageEntityUtil.getField(JobUpdateSummary.class, "state"),
- StorageEntityUtil.getField(IJobUpdateSummary.class, "state"));
- saveUpdate(update1, Optional.of("lock1"));
- assertUpdate(update1);
-
- saveUpdate(update2, Optional.<String>absent());
- assertUpdate(update2);
-
- // Colliding update IDs should be forbidden.
- IJobUpdate update3 =
- makeJobUpdate(makeKey(JobKeys.from("role", "env", "name3"), updateId2.getId()));
- try {
- saveUpdate(update3, Optional.<String>absent());
- fail("Update ID collision should not be allowed");
- } catch (StorageException e) {
- // Expected.
- }
- }
-
- @Test
- public void testSaveNullInitialState() {
- JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
- builder.getInstructions().unsetInitialState();
-
- // Save with null initial state instances.
- saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
-
- builder.getInstructions().setInitialState(ImmutableSet.<InstanceTaskConfig>of());
- assertUpdate(IJobUpdate.build(builder));
- }
-
- @Test
- public void testSaveNullDesiredState() {
- JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
- builder.getInstructions().unsetDesiredState();
-
- // Save with null desired state instances.
- saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
-
- assertUpdate(IJobUpdate.build(builder));
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testSaveBothInitialAndDesiredMissingThrows() {
- JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
- builder.getInstructions().unsetInitialState();
- builder.getInstructions().unsetDesiredState();
-
- saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
- }
-
- @Test(expected = NullPointerException.class)
- public void testSaveNullInitialStateTaskThrows() {
- JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
- builder.getInstructions().getInitialState().add(
- new InstanceTaskConfig(null, ImmutableSet.<Range>of()));
-
- saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testSaveEmptyInitialStateRangesThrows() {
- JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
- builder.getInstructions().getInitialState().add(
- new InstanceTaskConfig(new TaskConfig(), ImmutableSet.<Range>of()));
-
- saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
- }
-
- @Test(expected = NullPointerException.class)
- public void testSaveNullDesiredStateTaskThrows() {
- JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
- builder.getInstructions().getDesiredState().setTask(null);
-
- saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
- }
-
- @Test(expected = IllegalArgumentException.class)
- public void testSaveEmptyDesiredStateRangesThrows() {
- JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
- builder.getInstructions().getDesiredState().setInstances(ImmutableSet.<Range>of());
-
- saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
- }
-
- @Test
- public void testSaveJobUpdateEmptyInstanceOverrides() {
- IJobUpdateKey updateId = makeKey("u1");
-
- IJobUpdate update = makeJobUpdate(updateId);
- JobUpdate builder = update.newBuilder();
- builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(ImmutableSet.<Range>of());
-
- IJobUpdate expected = IJobUpdate.build(builder);
-
- // Save with empty overrides.
- saveUpdate(expected, Optional.of("lock"));
- assertUpdate(expected);
- }
-
- @Test
- public void testSaveJobUpdateNullInstanceOverrides() {
- IJobUpdateKey updateId = makeKey("u1");
-
- IJobUpdate update = makeJobUpdate(updateId);
- JobUpdate builder = update.newBuilder();
- builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(ImmutableSet.<Range>of());
-
- IJobUpdate expected = IJobUpdate.build(builder);
-
- // Save with null overrides.
- builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(null);
- saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
- assertUpdate(expected);
- }
-
- @Test(expected = StorageException.class)
- public void testSaveJobUpdateTwiceThrows() {
- IJobUpdateKey updateId = makeKey("u1");
- IJobUpdate update = makeJobUpdate(updateId);
-
- saveUpdate(update, Optional.of("lock1"));
- saveUpdate(update, Optional.of("lock2"));
- }
-
- @Test
- public void testSaveJobEvents() {
- IJobUpdateKey updateId = makeKey("u3");
- IJobUpdate update = makeJobUpdate(updateId);
- IJobUpdateEvent event1 = makeJobUpdateEvent(ROLLING_FORWARD, 124L);
- IJobUpdateEvent event2 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 125L);
-
- saveUpdate(update, Optional.of("lock1"));
- assertUpdate(update);
- assertEquals(ImmutableList.of(FIRST_EVENT), getUpdateDetails(updateId).get().getUpdateEvents());
-
- saveJobEvent(event1, updateId);
- assertEquals(
- populateExpected(update, ROLLING_FORWARD, CREATED_MS, 124L),
- getUpdateDetails(updateId).get().getUpdate());
- assertEquals(event1, getUpdateDetails(updateId).get().getUpdateEvents().get(1));
-
- saveJobEvent(event2, updateId);
- assertEquals(
- populateExpected(update, ROLL_FORWARD_PAUSED, CREATED_MS, 125L),
- getUpdateDetails(updateId).get().getUpdate());
- assertEquals(event1, getUpdateDetails(updateId).get().getUpdateEvents().get(1));
- assertEquals(event2, getUpdateDetails(updateId).get().getUpdateEvents().get(2));
- }
-
- @Test
- public void testSaveInstanceEvents() {
- IJobUpdateKey updateId = makeKey("u3");
- IJobUpdate update = makeJobUpdate(updateId);
- IJobInstanceUpdateEvent event1 = makeJobInstanceEvent(0, 125L, INSTANCE_UPDATED);
- IJobInstanceUpdateEvent event2 = makeJobInstanceEvent(1, 126L, INSTANCE_ROLLING_BACK);
-
- saveUpdate(update, Optional.of("lock"));
- assertUpdate(update);
- assertEquals(0, getUpdateDetails(updateId).get().getInstanceEvents().size());
-
- saveJobInstanceEvent(event1, updateId);
- assertEquals(
- populateExpected(update, ROLLING_FORWARD, CREATED_MS, 125L),
- getUpdateDetails(updateId).get().getUpdate());
- assertEquals(
- event1,
- Iterables.getOnlyElement(getUpdateDetails(updateId).get().getInstanceEvents()));
-
- saveJobInstanceEvent(event2, updateId);
- assertEquals(
- populateExpected(update, ROLLING_FORWARD, CREATED_MS, 126L),
- getUpdateDetails(updateId).get().getUpdate());
- assertEquals(event1, getUpdateDetails(updateId).get().getInstanceEvents().get(0));
- assertEquals(event2, getUpdateDetails(updateId).get().getInstanceEvents().get(1));
- }
-
- @Test(expected = StorageException.class)
- public void testSaveJobEventWithoutUpdateFails() {
- saveJobEvent(makeJobUpdateEvent(ROLLING_FORWARD, 123L), makeKey("u2"));
- }
-
- @Test(expected = StorageException.class)
- public void testSaveInstanceEventWithoutUpdateFails() {
- saveJobInstanceEvent(makeJobInstanceEvent(0, 125L, INSTANCE_UPDATED), makeKey("u1"));
- }
-
- @Test
- public void testSaveJobUpdateStateIgnored() {
- IJobUpdateKey updateId = makeKey("u1");
- IJobUpdate update = populateExpected(makeJobUpdate(updateId), ABORTED, 567L, 567L);
- saveUpdate(update, Optional.of("lock1"));
-
- // Assert state fields were ignored.
- assertUpdate(update);
- }
-
- @Test
- public void testSaveJobUpdateWithoutEventFailsSelect() {
- final IJobUpdateKey updateId = makeKey("u3");
- storage.write(new MutateWork.NoResult.Quiet() {
- @Override
- public void execute(MutableStoreProvider storeProvider) {
- IJobUpdate update = makeJobUpdate(updateId);
- storeProvider.getLockStore().saveLock(makeLock(update.getSummary().getJobKey(), "lock1"));
- storeProvider.getJobUpdateStore().saveJobUpdate(update, Optional.of("lock1"));
- }
- });
- assertEquals(Optional.<IJobUpdateDetails>absent(), getUpdateDetails(updateId));
- }
-
- @Test
- public void testMultipleJobDetails() {
- IJobUpdateKey updateId1 = makeKey(JobKeys.from("role", "env", "name1"), "u1");
- IJobUpdateKey updateId2 = makeKey(JobKeys.from("role", "env", "name2"), "u2");
- IJobUpdateDetails details1 = makeJobDetails(makeJobUpdate(updateId1));
- IJobUpdateDetails details2 = makeJobDetails(makeJobUpdate(updateId2));
-
- assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
-
- saveUpdate(details1.getUpdate(), Optional.of("lock1"));
- saveUpdate(details2.getUpdate(), Optional.of("lock2"));
-
- details1 = updateJobDetails(populateExpected(details1.getUpdate()), FIRST_EVENT);
- details2 = updateJobDetails(populateExpected(details2.getUpdate()), FIRST_EVENT);
- assertEquals(Optional.of(details1), getUpdateDetails(updateId1));
- assertEquals(Optional.of(details2), getUpdateDetails(updateId2));
-
- IJobUpdateEvent jEvent11 = makeJobUpdateEvent(ROLLING_FORWARD, 456L);
- IJobUpdateEvent jEvent12 = makeJobUpdateEvent(ERROR, 457L);
- IJobInstanceUpdateEvent iEvent11 = makeJobInstanceEvent(1, 451L, INSTANCE_UPDATED);
- IJobInstanceUpdateEvent iEvent12 = makeJobInstanceEvent(2, 452L, INSTANCE_UPDATING);
-
- IJobUpdateEvent jEvent21 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 567L);
- IJobUpdateEvent jEvent22 = makeJobUpdateEvent(ABORTED, 568L);
- IJobInstanceUpdateEvent iEvent21 = makeJobInstanceEvent(3, 561L, INSTANCE_UPDATING);
- IJobInstanceUpdateEvent iEvent22 = makeJobInstanceEvent(3, 562L, INSTANCE_UPDATED);
-
- saveJobEvent(jEvent11, updateId1);
- saveJobEvent(jEvent12, updateId1);
- saveJobInstanceEvent(iEvent11, updateId1);
- saveJobInstanceEvent(iEvent12, updateId1);
-
- saveJobEvent(jEvent21, updateId2);
- saveJobEvent(jEvent22, updateId2);
- assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
- saveJobInstanceEvent(iEvent21, updateId2);
-
- assertEquals(ImmutableList.of(iEvent21), getInstanceEvents(updateId2, 3));
- saveJobInstanceEvent(iEvent22, updateId2);
- assertEquals(ImmutableList.of(iEvent21, iEvent22), getInstanceEvents(updateId2, 3));
-
- details1 = updateJobDetails(
- populateExpected(details1.getUpdate(), ERROR, CREATED_MS, 457L),
- ImmutableList.of(FIRST_EVENT, jEvent11, jEvent12), ImmutableList.of(iEvent11, iEvent12));
-
- details2 = updateJobDetails(
- populateExpected(details2.getUpdate(), ABORTED, CREATED_MS, 568L),
- ImmutableList.of(FIRST_EVENT, jEvent21, jEvent22), ImmutableList.of(iEvent21, iEvent22));
-
- assertEquals(Optional.of(details1), getUpdateDetails(updateId1));
- assertEquals(Optional.of(details2), getUpdateDetails(updateId2));
-
- assertEquals(
- ImmutableSet.of(
- new StoredJobUpdateDetails(details1.newBuilder(), "lock1"),
- new StoredJobUpdateDetails(details2.newBuilder(), "lock2")),
- getAllUpdateDetails());
-
- assertEquals(
- ImmutableList.of(getUpdateDetails(updateId2).get(), getUpdateDetails(updateId1).get()),
- queryDetails(new JobUpdateQuery().setRole("role")));
- }
-
- @Test
- public void testTruncateJobUpdates() {
- IJobUpdateKey updateId = makeKey("u5");
- IJobUpdate update = makeJobUpdate(updateId);
- IJobInstanceUpdateEvent instanceEvent = IJobInstanceUpdateEvent.build(
- new JobInstanceUpdateEvent(0, 125L, INSTANCE_ROLLBACK_FAILED));
-
- saveUpdate(update, Optional.of("lock"));
- saveJobEvent(makeJobUpdateEvent(ROLLING_FORWARD, 123L), updateId);
- saveJobInstanceEvent(instanceEvent, updateId);
- assertEquals(
- populateExpected(update, ROLLING_FORWARD, CREATED_MS, 125L),
- getUpdate(updateId).get());
- assertEquals(2, getUpdateDetails(updateId).get().getUpdateEvents().size());
- assertEquals(1, getUpdateDetails(updateId).get().getInstanceEvents().size());
-
- truncateUpdates();
- assertEquals(Optional.<IJobUpdateDetails>absent(), getUpdateDetails(updateId));
- }
-
- @Test
- public void testPruneHistory() {
- IJobUpdateKey updateId1 = makeKey("u11");
- IJobUpdateKey updateId2 = makeKey("u12");
- IJobUpdateKey updateId3 = makeKey("u13");
- IJobUpdateKey updateId4 = makeKey("u14");
- IJobKey job2 = JobKeys.from("testRole2", "testEnv2", "job2");
- IJobUpdateKey updateId5 = makeKey(job2, "u15");
- IJobUpdateKey updateId6 = makeKey(job2, "u16");
- IJobUpdateKey updateId7 = makeKey(job2, "u17");
-
- IJobUpdate update1 = makeJobUpdate(updateId1);
- IJobUpdate update2 = makeJobUpdate(updateId2);
- IJobUpdate update3 = makeJobUpdate(updateId3);
- IJobUpdate update4 = makeJobUpdate(updateId4);
- IJobUpdate update5 = makeJobUpdate(updateId5);
- IJobUpdate update6 = makeJobUpdate(updateId6);
- IJobUpdate update7 = makeJobUpdate(updateId7);
-
- IJobUpdateEvent updateEvent1 = makeJobUpdateEvent(ROLLING_BACK, 123L);
- IJobUpdateEvent updateEvent2 = makeJobUpdateEvent(ABORTED, 124L);
- IJobUpdateEvent updateEvent3 = makeJobUpdateEvent(ROLLED_BACK, 125L);
- IJobUpdateEvent updateEvent4 = makeJobUpdateEvent(FAILED, 126L);
- IJobUpdateEvent updateEvent5 = makeJobUpdateEvent(ERROR, 123L);
- IJobUpdateEvent updateEvent6 = makeJobUpdateEvent(FAILED, 125L);
- IJobUpdateEvent updateEvent7 = makeJobUpdateEvent(ROLLING_FORWARD, 126L);
-
- update1 = populateExpected(
- saveUpdateNoEvent(update1, Optional.of("lock1")), ROLLING_BACK, 123L, 123L);
- update2 = populateExpected(
- saveUpdateNoEvent(update2, Optional.<String>absent()), ABORTED, 124L, 124L);
- update3 = populateExpected(
- saveUpdateNoEvent(update3, Optional.<String>absent()), ROLLED_BACK, 125L, 125L);
- update4 = populateExpected(
- saveUpdateNoEvent(update4, Optional.<String>absent()), FAILED, 126L, 126L);
- update5 = populateExpected(
- saveUpdateNoEvent(update5, Optional.<String>absent()), ERROR, 123L, 123L);
- update6 = populateExpected(
- saveUpdateNoEvent(update6, Optional.<String>absent()), FAILED, 125L, 125L);
- update7 = populateExpected(
- saveUpdateNoEvent(update7, Optional.of("lock2")), ROLLING_FORWARD, 126L, 126L);
-
- saveJobEvent(updateEvent1, updateId1);
- saveJobEvent(updateEvent2, updateId2);
- saveJobEvent(updateEvent3, updateId3);
- saveJobEvent(updateEvent4, updateId4);
- saveJobEvent(updateEvent5, updateId5);
- saveJobEvent(updateEvent6, updateId6);
- saveJobEvent(updateEvent7, updateId7);
-
- assertEquals(update1, getUpdate(updateId1).get());
- assertEquals(update2, getUpdate(updateId2).get());
- assertEquals(update3, getUpdate(updateId3).get());
- assertEquals(update4, getUpdate(updateId4).get());
- assertEquals(update5, getUpdate(updateId5).get());
- assertEquals(update6, getUpdate(updateId6).get());
- assertEquals(update7, getUpdate(updateId7).get());
-
- long pruningThreshold = 120L;
-
- // No updates pruned.
- assertEquals(ImmutableSet.<IJobUpdateKey>of(), pruneHistory(3, pruningThreshold));
- assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
- assertEquals(Optional.of(update6), getUpdate(updateId6));
- assertEquals(Optional.of(update5), getUpdate(updateId5));
-
- assertEquals(Optional.of(update4), getUpdate(updateId4));
- assertEquals(Optional.of(update3), getUpdate(updateId3));
- assertEquals(Optional.of(update2), getUpdate(updateId2));
- assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
-
- assertEquals(ImmutableSet.of(updateId2), pruneHistory(2, pruningThreshold));
- // No updates pruned.
- assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
- assertEquals(Optional.of(update6), getUpdate(updateId6));
- assertEquals(Optional.of(update5), getUpdate(updateId5));
-
- // 1 update pruned.
- assertEquals(Optional.of(update4), getUpdate(updateId4));
- assertEquals(Optional.of(update3), getUpdate(updateId3));
- assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId2));
- assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
-
- assertEquals(ImmutableSet.of(updateId5, updateId3), pruneHistory(1, pruningThreshold));
- // 1 update pruned.
- assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
- assertEquals(Optional.of(update6), getUpdate(updateId6));
- assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId5));
-
- // 2 updates pruned.
- assertEquals(Optional.of(update4), getUpdate(updateId4));
- assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId3));
- assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
-
- // The oldest update is pruned.
- assertEquals(ImmutableSet.of(updateId6), pruneHistory(1, 126L));
- assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
- assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId6));
-
- assertEquals(Optional.of(update4), getUpdate(updateId4));
- assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
-
- // Nothing survives the 0 per job count.
- assertEquals(ImmutableSet.of(updateId4), pruneHistory(0, pruningThreshold));
- assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
-
- assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId4));
- assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
- }
-
- @Test(expected = StorageException.class)
- public void testSaveUpdateWithoutLock() {
- final IJobUpdate update = makeJobUpdate(makeKey("updateId"));
- storage.write(new MutateWork.NoResult.Quiet() {
- @Override
- public void execute(MutableStoreProvider storeProvider) {
- storeProvider.getJobUpdateStore().saveJobUpdate(update, Optional.of("lock"));
- }
- });
- }
-
- @Test(expected = StorageException.class)
- public void testSaveTwoUpdatesForOneJob() {
- final IJobUpdate update = makeJobUpdate(makeKey("updateId"));
- saveUpdate(update, Optional.of("lock1"));
- saveUpdate(update, Optional.of("lock2"));
- }
-
- @Test(expected = StorageException.class)
- public void testSaveTwoUpdatesSameJobKey() {
- final IJobUpdate update1 = makeJobUpdate(makeKey("update1"));
- final IJobUpdate update2 = makeJobUpdate(makeKey("update2"));
- saveUpdate(update1, Optional.of("lock1"));
- saveUpdate(update2, Optional.of("lock1"));
- }
-
- @Test
- public void testLockCleared() {
- final IJobUpdate update = makeJobUpdate(makeKey("update1"));
- saveUpdate(update, Optional.of("lock1"));
-
- removeLock(update, "lock1");
-
- assertEquals(
- Optional.of(updateJobDetails(populateExpected(update), FIRST_EVENT)),
- getUpdateDetails(makeKey("update1")));
- assertEquals(
- ImmutableSet.of(
- new StoredJobUpdateDetails(
- updateJobDetails(populateExpected(update), FIRST_EVENT).newBuilder(),
- null)),
- getAllUpdateDetails());
-
- assertEquals(
- ImmutableList.of(populateExpected(update).getSummary()),
- getSummaries(new JobUpdateQuery().setKey(UPDATE1.newBuilder())));
-
- // If the lock has been released for this job, we can start another update.
- saveUpdate(makeJobUpdate(makeKey("update2")), Optional.of("lock2"));
- }
-
- private static final Optional<String> NO_TOKEN = Optional.absent();
-
- @Test
- public void testGetLockToken() {
- storage.write(new MutateWork.NoResult.Quiet() {
- @Override
- public void execute(MutableStoreProvider storeProvider) {
- final IJobUpdate update1 = makeJobUpdate(UPDATE1);
- final IJobUpdate update2 = makeJobUpdate(UPDATE2);
- saveUpdate(update1, Optional.of("lock1"));
- assertEquals(
- Optional.of("lock1"),
- storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
- assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
-
- saveUpdate(update2, Optional.of("lock2"));
- assertEquals(
- Optional.of("lock1"),
- storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
- assertEquals(
- Optional.of("lock2"),
- storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
-
- storeProvider.getLockStore().removeLock(
- makeLock(update1.getSummary().getJobKey(), "lock1").getKey());
- assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
- assertEquals(
- Optional.of("lock2"),
- storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
-
- storeProvider.getLockStore().removeLock(
- makeLock(update2.getSummary().getJobKey(), "lock2").getKey());
- assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
- assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
- }
- });
- }
-
- @Test
- public void testGetSummaries() {
- String role1 = "role1";
- IJobKey job1 = JobKeys.from(role1, "env", "name1");
- IJobKey job2 = JobKeys.from(role1, "env", "name2");
- IJobKey job3 = JobKeys.from(role1, "env", "name3");
- IJobKey job4 = JobKeys.from(role1, "env", "name4");
- IJobKey job5 = JobKeys.from("role", "env", "name5");
- IJobUpdateSummary s1 =
- saveSummary(makeKey(job1, "u1"), 1230L, ROLLED_BACK, "user", Optional.of("lock1"));
- IJobUpdateSummary s2 =
- saveSummary(makeKey(job2, "u2"), 1231L, ABORTED, "user", Optional.of("lock2"));
- IJobUpdateSummary s3 =
- saveSummary(makeKey(job3, "u3"), 1239L, ERROR, "user2", Optional.of("lock3"));
- IJobUpdateSummary s4 =
- saveSummary(makeKey(job4, "u4"), 1234L, ROLL_BACK_PAUSED, "user3", Optional.of("lock4"));
- IJobUpdateSummary s5 =
- saveSummary(makeKey(job5, "u5"), 1235L, ROLLING_FORWARD, "user4", Optional.of("lock5"));
-
- // Test empty query returns all.
- assertEquals(ImmutableList.of(s3, s5, s4, s2, s1), getSummaries(new JobUpdateQuery()));
-
- // Test query by updateId.
- assertEquals(
- ImmutableList.of(s1),
- getSummaries(new JobUpdateQuery().setKey(new JobUpdateKey(job1.newBuilder(), "u1"))));
-
- // Test query by role.
- assertEquals(
- ImmutableList.of(s3, s4, s2, s1),
- getSummaries(new JobUpdateQuery().setRole(role1)));
-
- // Test query by job key.
- assertEquals(
- ImmutableList.of(s5),
- getSummaries(new JobUpdateQuery().setJobKey(job5.newBuilder())));
-
- // Test querying by update key.
- assertEquals(
- ImmutableList.of(s5),
- getSummaries(
- new JobUpdateQuery().setKey(new JobUpdateKey(job5.newBuilder(), s5.getUpdateId()))));
-
- // Test querying by incorrect update keys.
- assertEquals(
- ImmutableList.<IJobUpdateSummary>of(),
- getSummaries(
- new JobUpdateQuery().setKey(new JobUpdateKey(job5.newBuilder(), s4.getUpdateId()))));
- assertEquals(
- ImmutableList.<IJobUpdateSummary>of(),
- getSummaries(
- new JobUpdateQuery().setKey(new JobUpdateKey(job4.newBuilder(), s5.getUpdateId()))));
-
- // Test query by user.
- assertEquals(ImmutableList.of(s2, s1), getSummaries(new JobUpdateQuery().setUser("user")));
-
- // Test query by one status.
- assertEquals(ImmutableList.of(s3), getSummaries(new JobUpdateQuery().setUpdateStatuses(
- ImmutableSet.of(ERROR))));
-
- // Test query by multiple statuses.
- assertEquals(ImmutableList.of(s3, s2, s1), getSummaries(new JobUpdateQuery().setUpdateStatuses(
- ImmutableSet.of(ERROR, ABORTED, ROLLED_BACK))));
-
- // Test query by empty statuses.
- assertEquals(
- ImmutableList.of(s3, s5, s4, s2, s1),
- getSummaries(new JobUpdateQuery().setUpdateStatuses(ImmutableSet.<JobUpdateStatus>of())));
-
- // Test paging.
- assertEquals(
- ImmutableList.of(s3, s5),
- getSummaries(new JobUpdateQuery().setLimit(2).setOffset(0)));
- assertEquals(
- ImmutableList.of(s4, s2),
- getSummaries(new JobUpdateQuery().setLimit(2).setOffset(2)));
- assertEquals(
- ImmutableList.of(s1),
- getSummaries(new JobUpdateQuery().setLimit(2).setOffset(4)));
-
- // Test no match.
- assertEquals(
- ImmutableList.<IJobUpdateSummary>of(),
- getSummaries(new JobUpdateQuery().setRole("no_match")));
- }
-
- @Test
- public void testQueryDetails() {
- IJobKey jobKey1 = JobKeys.from("role1", "env", "name1");
- IJobUpdateKey updateId1 = makeKey(jobKey1, "u1");
- IJobKey jobKey2 = JobKeys.from("role2", "env", "name2");
- IJobUpdateKey updateId2 = makeKey(jobKey2, "u2");
-
- IJobUpdate update1 = makeJobUpdate(updateId1);
- IJobUpdate update2 = makeJobUpdate(updateId2);
-
- assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
-
- saveUpdate(update1, Optional.of("lock1"));
- saveUpdate(update2, Optional.of("lock2"));
-
- updateJobDetails(populateExpected(update1), FIRST_EVENT);
- updateJobDetails(populateExpected(update2), FIRST_EVENT);
-
- IJobUpdateEvent jEvent11 = makeJobUpdateEvent(ROLLING_BACK, 450L);
- IJobUpdateEvent jEvent12 = makeJobUpdateEvent(ROLLED_BACK, 500L);
- IJobInstanceUpdateEvent iEvent11 = makeJobInstanceEvent(1, 451L, INSTANCE_ROLLING_BACK);
- IJobInstanceUpdateEvent iEvent12 = makeJobInstanceEvent(2, 458L, INSTANCE_ROLLED_BACK);
-
- IJobUpdateEvent jEvent21 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 550L);
- IJobUpdateEvent jEvent22 = makeJobUpdateEvent(ABORTED, 600L);
- IJobInstanceUpdateEvent iEvent21 = makeJobInstanceEvent(3, 561L, INSTANCE_UPDATING);
- IJobInstanceUpdateEvent iEvent22 = makeJobInstanceEvent(3, 570L, INSTANCE_UPDATED);
-
- saveJobEvent(jEvent11, updateId1);
- saveJobEvent(jEvent12, updateId1);
- saveJobInstanceEvent(iEvent11, updateId1);
- saveJobInstanceEvent(iEvent12, updateId1);
-
- saveJobEvent(jEvent21, updateId2);
- saveJobEvent(jEvent22, updateId2);
-
- saveJobInstanceEvent(iEvent21, updateId2);
- saveJobInstanceEvent(iEvent22, updateId2);
-
- IJobUpdateDetails details1 = getUpdateDetails(updateId1).get();
- IJobUpdateDetails details2 = getUpdateDetails(updateId2).get();
-
- // Test empty query returns all.
- assertEquals(ImmutableList.of(details2, details1), queryDetails(new JobUpdateQuery()));
-
- // Test query by update ID.
- assertEquals(
- ImmutableList.of(details1),
- queryDetails(new JobUpdateQuery().setKey(updateId1.newBuilder())));
-
- // Test query by role.
- assertEquals(
- ImmutableList.of(details2),
- queryDetails(new JobUpdateQuery().setRole(jobKey2.getRole())));
-
- // Test query by job key.
- assertEquals(
- ImmutableList.of(details2),
- queryDetails(new JobUpdateQuery().setJobKey(jobKey2.newBuilder())));
-
- // Test query by status.
- assertEquals(
- ImmutableList.of(details2),
- queryDetails(new JobUpdateQuery().setUpdateStatuses(ImmutableSet.of(ABORTED))));
-
- // Test no match.
- assertEquals(
- ImmutableList.<IJobUpdateDetails>of(),
- queryDetails(new JobUpdateQuery().setRole("no match")));
- }
-
- private static IJobUpdateKey makeKey(String id) {
- return makeKey(JOB, id);
- }
-
- private static IJobUpdateKey makeKey(IJobKey job, String id) {
- return IJobUpdateKey.build(new JobUpdateKey(job.newBuilder(), id));
- }
-
- private void assertUpdate(IJobUpdate expected) {
- IJobUpdateKey key = expected.getSummary().getKey();
- assertEquals(populateExpected(expected), getUpdate(key).get());
- assertEquals(getUpdate(key).get(), getUpdateDetails(key).get().getUpdate());
- assertEquals(getUpdateInstructions(key).get(), expected.getInstructions());
- }
-
- private Optional<IJobUpdate> getUpdate(final IJobUpdateKey key) {
- return storage.read(new Quiet<Optional<IJobUpdate>>() {
- @Override
- public Optional<IJobUpdate> apply(Storage.StoreProvider storeProvider) {
- return storeProvider.getJobUpdateStore().fetchJobUpdate(key);
- }
- });
- }
-
- private List<IJobInstanceUpdateEvent> getInstanceEvents(final IJobUpdateKey key, final int id) {
- return storage.read(new Quiet<List<IJobInstanceUpdateEvent>>() {
- @Override
- public List<IJobInstanceUpdateEvent> apply(Storage.StoreProvider storeProvider) {
- return storeProvider.getJobUpdateStore().fetchInstanceEvents(key, id);
- }
- });
- }
-
- private Optional<IJobUpdateInstructions> getUpdateInstructions(final IJobUpdateKey key) {
- return storage.read(new Quiet<Optional<IJobUpdateInstructions>>() {
- @Override
- public Optional<IJobUpdateInstructions> apply(Storage.StoreProvider storeProvider) {
- return storeProvider.getJobUpdateStore().fetchJobUpdateInstructions(key);
- }
- });
- }
-
- private Optional<IJobUpdateDetails> getUpdateDetails(final IJobUpdateKey key) {
- return storage.read(new Quiet<Optional<IJobUpdateDetails>>() {
- @Override
- public Optional<IJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
- return storeProvider.getJobUpdateStore().fetchJobUpdateDetails(key);
- }
- });
- }
-
- private Set<StoredJobUpdateDetails> getAllUpdateDetails() {
- return storage.read(new Quiet<Set<StoredJobUpdateDetails>>() {
- @Override
- public Set<StoredJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
- return storeProvider.getJobUpdateStore().fetchAllJobUpdateDetails();
- }
- });
- }
-
- private List<IJobUpdateDetails> queryDetails(final JobUpdateQuery query) {
- return storage.read(new Quiet<List<IJobUpdateDetails>>() {
- @Override
- public List<IJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
- return storeProvider.getJobUpdateStore().fetchJobUpdateDetails(
- IJobUpdateQuery.build(query));
- }
- });
- }
-
- private List<IJobUpdateSummary> getSummaries(final JobUpdateQuery query) {
- return storage.read(new Quiet<List<IJobUpdateSummary>>() {
- @Override
- public List<IJobUpdateSummary> apply(Storage.StoreProvider storeProvider) {
- return storeProvider.getJobUpdateStore().fetchJobUpdateSummaries(
- IJobUpdateQuery.build(query));
- }
- });
- }
-
- private static ILock makeLock(IJobKey jobKey, String lockToken) {
- return ILock.build(new Lock()
- .setKey(LockKey.job(jobKey.newBuilder()))
- .setToken(lockToken)
- .setTimestampMs(100)
- .setUser("fake user"));
- }
-
- private IJobUpdate saveUpdate(final IJobUpdate update, final Optional<String> lockToken) {
- storage.write(new MutateWork.NoResult.Quiet() {
- @Override
- public void execute(MutableStoreProvider storeProvider) {
- if (lockToken.isPresent()) {
- storeProvider.getLockStore().saveLock(
- makeLock(update.getSummary().getJobKey(), lockToken.get()));
- }
- storeProvider.getJobUpdateStore().saveJobUpdate(update, lockToken);
- storeProvider.getJobUpdateStore().saveJobUpdateEvent(
- update.getSummary().getKey(),
- FIRST_EVENT);
- }
- });
-
- return update;
- }
-
- private IJobUpdate saveUpdateNoEvent(final IJobUpdate update, final Optional<String> lockToken) {
- storage.write(new MutateWork.NoResult.Quiet() {
- @Override
- public void execute(MutableStoreProvider storeProvider) {
- if (lockToken.isPresent()) {
- storeProvider.getLockStore().saveLock(
- makeLock(update.getSummary().getJobKey(), lockToken.get()));
- }
- storeProvider.getJobUpdateStore().saveJobUpdate(update, lockToken);
- }
- });
-
- return update;
- }
-
- private void saveJobEvent(final IJobUpdateEvent event, final IJobUpdateKey key) {
- storage.write(new MutateWork.NoResult.Quiet() {
- @Override
- public void execute(MutableStoreProvider storeProvider) {
- storeProvider.getJobUpdateStore().saveJobUpdateEvent(key, event);
- }
- });
- }
-
- private void saveJobInstanceEvent(final IJobInstanceUpdateEvent event, final IJobUpdateKey key) {
- storage.write(new MutateWork.NoResult.Quiet() {
- @Override
- public void execute(MutableStoreProvider storeProvider) {
- storeProvider.getJobUpdateStore().saveJobInstanceUpdateEvent(key, event);
- }
- });
- }
-
- private void truncateUpdates() {
- storage.write(new MutateWork.NoResult.Quiet() {
- @Override
- public void execute(MutableStoreProvider storeProvider) {
- storeProvider.getJobUpdateStore().deleteAllUpdatesAndEvents();
- }
- });
- }
-
- private Set<IJobUpdateKey> pruneHistory(final int retainCount, final long pruningThresholdMs) {
- return storage.write(new MutateWork.Quiet<Set<IJobUpdateKey>>() {
- @Override
- public Set<IJobUpdateKey> apply(MutableStoreProvider storeProvider) {
- return storeProvider.getJobUpdateStore().pruneHistory(retainCount, pruningThresholdMs);
- }
- });
- }
-
- private void removeLock(final IJobUpdate update, final String lockToken) {
- storage.write(new MutateWork.NoResult.Quiet() {
- @Override
- public void execute(MutableStoreProvider storeProvider) {
- storeProvider.getLockStore().removeLock(
- makeLock(update.getSummary().getJobKey(), lockToken).getKey());
- }
- });
- }
-
- private IJobUpdate populateExpected(IJobUpdate update) {
- return populateExpected(update, ROLLING_FORWARD, CREATED_MS, CREATED_MS);
- }
-
- private IJobUpdate populateExpected(
- IJobUpdate update,
- JobUpdateStatus status,
- long createdMs,
- long lastMs) {
-
- JobUpdateState state = new JobUpdateState()
- .setCreatedTimestampMs(createdMs)
- .setLastModifiedTimestampMs(lastMs)
- .setStatus(status);
- JobUpdate builder = update.newBuilder();
- builder.getSummary().setState(state);
- return IJobUpdate.build(builder);
- }
-
- private static IJobUpdateEvent makeJobUpdateEvent(JobUpdateStatus status, long timestampMs) {
- return IJobUpdateEvent.build(
- new JobUpdateEvent(status, timestampMs)
- .setUser("user")
- .setMessage("message"));
- }
-
- private IJobInstanceUpdateEvent makeJobInstanceEvent(
- int instanceId,
- long timestampMs,
- JobUpdateAction action) {
-
- return IJobInstanceUpdateEvent.build(
- new JobInstanceUpdateEvent(instanceId, timestampMs, action));
- }
-
- private IJobUpdateDetails makeJobDetails(IJobUpdate update) {
- return updateJobDetails(
- update,
- ImmutableList.of(FIRST_EVENT),
- ImmutableList.<IJobInstanceUpdateEvent>of());
- }
-
- private IJobUpdateDetails updateJobDetails(IJobUpdate update, IJobUpdateEvent event) {
- return updateJobDetails(
- update,
- ImmutableList.of(event),
- ImmutableList.<IJobInstanceUpdateEvent>of());
- }
-
- private IJobUpdateDetails updateJobDetails(
- IJobUpdate update,
- List<IJobUpdateEvent> jobEvents,
- List<IJobInstanceUpdateEvent> instanceEvents) {
-
- return IJobUpdateDetails.build(new JobUpdateDetails()
- .setUpdate(update.newBuilder())
- .setUpdateEvents(IJobUpdateEvent.toBuildersList(jobEvents))
- .setInstanceEvents(IJobInstanceUpdateEvent.toBuildersList(instanceEvents)));
- }
-
- private IJobUpdateSummary makeSummary(IJobUpdateKey key, String user) {
- return IJobUpdateSummary.build(new JobUpdateSummary()
- .setKey(key.newBuilder())
- .setUpdateId(key.getId())
- .setJobKey(key.getJob().newBuilder())
- .setUser(user));
- }
-
- private IJobUpdateSummary saveSummary(
- IJobUpdateKey key,
- Long modifiedTimestampMs,
- JobUpdateStatus status,
- String user,
- Optional<String> lockToken) {
-
- IJobUpdateSummary summary = IJobUpdateSummary.build(new JobUpdateSummary()
- .setKey(key.newBuilder())
- .setUpdateId(key.getId())
- .setJobKey(key.getJob().newBuilder())
- .setUser(user));
-
- IJobUpdate update = makeJobUpdate(summary);
- saveUpdate(update, lockToken);
- saveJobEvent(makeJobUpdateEvent(status, modifiedTimestampMs), key);
- return populateExpected(update, status, CREATED_MS, modifiedTimestampMs).getSummary();
- }
-
- private IJobUpdate makeJobUpdate(IJobUpdateSummary summary) {
- return IJobUpdate.build(makeJobUpdate().newBuilder().setSummary(summary.newBuilder()));
- }
-
- private IJobUpdate makeJobUpdate(IJobUpdateKey key) {
- return IJobUpdate.build(makeJobUpdate().newBuilder()
- .setSummary(makeSummary(key, "user").newBuilder()));
- }
-
- private IJobUpdate makeJobUpdate() {
- return IJobUpdate.build(new JobUpdate()
- .setInstructions(makeJobUpdateInstructions().newBuilder()));
- }
-
- private IJobUpdateInstructions makeJobUpdateInstructions() {
- return IJobUpdateInstructions.build(new JobUpdateInstructions()
- .setDesiredState(new InstanceTaskConfig()
- .setTask(makeTaskConfig())
- .setInstances(ImmutableSet.of(new Range(0, 7), new Range(8, 9))))
- .setInitialState(ImmutableSet.of(
- new InstanceTaskConfig()
- .setInstances(ImmutableSet.of(new Range(0, 1), new Range(2, 3)))
- .setTask(makeTaskConfig()),
- new InstanceTaskConfig()
- .setInstances(ImmutableSet.of(new Range(4, 5), new Range(6, 7)))
- .setTask(makeTaskConfig())))
- .setSettings(new JobUpdateSettings()
- .setBlockIfNoPulsesAfterMs(500)
- .setUpdateOnlyTheseInstances(ImmutableSet.of(new Range(0, 0), new Range(3, 5)))));
- }
-
- private TaskConfig makeTaskConfig() {
- return new TaskConfig()
- .setJobName(JOB.getName())
- .setEnvironment(JOB.getEnvironment())
- .setOwner(new Identity(JOB.getRole(), "user"))
- .setJob(new JobKey("role", "env", "job"))
- .setIsService(true)
- .setConstraints(ImmutableSet.of(
- new Constraint(
- "name",
- TaskConstraint.value(new ValueConstraint(true, ImmutableSet.of("x86"))))))
- .setRequestedPorts(ImmutableSet.of("http"))
- .setTaskLinks(ImmutableMap.of("key", "url"))
- .setContactEmail("foo@bar.com")
- .setExecutorConfig(new ExecutorConfig("name", "data"))
- .setMetadata(ImmutableSet.of(new Metadata("name", "value")));
- }
-}
http://git-wip-us.apache.org/repos/asf/aurora/blob/449a835e/src/test/java/org/apache/aurora/scheduler/storage/db/DbJobUpdateStoreTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/aurora/scheduler/storage/db/DbJobUpdateStoreTest.java b/src/test/java/org/apache/aurora/scheduler/storage/db/DbJobUpdateStoreTest.java
new file mode 100644
index 0000000..219676f
--- /dev/null
+++ b/src/test/java/org/apache/aurora/scheduler/storage/db/DbJobUpdateStoreTest.java
@@ -0,0 +1,1061 @@
+/**
+ * Licensed 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.aurora.scheduler.storage.db;
+
+import java.util.List;
+import java.util.Set;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+
+import org.apache.aurora.gen.InstanceTaskConfig;
+import org.apache.aurora.gen.JobInstanceUpdateEvent;
+import org.apache.aurora.gen.JobUpdate;
+import org.apache.aurora.gen.JobUpdateAction;
+import org.apache.aurora.gen.JobUpdateDetails;
+import org.apache.aurora.gen.JobUpdateEvent;
+import org.apache.aurora.gen.JobUpdateInstructions;
+import org.apache.aurora.gen.JobUpdateKey;
+import org.apache.aurora.gen.JobUpdateQuery;
+import org.apache.aurora.gen.JobUpdateSettings;
+import org.apache.aurora.gen.JobUpdateState;
+import org.apache.aurora.gen.JobUpdateStatus;
+import org.apache.aurora.gen.JobUpdateSummary;
+import org.apache.aurora.gen.Lock;
+import org.apache.aurora.gen.LockKey;
+import org.apache.aurora.gen.Range;
+import org.apache.aurora.gen.TaskConfig;
+import org.apache.aurora.gen.storage.StoredJobUpdateDetails;
+import org.apache.aurora.scheduler.base.JobKeys;
+import org.apache.aurora.scheduler.base.TaskTestUtil;
+import org.apache.aurora.scheduler.storage.Storage;
+import org.apache.aurora.scheduler.storage.Storage.MutableStoreProvider;
+import org.apache.aurora.scheduler.storage.Storage.MutateWork;
+import org.apache.aurora.scheduler.storage.Storage.StorageException;
+import org.apache.aurora.scheduler.storage.Storage.Work.Quiet;
+import org.apache.aurora.scheduler.storage.entities.IJobInstanceUpdateEvent;
+import org.apache.aurora.scheduler.storage.entities.IJobKey;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdate;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateDetails;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateEvent;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateInstructions;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateKey;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateQuery;
+import org.apache.aurora.scheduler.storage.entities.IJobUpdateSummary;
+import org.apache.aurora.scheduler.storage.entities.ILock;
+import org.apache.aurora.scheduler.storage.testing.StorageEntityUtil;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLBACK_FAILED;
+import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLED_BACK;
+import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_ROLLING_BACK;
+import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_UPDATED;
+import static org.apache.aurora.gen.JobUpdateAction.INSTANCE_UPDATING;
+import static org.apache.aurora.gen.JobUpdateStatus.ABORTED;
+import static org.apache.aurora.gen.JobUpdateStatus.ERROR;
+import static org.apache.aurora.gen.JobUpdateStatus.FAILED;
+import static org.apache.aurora.gen.JobUpdateStatus.ROLLED_BACK;
+import static org.apache.aurora.gen.JobUpdateStatus.ROLLING_BACK;
+import static org.apache.aurora.gen.JobUpdateStatus.ROLLING_FORWARD;
+import static org.apache.aurora.gen.JobUpdateStatus.ROLL_BACK_PAUSED;
+import static org.apache.aurora.gen.JobUpdateStatus.ROLL_FORWARD_PAUSED;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class DbJobUpdateStoreTest {
+
+ private static final IJobKey JOB = JobKeys.from("testRole", "testEnv", "job");
+ private static final IJobUpdateKey UPDATE1 =
+ IJobUpdateKey.build(new JobUpdateKey(JOB.newBuilder(), "update1"));
+ private static final IJobUpdateKey UPDATE2 = IJobUpdateKey.build(
+ new JobUpdateKey(JobKeys.from("testRole", "testEnv", "job2").newBuilder(), "update2"));
+ private static final long CREATED_MS = 111L;
+ private static final IJobUpdateEvent FIRST_EVENT =
+ makeJobUpdateEvent(ROLLING_FORWARD, CREATED_MS);
+
+ private Storage storage;
+
+ @Before
+ public void setUp() throws Exception {
+ storage = DbUtil.createStorage();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ truncateUpdates();
+ }
+
+ @Test
+ public void testSaveJobUpdates() {
+ IJobUpdateKey updateId1 = makeKey(JobKeys.from("role", "env", "name1"), "u1");
+ IJobUpdateKey updateId2 = makeKey(JobKeys.from("role", "env", "name2"), "u2");
+
+ IJobUpdate update1 = makeJobUpdate(updateId1);
+ IJobUpdate update2 = makeJobUpdate(updateId2);
+
+ assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId1));
+ assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId2));
+
+ StorageEntityUtil.assertFullyPopulated(
+ update1,
+ StorageEntityUtil.getField(JobUpdateSummary.class, "state"),
+ StorageEntityUtil.getField(IJobUpdateSummary.class, "state"),
+ StorageEntityUtil.getField(Range.class, "first"),
+ StorageEntityUtil.getField(Range.class, "last"));
+ saveUpdate(update1, Optional.of("lock1"));
+ assertUpdate(update1);
+
+ saveUpdate(update2, Optional.<String>absent());
+ assertUpdate(update2);
+
+ // Colliding update IDs should be forbidden.
+ IJobUpdate update3 =
+ makeJobUpdate(makeKey(JobKeys.from("role", "env", "name3"), updateId2.getId()));
+ try {
+ saveUpdate(update3, Optional.<String>absent());
+ fail("Update ID collision should not be allowed");
+ } catch (StorageException e) {
+ // Expected.
+ }
+ }
+
+ @Test
+ public void testSaveNullInitialState() {
+ JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+ builder.getInstructions().unsetInitialState();
+
+ // Save with null initial state instances.
+ saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+
+ builder.getInstructions().setInitialState(ImmutableSet.<InstanceTaskConfig>of());
+ assertUpdate(IJobUpdate.build(builder));
+ }
+
+ @Test
+ public void testSaveNullDesiredState() {
+ JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+ builder.getInstructions().unsetDesiredState();
+
+ // Save with null desired state instances.
+ saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+
+ assertUpdate(IJobUpdate.build(builder));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testSaveBothInitialAndDesiredMissingThrows() {
+ JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+ builder.getInstructions().unsetInitialState();
+ builder.getInstructions().unsetDesiredState();
+
+ saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void testSaveNullInitialStateTaskThrows() {
+ JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+ builder.getInstructions().getInitialState().add(
+ new InstanceTaskConfig(null, ImmutableSet.<Range>of()));
+
+ saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testSaveEmptyInitialStateRangesThrows() {
+ JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+ builder.getInstructions().getInitialState().add(
+ new InstanceTaskConfig(new TaskConfig(), ImmutableSet.<Range>of()));
+
+ saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+ }
+
+ @Test(expected = NullPointerException.class)
+ public void testSaveNullDesiredStateTaskThrows() {
+ JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+ builder.getInstructions().getDesiredState().setTask(null);
+
+ saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testSaveEmptyDesiredStateRangesThrows() {
+ JobUpdate builder = makeJobUpdate(makeKey("u1")).newBuilder();
+ builder.getInstructions().getDesiredState().setInstances(ImmutableSet.<Range>of());
+
+ saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+ }
+
+ @Test
+ public void testSaveJobUpdateEmptyInstanceOverrides() {
+ IJobUpdateKey updateId = makeKey("u1");
+
+ IJobUpdate update = makeJobUpdate(updateId);
+ JobUpdate builder = update.newBuilder();
+ builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(ImmutableSet.<Range>of());
+
+ IJobUpdate expected = IJobUpdate.build(builder);
+
+ // Save with empty overrides.
+ saveUpdate(expected, Optional.of("lock"));
+ assertUpdate(expected);
+ }
+
+ @Test
+ public void testSaveJobUpdateNullInstanceOverrides() {
+ IJobUpdateKey updateId = makeKey("u1");
+
+ IJobUpdate update = makeJobUpdate(updateId);
+ JobUpdate builder = update.newBuilder();
+ builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(ImmutableSet.<Range>of());
+
+ IJobUpdate expected = IJobUpdate.build(builder);
+
+ // Save with null overrides.
+ builder.getInstructions().getSettings().setUpdateOnlyTheseInstances(null);
+ saveUpdate(IJobUpdate.build(builder), Optional.of("lock"));
+ assertUpdate(expected);
+ }
+
+ @Test(expected = StorageException.class)
+ public void testSaveJobUpdateTwiceThrows() {
+ IJobUpdateKey updateId = makeKey("u1");
+ IJobUpdate update = makeJobUpdate(updateId);
+
+ saveUpdate(update, Optional.of("lock1"));
+ saveUpdate(update, Optional.of("lock2"));
+ }
+
+ @Test
+ public void testSaveJobEvents() {
+ IJobUpdateKey updateId = makeKey("u3");
+ IJobUpdate update = makeJobUpdate(updateId);
+ IJobUpdateEvent event1 = makeJobUpdateEvent(ROLLING_FORWARD, 124L);
+ IJobUpdateEvent event2 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 125L);
+
+ saveUpdate(update, Optional.of("lock1"));
+ assertUpdate(update);
+ assertEquals(ImmutableList.of(FIRST_EVENT), getUpdateDetails(updateId).get().getUpdateEvents());
+
+ saveJobEvent(event1, updateId);
+ assertEquals(
+ populateExpected(update, ROLLING_FORWARD, CREATED_MS, 124L),
+ getUpdateDetails(updateId).get().getUpdate());
+ assertEquals(event1, getUpdateDetails(updateId).get().getUpdateEvents().get(1));
+
+ saveJobEvent(event2, updateId);
+ assertEquals(
+ populateExpected(update, ROLL_FORWARD_PAUSED, CREATED_MS, 125L),
+ getUpdateDetails(updateId).get().getUpdate());
+ assertEquals(event1, getUpdateDetails(updateId).get().getUpdateEvents().get(1));
+ assertEquals(event2, getUpdateDetails(updateId).get().getUpdateEvents().get(2));
+ }
+
+ @Test
+ public void testSaveInstanceEvents() {
+ IJobUpdateKey updateId = makeKey("u3");
+ IJobUpdate update = makeJobUpdate(updateId);
+ IJobInstanceUpdateEvent event1 = makeJobInstanceEvent(0, 125L, INSTANCE_UPDATED);
+ IJobInstanceUpdateEvent event2 = makeJobInstanceEvent(1, 126L, INSTANCE_ROLLING_BACK);
+
+ saveUpdate(update, Optional.of("lock"));
+ assertUpdate(update);
+ assertEquals(0, getUpdateDetails(updateId).get().getInstanceEvents().size());
+
+ saveJobInstanceEvent(event1, updateId);
+ assertEquals(
+ populateExpected(update, ROLLING_FORWARD, CREATED_MS, 125L),
+ getUpdateDetails(updateId).get().getUpdate());
+ assertEquals(
+ event1,
+ Iterables.getOnlyElement(getUpdateDetails(updateId).get().getInstanceEvents()));
+
+ saveJobInstanceEvent(event2, updateId);
+ assertEquals(
+ populateExpected(update, ROLLING_FORWARD, CREATED_MS, 126L),
+ getUpdateDetails(updateId).get().getUpdate());
+ assertEquals(event1, getUpdateDetails(updateId).get().getInstanceEvents().get(0));
+ assertEquals(event2, getUpdateDetails(updateId).get().getInstanceEvents().get(1));
+ }
+
+ @Test(expected = StorageException.class)
+ public void testSaveJobEventWithoutUpdateFails() {
+ saveJobEvent(makeJobUpdateEvent(ROLLING_FORWARD, 123L), makeKey("u2"));
+ }
+
+ @Test(expected = StorageException.class)
+ public void testSaveInstanceEventWithoutUpdateFails() {
+ saveJobInstanceEvent(makeJobInstanceEvent(0, 125L, INSTANCE_UPDATED), makeKey("u1"));
+ }
+
+ @Test
+ public void testSaveJobUpdateStateIgnored() {
+ IJobUpdateKey updateId = makeKey("u1");
+ IJobUpdate update = populateExpected(makeJobUpdate(updateId), ABORTED, 567L, 567L);
+ saveUpdate(update, Optional.of("lock1"));
+
+ // Assert state fields were ignored.
+ assertUpdate(update);
+ }
+
+ @Test
+ public void testSaveJobUpdateWithoutEventFailsSelect() {
+ final IJobUpdateKey updateId = makeKey("u3");
+ storage.write(new MutateWork.NoResult.Quiet() {
+ @Override
+ public void execute(MutableStoreProvider storeProvider) {
+ IJobUpdate update = makeJobUpdate(updateId);
+ storeProvider.getLockStore().saveLock(makeLock(update.getSummary().getJobKey(), "lock1"));
+ storeProvider.getJobUpdateStore().saveJobUpdate(update, Optional.of("lock1"));
+ }
+ });
+ assertEquals(Optional.<IJobUpdateDetails>absent(), getUpdateDetails(updateId));
+ }
+
+ @Test
+ public void testMultipleJobDetails() {
+ IJobUpdateKey updateId1 = makeKey(JobKeys.from("role", "env", "name1"), "u1");
+ IJobUpdateKey updateId2 = makeKey(JobKeys.from("role", "env", "name2"), "u2");
+ IJobUpdateDetails details1 = makeJobDetails(makeJobUpdate(updateId1));
+ IJobUpdateDetails details2 = makeJobDetails(makeJobUpdate(updateId2));
+
+ assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
+
+ saveUpdate(details1.getUpdate(), Optional.of("lock1"));
+ saveUpdate(details2.getUpdate(), Optional.of("lock2"));
+
+ details1 = updateJobDetails(populateExpected(details1.getUpdate()), FIRST_EVENT);
+ details2 = updateJobDetails(populateExpected(details2.getUpdate()), FIRST_EVENT);
+ assertEquals(Optional.of(details1), getUpdateDetails(updateId1));
+ assertEquals(Optional.of(details2), getUpdateDetails(updateId2));
+
+ IJobUpdateEvent jEvent11 = makeJobUpdateEvent(ROLLING_FORWARD, 456L);
+ IJobUpdateEvent jEvent12 = makeJobUpdateEvent(ERROR, 457L);
+ IJobInstanceUpdateEvent iEvent11 = makeJobInstanceEvent(1, 451L, INSTANCE_UPDATED);
+ IJobInstanceUpdateEvent iEvent12 = makeJobInstanceEvent(2, 452L, INSTANCE_UPDATING);
+
+ IJobUpdateEvent jEvent21 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 567L);
+ IJobUpdateEvent jEvent22 = makeJobUpdateEvent(ABORTED, 568L);
+ IJobInstanceUpdateEvent iEvent21 = makeJobInstanceEvent(3, 561L, INSTANCE_UPDATING);
+ IJobInstanceUpdateEvent iEvent22 = makeJobInstanceEvent(3, 562L, INSTANCE_UPDATED);
+
+ saveJobEvent(jEvent11, updateId1);
+ saveJobEvent(jEvent12, updateId1);
+ saveJobInstanceEvent(iEvent11, updateId1);
+ saveJobInstanceEvent(iEvent12, updateId1);
+
+ saveJobEvent(jEvent21, updateId2);
+ saveJobEvent(jEvent22, updateId2);
+ assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
+ saveJobInstanceEvent(iEvent21, updateId2);
+
+ assertEquals(ImmutableList.of(iEvent21), getInstanceEvents(updateId2, 3));
+ saveJobInstanceEvent(iEvent22, updateId2);
+ assertEquals(ImmutableList.of(iEvent21, iEvent22), getInstanceEvents(updateId2, 3));
+
+ details1 = updateJobDetails(
+ populateExpected(details1.getUpdate(), ERROR, CREATED_MS, 457L),
+ ImmutableList.of(FIRST_EVENT, jEvent11, jEvent12), ImmutableList.of(iEvent11, iEvent12));
+
+ details2 = updateJobDetails(
+ populateExpected(details2.getUpdate(), ABORTED, CREATED_MS, 568L),
+ ImmutableList.of(FIRST_EVENT, jEvent21, jEvent22), ImmutableList.of(iEvent21, iEvent22));
+
+ assertEquals(Optional.of(details1), getUpdateDetails(updateId1));
+ assertEquals(Optional.of(details2), getUpdateDetails(updateId2));
+
+ assertEquals(
+ ImmutableSet.of(
+ new StoredJobUpdateDetails(details1.newBuilder(), "lock1"),
+ new StoredJobUpdateDetails(details2.newBuilder(), "lock2")),
+ getAllUpdateDetails());
+
+ assertEquals(
+ ImmutableList.of(getUpdateDetails(updateId2).get(), getUpdateDetails(updateId1).get()),
+ queryDetails(new JobUpdateQuery().setRole("role")));
+ }
+
+ @Test
+ public void testTruncateJobUpdates() {
+ IJobUpdateKey updateId = makeKey("u5");
+ IJobUpdate update = makeJobUpdate(updateId);
+ IJobInstanceUpdateEvent instanceEvent = IJobInstanceUpdateEvent.build(
+ new JobInstanceUpdateEvent(0, 125L, INSTANCE_ROLLBACK_FAILED));
+
+ saveUpdate(update, Optional.of("lock"));
+ saveJobEvent(makeJobUpdateEvent(ROLLING_FORWARD, 123L), updateId);
+ saveJobInstanceEvent(instanceEvent, updateId);
+ assertEquals(
+ populateExpected(update, ROLLING_FORWARD, CREATED_MS, 125L),
+ getUpdate(updateId).get());
+ assertEquals(2, getUpdateDetails(updateId).get().getUpdateEvents().size());
+ assertEquals(1, getUpdateDetails(updateId).get().getInstanceEvents().size());
+
+ truncateUpdates();
+ assertEquals(Optional.<IJobUpdateDetails>absent(), getUpdateDetails(updateId));
+ }
+
+ @Test
+ public void testPruneHistory() {
+ IJobUpdateKey updateId1 = makeKey("u11");
+ IJobUpdateKey updateId2 = makeKey("u12");
+ IJobUpdateKey updateId3 = makeKey("u13");
+ IJobUpdateKey updateId4 = makeKey("u14");
+ IJobKey job2 = JobKeys.from("testRole2", "testEnv2", "job2");
+ IJobUpdateKey updateId5 = makeKey(job2, "u15");
+ IJobUpdateKey updateId6 = makeKey(job2, "u16");
+ IJobUpdateKey updateId7 = makeKey(job2, "u17");
+
+ IJobUpdate update1 = makeJobUpdate(updateId1);
+ IJobUpdate update2 = makeJobUpdate(updateId2);
+ IJobUpdate update3 = makeJobUpdate(updateId3);
+ IJobUpdate update4 = makeJobUpdate(updateId4);
+ IJobUpdate update5 = makeJobUpdate(updateId5);
+ IJobUpdate update6 = makeJobUpdate(updateId6);
+ IJobUpdate update7 = makeJobUpdate(updateId7);
+
+ IJobUpdateEvent updateEvent1 = makeJobUpdateEvent(ROLLING_BACK, 123L);
+ IJobUpdateEvent updateEvent2 = makeJobUpdateEvent(ABORTED, 124L);
+ IJobUpdateEvent updateEvent3 = makeJobUpdateEvent(ROLLED_BACK, 125L);
+ IJobUpdateEvent updateEvent4 = makeJobUpdateEvent(FAILED, 126L);
+ IJobUpdateEvent updateEvent5 = makeJobUpdateEvent(ERROR, 123L);
+ IJobUpdateEvent updateEvent6 = makeJobUpdateEvent(FAILED, 125L);
+ IJobUpdateEvent updateEvent7 = makeJobUpdateEvent(ROLLING_FORWARD, 126L);
+
+ update1 = populateExpected(
+ saveUpdateNoEvent(update1, Optional.of("lock1")), ROLLING_BACK, 123L, 123L);
+ update2 = populateExpected(
+ saveUpdateNoEvent(update2, Optional.<String>absent()), ABORTED, 124L, 124L);
+ update3 = populateExpected(
+ saveUpdateNoEvent(update3, Optional.<String>absent()), ROLLED_BACK, 125L, 125L);
+ update4 = populateExpected(
+ saveUpdateNoEvent(update4, Optional.<String>absent()), FAILED, 126L, 126L);
+ update5 = populateExpected(
+ saveUpdateNoEvent(update5, Optional.<String>absent()), ERROR, 123L, 123L);
+ update6 = populateExpected(
+ saveUpdateNoEvent(update6, Optional.<String>absent()), FAILED, 125L, 125L);
+ update7 = populateExpected(
+ saveUpdateNoEvent(update7, Optional.of("lock2")), ROLLING_FORWARD, 126L, 126L);
+
+ saveJobEvent(updateEvent1, updateId1);
+ saveJobEvent(updateEvent2, updateId2);
+ saveJobEvent(updateEvent3, updateId3);
+ saveJobEvent(updateEvent4, updateId4);
+ saveJobEvent(updateEvent5, updateId5);
+ saveJobEvent(updateEvent6, updateId6);
+ saveJobEvent(updateEvent7, updateId7);
+
+ assertEquals(update1, getUpdate(updateId1).get());
+ assertEquals(update2, getUpdate(updateId2).get());
+ assertEquals(update3, getUpdate(updateId3).get());
+ assertEquals(update4, getUpdate(updateId4).get());
+ assertEquals(update5, getUpdate(updateId5).get());
+ assertEquals(update6, getUpdate(updateId6).get());
+ assertEquals(update7, getUpdate(updateId7).get());
+
+ long pruningThreshold = 120L;
+
+ // No updates pruned.
+ assertEquals(ImmutableSet.<IJobUpdateKey>of(), pruneHistory(3, pruningThreshold));
+ assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
+ assertEquals(Optional.of(update6), getUpdate(updateId6));
+ assertEquals(Optional.of(update5), getUpdate(updateId5));
+
+ assertEquals(Optional.of(update4), getUpdate(updateId4));
+ assertEquals(Optional.of(update3), getUpdate(updateId3));
+ assertEquals(Optional.of(update2), getUpdate(updateId2));
+ assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
+
+ assertEquals(ImmutableSet.of(updateId2), pruneHistory(2, pruningThreshold));
+ // No updates pruned.
+ assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
+ assertEquals(Optional.of(update6), getUpdate(updateId6));
+ assertEquals(Optional.of(update5), getUpdate(updateId5));
+
+ // 1 update pruned.
+ assertEquals(Optional.of(update4), getUpdate(updateId4));
+ assertEquals(Optional.of(update3), getUpdate(updateId3));
+ assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId2));
+ assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
+
+ assertEquals(ImmutableSet.of(updateId5, updateId3), pruneHistory(1, pruningThreshold));
+ // 1 update pruned.
+ assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
+ assertEquals(Optional.of(update6), getUpdate(updateId6));
+ assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId5));
+
+ // 2 updates pruned.
+ assertEquals(Optional.of(update4), getUpdate(updateId4));
+ assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId3));
+ assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
+
+ // The oldest update is pruned.
+ assertEquals(ImmutableSet.of(updateId6), pruneHistory(1, 126L));
+ assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
+ assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId6));
+
+ assertEquals(Optional.of(update4), getUpdate(updateId4));
+ assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
+
+ // Nothing survives the 0 per job count.
+ assertEquals(ImmutableSet.of(updateId4), pruneHistory(0, pruningThreshold));
+ assertEquals(Optional.of(update7), getUpdate(updateId7)); // active update
+
+ assertEquals(Optional.<IJobUpdate>absent(), getUpdate(updateId4));
+ assertEquals(Optional.of(update1), getUpdate(updateId1)); // active update
+ }
+
+ @Test(expected = StorageException.class)
+ public void testSaveUpdateWithoutLock() {
+ final IJobUpdate update = makeJobUpdate(makeKey("updateId"));
+ storage.write(new MutateWork.NoResult.Quiet() {
+ @Override
+ public void execute(MutableStoreProvider storeProvider) {
+ storeProvider.getJobUpdateStore().saveJobUpdate(update, Optional.of("lock"));
+ }
+ });
+ }
+
+ @Test(expected = StorageException.class)
+ public void testSaveTwoUpdatesForOneJob() {
+ final IJobUpdate update = makeJobUpdate(makeKey("updateId"));
+ saveUpdate(update, Optional.of("lock1"));
+ saveUpdate(update, Optional.of("lock2"));
+ }
+
+ @Test(expected = StorageException.class)
+ public void testSaveTwoUpdatesSameJobKey() {
+ final IJobUpdate update1 = makeJobUpdate(makeKey("update1"));
+ final IJobUpdate update2 = makeJobUpdate(makeKey("update2"));
+ saveUpdate(update1, Optional.of("lock1"));
+ saveUpdate(update2, Optional.of("lock1"));
+ }
+
+ @Test
+ public void testLockCleared() {
+ final IJobUpdate update = makeJobUpdate(makeKey("update1"));
+ saveUpdate(update, Optional.of("lock1"));
+
+ removeLock(update, "lock1");
+
+ assertEquals(
+ Optional.of(updateJobDetails(populateExpected(update), FIRST_EVENT)),
+ getUpdateDetails(makeKey("update1")));
+ assertEquals(
+ ImmutableSet.of(
+ new StoredJobUpdateDetails(
+ updateJobDetails(populateExpected(update), FIRST_EVENT).newBuilder(),
+ null)),
+ getAllUpdateDetails());
+
+ assertEquals(
+ ImmutableList.of(populateExpected(update).getSummary()),
+ getSummaries(new JobUpdateQuery().setKey(UPDATE1.newBuilder())));
+
+ // If the lock has been released for this job, we can start another update.
+ saveUpdate(makeJobUpdate(makeKey("update2")), Optional.of("lock2"));
+ }
+
+ private static final Optional<String> NO_TOKEN = Optional.absent();
+
+ @Test
+ public void testGetLockToken() {
+ storage.write(new MutateWork.NoResult.Quiet() {
+ @Override
+ public void execute(MutableStoreProvider storeProvider) {
+ final IJobUpdate update1 = makeJobUpdate(UPDATE1);
+ final IJobUpdate update2 = makeJobUpdate(UPDATE2);
+ saveUpdate(update1, Optional.of("lock1"));
+ assertEquals(
+ Optional.of("lock1"),
+ storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
+ assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
+
+ saveUpdate(update2, Optional.of("lock2"));
+ assertEquals(
+ Optional.of("lock1"),
+ storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
+ assertEquals(
+ Optional.of("lock2"),
+ storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
+
+ storeProvider.getLockStore().removeLock(
+ makeLock(update1.getSummary().getJobKey(), "lock1").getKey());
+ assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
+ assertEquals(
+ Optional.of("lock2"),
+ storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
+
+ storeProvider.getLockStore().removeLock(
+ makeLock(update2.getSummary().getJobKey(), "lock2").getKey());
+ assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE1));
+ assertEquals(NO_TOKEN, storeProvider.getJobUpdateStore().getLockToken(UPDATE2));
+ }
+ });
+ }
+
+ @Test
+ public void testGetSummaries() {
+ String role1 = "role1";
+ IJobKey job1 = JobKeys.from(role1, "env", "name1");
+ IJobKey job2 = JobKeys.from(role1, "env", "name2");
+ IJobKey job3 = JobKeys.from(role1, "env", "name3");
+ IJobKey job4 = JobKeys.from(role1, "env", "name4");
+ IJobKey job5 = JobKeys.from("role", "env", "name5");
+ IJobUpdateSummary s1 =
+ saveSummary(makeKey(job1, "u1"), 1230L, ROLLED_BACK, "user", Optional.of("lock1"));
+ IJobUpdateSummary s2 =
+ saveSummary(makeKey(job2, "u2"), 1231L, ABORTED, "user", Optional.of("lock2"));
+ IJobUpdateSummary s3 =
+ saveSummary(makeKey(job3, "u3"), 1239L, ERROR, "user2", Optional.of("lock3"));
+ IJobUpdateSummary s4 =
+ saveSummary(makeKey(job4, "u4"), 1234L, ROLL_BACK_PAUSED, "user3", Optional.of("lock4"));
+ IJobUpdateSummary s5 =
+ saveSummary(makeKey(job5, "u5"), 1235L, ROLLING_FORWARD, "user4", Optional.of("lock5"));
+
+ // Test empty query returns all.
+ assertEquals(ImmutableList.of(s3, s5, s4, s2, s1), getSummaries(new JobUpdateQuery()));
+
+ // Test query by updateId.
+ assertEquals(
+ ImmutableList.of(s1),
+ getSummaries(new JobUpdateQuery().setKey(new JobUpdateKey(job1.newBuilder(), "u1"))));
+
+ // Test query by role.
+ assertEquals(
+ ImmutableList.of(s3, s4, s2, s1),
+ getSummaries(new JobUpdateQuery().setRole(role1)));
+
+ // Test query by job key.
+ assertEquals(
+ ImmutableList.of(s5),
+ getSummaries(new JobUpdateQuery().setJobKey(job5.newBuilder())));
+
+ // Test querying by update key.
+ assertEquals(
+ ImmutableList.of(s5),
+ getSummaries(
+ new JobUpdateQuery().setKey(new JobUpdateKey(job5.newBuilder(), s5.getUpdateId()))));
+
+ // Test querying by incorrect update keys.
+ assertEquals(
+ ImmutableList.<IJobUpdateSummary>of(),
+ getSummaries(
+ new JobUpdateQuery().setKey(new JobUpdateKey(job5.newBuilder(), s4.getUpdateId()))));
+ assertEquals(
+ ImmutableList.<IJobUpdateSummary>of(),
+ getSummaries(
+ new JobUpdateQuery().setKey(new JobUpdateKey(job4.newBuilder(), s5.getUpdateId()))));
+
+ // Test query by user.
+ assertEquals(ImmutableList.of(s2, s1), getSummaries(new JobUpdateQuery().setUser("user")));
+
+ // Test query by one status.
+ assertEquals(ImmutableList.of(s3), getSummaries(new JobUpdateQuery().setUpdateStatuses(
+ ImmutableSet.of(ERROR))));
+
+ // Test query by multiple statuses.
+ assertEquals(ImmutableList.of(s3, s2, s1), getSummaries(new JobUpdateQuery().setUpdateStatuses(
+ ImmutableSet.of(ERROR, ABORTED, ROLLED_BACK))));
+
+ // Test query by empty statuses.
+ assertEquals(
+ ImmutableList.of(s3, s5, s4, s2, s1),
+ getSummaries(new JobUpdateQuery().setUpdateStatuses(ImmutableSet.<JobUpdateStatus>of())));
+
+ // Test paging.
+ assertEquals(
+ ImmutableList.of(s3, s5),
+ getSummaries(new JobUpdateQuery().setLimit(2).setOffset(0)));
+ assertEquals(
+ ImmutableList.of(s4, s2),
+ getSummaries(new JobUpdateQuery().setLimit(2).setOffset(2)));
+ assertEquals(
+ ImmutableList.of(s1),
+ getSummaries(new JobUpdateQuery().setLimit(2).setOffset(4)));
+
+ // Test no match.
+ assertEquals(
+ ImmutableList.<IJobUpdateSummary>of(),
+ getSummaries(new JobUpdateQuery().setRole("no_match")));
+ }
+
+ @Test
+ public void testQueryDetails() {
+ IJobKey jobKey1 = JobKeys.from("role1", "env", "name1");
+ IJobUpdateKey updateId1 = makeKey(jobKey1, "u1");
+ IJobKey jobKey2 = JobKeys.from("role2", "env", "name2");
+ IJobUpdateKey updateId2 = makeKey(jobKey2, "u2");
+
+ IJobUpdate update1 = makeJobUpdate(updateId1);
+ IJobUpdate update2 = makeJobUpdate(updateId2);
+
+ assertEquals(ImmutableList.<IJobInstanceUpdateEvent>of(), getInstanceEvents(updateId2, 3));
+
+ saveUpdate(update1, Optional.of("lock1"));
+ saveUpdate(update2, Optional.of("lock2"));
+
+ updateJobDetails(populateExpected(update1), FIRST_EVENT);
+ updateJobDetails(populateExpected(update2), FIRST_EVENT);
+
+ IJobUpdateEvent jEvent11 = makeJobUpdateEvent(ROLLING_BACK, 450L);
+ IJobUpdateEvent jEvent12 = makeJobUpdateEvent(ROLLED_BACK, 500L);
+ IJobInstanceUpdateEvent iEvent11 = makeJobInstanceEvent(1, 451L, INSTANCE_ROLLING_BACK);
+ IJobInstanceUpdateEvent iEvent12 = makeJobInstanceEvent(2, 458L, INSTANCE_ROLLED_BACK);
+
+ IJobUpdateEvent jEvent21 = makeJobUpdateEvent(ROLL_FORWARD_PAUSED, 550L);
+ IJobUpdateEvent jEvent22 = makeJobUpdateEvent(ABORTED, 600L);
+ IJobInstanceUpdateEvent iEvent21 = makeJobInstanceEvent(3, 561L, INSTANCE_UPDATING);
+ IJobInstanceUpdateEvent iEvent22 = makeJobInstanceEvent(3, 570L, INSTANCE_UPDATED);
+
+ saveJobEvent(jEvent11, updateId1);
+ saveJobEvent(jEvent12, updateId1);
+ saveJobInstanceEvent(iEvent11, updateId1);
+ saveJobInstanceEvent(iEvent12, updateId1);
+
+ saveJobEvent(jEvent21, updateId2);
+ saveJobEvent(jEvent22, updateId2);
+
+ saveJobInstanceEvent(iEvent21, updateId2);
+ saveJobInstanceEvent(iEvent22, updateId2);
+
+ IJobUpdateDetails details1 = getUpdateDetails(updateId1).get();
+ IJobUpdateDetails details2 = getUpdateDetails(updateId2).get();
+
+ // Test empty query returns all.
+ assertEquals(ImmutableList.of(details2, details1), queryDetails(new JobUpdateQuery()));
+
+ // Test query by update ID.
+ assertEquals(
+ ImmutableList.of(details1),
+ queryDetails(new JobUpdateQuery().setKey(updateId1.newBuilder())));
+
+ // Test query by role.
+ assertEquals(
+ ImmutableList.of(details2),
+ queryDetails(new JobUpdateQuery().setRole(jobKey2.getRole())));
+
+ // Test query by job key.
+ assertEquals(
+ ImmutableList.of(details2),
+ queryDetails(new JobUpdateQuery().setJobKey(jobKey2.newBuilder())));
+
+ // Test query by status.
+ assertEquals(
+ ImmutableList.of(details2),
+ queryDetails(new JobUpdateQuery().setUpdateStatuses(ImmutableSet.of(ABORTED))));
+
+ // Test no match.
+ assertEquals(
+ ImmutableList.<IJobUpdateDetails>of(),
+ queryDetails(new JobUpdateQuery().setRole("no match")));
+ }
+
+ private static IJobUpdateKey makeKey(String id) {
+ return makeKey(JOB, id);
+ }
+
+ private static IJobUpdateKey makeKey(IJobKey job, String id) {
+ return IJobUpdateKey.build(new JobUpdateKey(job.newBuilder(), id));
+ }
+
+ private void assertUpdate(IJobUpdate expected) {
+ IJobUpdateKey key = expected.getSummary().getKey();
+ assertEquals(populateExpected(expected), getUpdate(key).get());
+ assertEquals(getUpdate(key).get(), getUpdateDetails(key).get().getUpdate());
+ assertEquals(getUpdateInstructions(key).get(), expected.getInstructions());
+ }
+
+ private Optional<IJobUpdate> getUpdate(final IJobUpdateKey key) {
+ return storage.read(new Quiet<Optional<IJobUpdate>>() {
+ @Override
+ public Optional<IJobUpdate> apply(Storage.StoreProvider storeProvider) {
+ return storeProvider.getJobUpdateStore().fetchJobUpdate(key);
+ }
+ });
+ }
+
+ private List<IJobInstanceUpdateEvent> getInstanceEvents(final IJobUpdateKey key, final int id) {
+ return storage.read(new Quiet<List<IJobInstanceUpdateEvent>>() {
+ @Override
+ public List<IJobInstanceUpdateEvent> apply(Storage.StoreProvider storeProvider) {
+ return storeProvider.getJobUpdateStore().fetchInstanceEvents(key, id);
+ }
+ });
+ }
+
+ private Optional<IJobUpdateInstructions> getUpdateInstructions(final IJobUpdateKey key) {
+ return storage.read(new Quiet<Optional<IJobUpdateInstructions>>() {
+ @Override
+ public Optional<IJobUpdateInstructions> apply(Storage.StoreProvider storeProvider) {
+ return storeProvider.getJobUpdateStore().fetchJobUpdateInstructions(key);
+ }
+ });
+ }
+
+ private Optional<IJobUpdateDetails> getUpdateDetails(final IJobUpdateKey key) {
+ return storage.read(new Quiet<Optional<IJobUpdateDetails>>() {
+ @Override
+ public Optional<IJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
+ return storeProvider.getJobUpdateStore().fetchJobUpdateDetails(key);
+ }
+ });
+ }
+
+ private Set<StoredJobUpdateDetails> getAllUpdateDetails() {
+ return storage.read(new Quiet<Set<StoredJobUpdateDetails>>() {
+ @Override
+ public Set<StoredJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
+ return storeProvider.getJobUpdateStore().fetchAllJobUpdateDetails();
+ }
+ });
+ }
+
+ private List<IJobUpdateDetails> queryDetails(final JobUpdateQuery query) {
+ return storage.read(new Quiet<List<IJobUpdateDetails>>() {
+ @Override
+ public List<IJobUpdateDetails> apply(Storage.StoreProvider storeProvider) {
+ return storeProvider.getJobUpdateStore().fetchJobUpdateDetails(
+ IJobUpdateQuery.build(query));
+ }
+ });
+ }
+
+ private List<IJobUpdateSummary> getSummaries(final JobUpdateQuery query) {
+ return storage.read(new Quiet<List<IJobUpdateSummary>>() {
+ @Override
+ public List<IJobUpdateSummary> apply(Storage.StoreProvider storeProvider) {
+ return storeProvider.getJobUpdateStore().fetchJobUpdateSummaries(
+ IJobUpdateQuery.build(query));
+ }
+ });
+ }
+
+ private static ILock makeLock(IJobKey jobKey, String lockToken) {
+ return ILock.build(new Lock()
+ .setKey(LockKey.job(jobKey.newBuilder()))
+ .setToken(lockToken)
+ .setTimestampMs(100)
+ .setUser("fake user"));
+ }
+
+ private IJobUpdate saveUpdate(final IJobUpdate update, final Optional<String> lockToken) {
+ storage.write(new MutateWork.NoResult.Quiet() {
+ @Override
+ public void execute(MutableStoreProvider storeProvider) {
+ if (lockToken.isPresent()) {
+ storeProvider.getLockStore().saveLock(
+ makeLock(update.getSummary().getJobKey(), lockToken.get()));
+ }
+ storeProvider.getJobUpdateStore().saveJobUpdate(update, lockToken);
+ storeProvider.getJobUpdateStore().saveJobUpdateEvent(
+ update.getSummary().getKey(),
+ FIRST_EVENT);
+ }
+ });
+
+ return update;
+ }
+
+ private IJobUpdate saveUpdateNoEvent(final IJobUpdate update, final Optional<String> lockToken) {
+ storage.write(new MutateWork.NoResult.Quiet() {
+ @Override
+ public void execute(MutableStoreProvider storeProvider) {
+ if (lockToken.isPresent()) {
+ storeProvider.getLockStore().saveLock(
+ makeLock(update.getSummary().getJobKey(), lockToken.get()));
+ }
+ storeProvider.getJobUpdateStore().saveJobUpdate(update, lockToken);
+ }
+ });
+
+ return update;
+ }
+
+ private void saveJobEvent(final IJobUpdateEvent event, final IJobUpdateKey key) {
+ storage.write(new MutateWork.NoResult.Quiet() {
+ @Override
+ public void execute(MutableStoreProvider storeProvider) {
+ storeProvider.getJobUpdateStore().saveJobUpdateEvent(key, event);
+ }
+ });
+ }
+
+ private void saveJobInstanceEvent(final IJobInstanceUpdateEvent event, final IJobUpdateKey key) {
+ storage.write(new MutateWork.NoResult.Quiet() {
+ @Override
+ public void execute(MutableStoreProvider storeProvider) {
+ storeProvider.getJobUpdateStore().saveJobInstanceUpdateEvent(key, event);
+ }
+ });
+ }
+
+ private void truncateUpdates() {
+ storage.write(new MutateWork.NoResult.Quiet() {
+ @Override
+ public void execute(MutableStoreProvider storeProvider) {
+ storeProvider.getJobUpdateStore().deleteAllUpdatesAndEvents();
+ }
+ });
+ }
+
+ private Set<IJobUpdateKey> pruneHistory(final int retainCount, final long pruningThresholdMs) {
+ return storage.write(new MutateWork.Quiet<Set<IJobUpdateKey>>() {
+ @Override
+ public Set<IJobUpdateKey> apply(MutableStoreProvider storeProvider) {
+ return storeProvider.getJobUpdateStore().pruneHistory(retainCount, pruningThresholdMs);
+ }
+ });
+ }
+
+ private void removeLock(final IJobUpdate update, final String lockToken) {
+ storage.write(new MutateWork.NoResult.Quiet() {
+ @Override
+ public void execute(MutableStoreProvider storeProvider) {
+ storeProvider.getLockStore().removeLock(
+ makeLock(update.getSummary().getJobKey(), lockToken).getKey());
+ }
+ });
+ }
+
+ private IJobUpdate populateExpected(IJobUpdate update) {
+ return populateExpected(update, ROLLING_FORWARD, CREATED_MS, CREATED_MS);
+ }
+
+ private IJobUpdate populateExpected(
+ IJobUpdate update,
+ JobUpdateStatus status,
+ long createdMs,
+ long lastMs) {
+
+ JobUpdateState state = new JobUpdateState()
+ .setCreatedTimestampMs(createdMs)
+ .setLastModifiedTimestampMs(lastMs)
+ .setStatus(status);
+ JobUpdate builder = update.newBuilder();
+ builder.getSummary().setState(state);
+ return IJobUpdate.build(builder);
+ }
+
+ private static IJobUpdateEvent makeJobUpdateEvent(JobUpdateStatus status, long timestampMs) {
+ return IJobUpdateEvent.build(
+ new JobUpdateEvent(status, timestampMs)
+ .setUser("user")
+ .setMessage("message"));
+ }
+
+ private IJobInstanceUpdateEvent makeJobInstanceEvent(
+ int instanceId,
+ long timestampMs,
+ JobUpdateAction action) {
+
+ return IJobInstanceUpdateEvent.build(
+ new JobInstanceUpdateEvent(instanceId, timestampMs, action));
+ }
+
+ private IJobUpdateDetails makeJobDetails(IJobUpdate update) {
+ return updateJobDetails(
+ update,
+ ImmutableList.of(FIRST_EVENT),
+ ImmutableList.<IJobInstanceUpdateEvent>of());
+ }
+
+ private IJobUpdateDetails updateJobDetails(IJobUpdate update, IJobUpdateEvent event) {
+ return updateJobDetails(
+ update,
+ ImmutableList.of(event),
+ ImmutableList.<IJobInstanceUpdateEvent>of());
+ }
+
+ private IJobUpdateDetails updateJobDetails(
+ IJobUpdate update,
+ List<IJobUpdateEvent> jobEvents,
+ List<IJobInstanceUpdateEvent> instanceEvents) {
+
+ return IJobUpdateDetails.build(new JobUpdateDetails()
+ .setUpdate(update.newBuilder())
+ .setUpdateEvents(IJobUpdateEvent.toBuildersList(jobEvents))
+ .setInstanceEvents(IJobInstanceUpdateEvent.toBuildersList(instanceEvents)));
+ }
+
+ private IJobUpdateSummary makeSummary(IJobUpdateKey key, String user) {
+ return IJobUpdateSummary.build(new JobUpdateSummary()
+ .setKey(key.newBuilder())
+ .setUpdateId(key.getId())
+ .setJobKey(key.getJob().newBuilder())
+ .setUser(user));
+ }
+
+ private IJobUpdateSummary saveSummary(
+ IJobUpdateKey key,
+ Long modifiedTimestampMs,
+ JobUpdateStatus status,
+ String user,
+ Optional<String> lockToken) {
+
+ IJobUpdateSummary summary = IJobUpdateSummary.build(new JobUpdateSummary()
+ .setKey(key.newBuilder())
+ .setUpdateId(key.getId())
+ .setJobKey(key.getJob().newBuilder())
+ .setUser(user));
+
+ IJobUpdate update = makeJobUpdate(summary);
+ saveUpdate(update, lockToken);
+ saveJobEvent(makeJobUpdateEvent(status, modifiedTimestampMs), key);
+ return populateExpected(update, status, CREATED_MS, modifiedTimestampMs).getSummary();
+ }
+
+ private IJobUpdate makeJobUpdate(IJobUpdateSummary summary) {
+ return IJobUpdate.build(makeJobUpdate().newBuilder().setSummary(summary.newBuilder()));
+ }
+
+ private IJobUpdate makeJobUpdate(IJobUpdateKey key) {
+ return IJobUpdate.build(makeJobUpdate().newBuilder()
+ .setSummary(makeSummary(key, "user").newBuilder()));
+ }
+
+ private IJobUpdate makeJobUpdate() {
+ return IJobUpdate.build(new JobUpdate()
+ .setInstructions(makeJobUpdateInstructions().newBuilder()));
+ }
+
+ private IJobUpdateInstructions makeJobUpdateInstructions() {
+ TaskConfig config = TaskTestUtil.makeConfig(JOB).newBuilder();
+ return IJobUpdateInstructions.build(new JobUpdateInstructions()
+ .setDesiredState(new InstanceTaskConfig()
+ .setTask(config)
+ .setInstances(ImmutableSet.of(new Range(0, 7), new Range(8, 9))))
+ .setInitialState(ImmutableSet.of(
+ new InstanceTaskConfig()
+ .setInstances(ImmutableSet.of(new Range(0, 1), new Range(2, 3)))
+ .setTask(config),
+ new InstanceTaskConfig()
+ .setInstances(ImmutableSet.of(new Range(4, 5), new Range(6, 7)))
+ .setTask(config)))
+ .setSettings(new JobUpdateSettings()
+ .setBlockIfNoPulsesAfterMs(500)
+ .setUpdateGroupSize(1)
+ .setMaxPerInstanceFailures(1)
+ .setMaxFailedInstances(1)
+ .setMaxWaitToInstanceRunningMs(100)
+ .setMinWaitInInstanceRunningMs(200)
+ .setRollbackOnFailure(true)
+ .setWaitForBatchCompletion(true)
+ .setUpdateOnlyTheseInstances(ImmutableSet.of(new Range(0, 0), new Range(3, 5)))));
+ }
+}