@Test(enabled = false)
public void weCanCancelTasks(NodeMetadata node) throws InterruptedException, ExecutionException {
ListenableFuture<ExecResponse> future =
client.submitScriptOnNode(node.getId(), "sleep 300", nameTask("sleeper").runAsRoot(false));
ExecResponse response = null;
try {
response = future.get(1, TimeUnit.MILLISECONDS);
fail(node.getId() + ": " + response);
} catch (TimeoutException e) {
assert !future.isDone();
response =
client.runScriptOnNode(
node.getId(), "/tmp/init-sleeper status", wrapInInitScript(false).runAsRoot(false));
assert !response.getOutput().trim().equals("") : node.getId() + ": " + response;
future.cancel(true);
response =
client.runScriptOnNode(
node.getId(), "/tmp/init-sleeper status", wrapInInitScript(false).runAsRoot(false));
assert response.getOutput().trim().equals("") : node.getId() + ": " + response;
try {
future.get();
fail(future.toString());
} catch (CancellationException e1) {
}
}
}
@Test
public void testBufferCloseOnFinish() throws Exception {
SqlTask sqlTask = createInitialTask();
OutputBuffers outputBuffers =
INITIAL_EMPTY_OUTPUT_BUFFERS
.withBuffer("out", new UnpartitionedPagePartitionFunction())
.withNoMoreBufferIds();
updateTask(sqlTask, EMPTY_SOURCES, outputBuffers);
ListenableFuture<BufferResult> bufferResult =
sqlTask.getTaskResults("out", 0, new DataSize(1, MEGABYTE));
assertFalse(bufferResult.isDone());
// finish the task by closing the sources (no splits will ever be added)
updateTask(
sqlTask,
ImmutableList.of(
new TaskSource(TABLE_SCAN_NODE_ID, ImmutableSet.<ScheduledSplit>of(), true)),
outputBuffers);
assertEquals(sqlTask.getTaskInfo().getState(), TaskState.FINISHED);
// buffer will be closed by cancel event (wait for 500 MS for event to fire)
assertTrue(bufferResult.get(200, MILLISECONDS).isBufferClosed());
assertEquals(sqlTask.getTaskInfo().getOutputBuffers().getState(), BufferState.FINISHED);
// verify the buffer is closed
bufferResult = sqlTask.getTaskResults("out", 0, new DataSize(1, MEGABYTE));
assertTrue(bufferResult.isDone());
assertTrue(bufferResult.get().isBufferClosed());
}
@Test
public void pingPong() throws Exception {
connect();
Utils.rollMockClock(0);
// No ping pong happened yet.
assertEquals(Long.MAX_VALUE, peer.getLastPingTime());
assertEquals(Long.MAX_VALUE, peer.getPingTime());
ListenableFuture<Long> future = peer.ping();
assertEquals(Long.MAX_VALUE, peer.getLastPingTime());
assertEquals(Long.MAX_VALUE, peer.getPingTime());
assertFalse(future.isDone());
Ping pingMsg = (Ping) outbound(writeTarget);
Utils.rollMockClock(5);
// The pong is returned.
inbound(writeTarget, new Pong(pingMsg.getNonce()));
pingAndWait(writeTarget);
assertTrue(future.isDone());
long elapsed = future.get();
assertTrue("" + elapsed, elapsed > 1000);
assertEquals(elapsed, peer.getLastPingTime());
assertEquals(elapsed, peer.getPingTime());
// Do it again and make sure it affects the average.
future = peer.ping();
pingMsg = (Ping) outbound(writeTarget);
Utils.rollMockClock(50);
inbound(writeTarget, new Pong(pingMsg.getNonce()));
elapsed = future.get();
assertEquals(elapsed, peer.getLastPingTime());
assertEquals(7250, peer.getPingTime());
}
private void copyToS3(String fileName) {
String bucketName = (String) properties.get(BUCKET_PROPNAME);
String accessId = (String) properties.get(ACCESS_ID_PROPNAME);
String secretKey = (String) properties.get(SECRET_KEY_PROPNAME);
Properties overrides = new Properties();
overrides.setProperty("s3" + ".identity", accessId);
overrides.setProperty("s3" + ".credential", secretKey);
final Iterable<? extends Module> MODULES =
ImmutableSet.of(
new JavaUrlHttpCommandExecutorServiceModule(),
new Log4JLoggingModule(),
new NettyPayloadModule());
BlobStoreContext context =
ContextBuilder.newBuilder("s3")
.credentials(accessId, secretKey)
.modules(MODULES)
.overrides(overrides)
.buildView(BlobStoreContext.class);
// Create Container (the bucket in s3)
try {
AsyncBlobStore blobStore = context.getAsyncBlobStore(); // it can be changed to sync
// BlobStore (returns false if it already exists)
ListenableFuture<Boolean> container = blobStore.createContainerInLocation(null, bucketName);
if (container.get()) {
LOG.info("Created bucket " + bucketName);
}
} catch (Exception ex) {
logger.error("Could not start binary service: {}", ex.getMessage());
throw new RuntimeException(ex);
}
try {
File file = new File(fileName);
AsyncBlobStore blobStore = context.getAsyncBlobStore();
BlobBuilder blobBuilder =
blobStore
.blobBuilder(file.getName())
.payload(file)
.calculateMD5()
.contentType("text/plain")
.contentLength(file.length());
Blob blob = blobBuilder.build();
ListenableFuture<String> futureETag =
blobStore.putBlob(bucketName, blob, PutOptions.Builder.multipart());
LOG.info("Uploaded file etag=" + futureETag.get());
} catch (Exception e) {
LOG.error("Error uploading to blob store", e);
}
}
@Test
public void testMasterAwareExecution() throws Exception {
Settings settings = settingsBuilder().put("discovery.type", "local").build();
ListenableFuture<String> master = internalCluster().startNodeAsync(settings);
ListenableFuture<String> nonMaster =
internalCluster()
.startNodeAsync(settingsBuilder().put(settings).put("node.master", false).build());
master.get();
ensureGreen(); // make sure we have a cluster
ClusterService clusterService =
internalCluster().getInstance(ClusterService.class, nonMaster.get());
final boolean[] taskFailed = {false};
final CountDownLatch latch1 = new CountDownLatch(1);
clusterService.submitStateUpdateTask(
"test",
new ClusterStateUpdateTask() {
@Override
public ClusterState execute(ClusterState currentState) throws Exception {
latch1.countDown();
return currentState;
}
@Override
public void onFailure(String source, Throwable t) {
taskFailed[0] = true;
latch1.countDown();
}
});
latch1.await();
assertTrue("cluster state update task was executed on a non-master", taskFailed[0]);
taskFailed[0] = true;
final CountDownLatch latch2 = new CountDownLatch(1);
clusterService.submitStateUpdateTask(
"test",
new ClusterStateNonMasterUpdateTask() {
@Override
public ClusterState execute(ClusterState currentState) throws Exception {
taskFailed[0] = false;
latch2.countDown();
return currentState;
}
@Override
public void onFailure(String source, Throwable t) {
taskFailed[0] = true;
latch2.countDown();
}
});
latch2.await();
assertFalse("non-master cluster state update task was not executed", taskFailed[0]);
}
public void checkAsyncCallReturnValues() throws ExecutionException, InterruptedException {
// All these async calls include a delay, so none she be finished at first
assertFalse(getBeforeFuture.isDone());
assertFalse(getAfterFuture.isDone());
assertFalse(putFuture.isDone());
// Calls are timed to complete in order, but Verify that we can still wait on the
// futures out of order
assertEquals(getBeforeFuture.get(), "default");
assertEquals(getAfterFuture.get(), "testValue");
putFuture.get();
}
@Test
public void testAsyncOutOfOrder() throws Exception {
ListenableFuture<String> getFuture;
ListenableFuture<Void> putFuture;
try (DelayedMap.AsyncClient client =
createClient(DelayedMap.AsyncClient.class, syncServer).get()) {
getFuture = client.getValueSlowly(500, TimeUnit.MILLISECONDS, "testKey");
putFuture = client.putValueSlowly(250, TimeUnit.MILLISECONDS, "testKey", "testValue");
assertEquals(getFuture.get(1, TimeUnit.SECONDS), "testValue");
putFuture.get(1, TimeUnit.SECONDS);
}
}
private static void send(PaymentSession session) {
try {
System.out.println("Payment Request");
System.out.println("Amount: " + session.getValue().doubleValue() / 100000 + "mDOGE");
System.out.println("Date: " + session.getDate());
System.out.println("Memo: " + session.getMemo());
if (session.pkiVerificationData != null) {
System.out.println("Pki-Verified Name: " + session.pkiVerificationData.name);
if (session.pkiVerificationData.orgName != null)
System.out.println("Pki-Verified Org: " + session.pkiVerificationData.orgName);
System.out.println(
"PKI data verified by: " + session.pkiVerificationData.rootAuthorityName);
}
final Wallet.SendRequest req = session.getSendRequest();
if (password != null) {
if (!wallet.checkPassword(password)) {
System.err.println("Password is incorrect.");
return;
}
req.aesKey = wallet.getKeyCrypter().deriveKey(password);
}
wallet.completeTx(req); // may throw InsufficientMoneyException.
if (options.has("offline")) {
wallet.commitTx(req.tx);
return;
}
setup();
// No refund address specified, no user-specified memo field.
ListenableFuture<PaymentSession.Ack> future =
session.sendPayment(ImmutableList.of(req.tx), null, null);
if (future == null) {
// No payment_url for submission so, broadcast and wait.
peers.startAndWait();
peers.broadcastTransaction(req.tx).get();
} else {
PaymentSession.Ack ack = future.get();
wallet.commitTx(req.tx);
System.out.println("Memo from server: " + ack.getMemo());
}
} catch (PaymentRequestException e) {
System.err.println("Failed to send payment " + e.getMessage());
System.exit(1);
} catch (VerificationException e) {
System.err.println("Failed to send payment " + e.getMessage());
System.exit(1);
} catch (ExecutionException e) {
System.err.println("Failed to send payment " + e.getMessage());
System.exit(1);
} catch (IOException e) {
System.err.println("Invalid payment " + e.getMessage());
System.exit(1);
} catch (InterruptedException e1) {
// Ignore.
} catch (InsufficientMoneyException e) {
System.err.println(
"Insufficient funds: have " + Utils.bitcoinValueToFriendlyString(wallet.getBalance()));
} catch (BlockStoreException e) {
throw new RuntimeException(e);
}
}
@Test
public void testBufferNotCloseOnFail() throws Exception {
SqlTask sqlTask = createInitialTask();
updateTask(
sqlTask,
EMPTY_SOURCES,
INITIAL_EMPTY_OUTPUT_BUFFERS.withBuffer("out", new UnpartitionedPagePartitionFunction()));
ListenableFuture<BufferResult> bufferResult =
sqlTask.getTaskResults("out", 0, new DataSize(1, MEGABYTE));
assertFalse(bufferResult.isDone());
TaskState taskState = sqlTask.getTaskInfo().getState();
sqlTask.failed(new Exception("test"));
assertEquals(
sqlTask.getTaskInfo(taskState).get(200, MILLISECONDS).getState(), TaskState.FAILED);
// buffer will not be closed by fail event. event is async so wait a bit for event to fire
try {
assertTrue(bufferResult.get(200, MILLISECONDS).isBufferClosed());
fail("expected TimeoutException");
} catch (TimeoutException expected) {
}
assertFalse(sqlTask.getTaskResults("out", 0, new DataSize(1, MEGABYTE)).isDone());
}
private static void sendPaymentRequest(String location, boolean verifyPki) {
if (location.startsWith("http") || location.startsWith("defcoin")) {
try {
ListenableFuture<PaymentSession> future;
if (location.startsWith("http")) {
future = PaymentSession.createFromUrl(location, verifyPki);
} else {
BitcoinURI paymentRequestURI = new BitcoinURI(location);
future = PaymentSession.createFromBitcoinUri(paymentRequestURI, verifyPki);
}
PaymentSession session = future.get();
if (session != null) {
send(session);
} else {
System.err.println("Server returned null session");
System.exit(1);
}
} catch (PaymentRequestException e) {
System.err.println("Error creating payment session " + e.getMessage());
System.exit(1);
} catch (BitcoinURIParseException e) {
System.err.println("Invalid defcoin uri: " + e.getMessage());
System.exit(1);
} catch (InterruptedException e) {
// Ignore.
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
} else {
// Try to open the payment request as a file.
FileInputStream stream = null;
try {
File paymentRequestFile = new File(location);
stream = new FileInputStream(paymentRequestFile);
} catch (Exception e) {
System.err.println("Failed to open file: " + e.getMessage());
System.exit(1);
}
try {
paymentRequest =
org.bitcoin.protocols.payments.Protos.PaymentRequest.newBuilder()
.mergeFrom(stream)
.build();
} catch (IOException e) {
System.err.println("Failed to parse payment request from file " + e.getMessage());
System.exit(1);
}
PaymentSession session = null;
try {
session = new PaymentSession(paymentRequest, verifyPki);
} catch (PaymentRequestException e) {
System.err.println("Error creating payment session " + e.getMessage());
System.exit(1);
}
send(session);
}
}
@Nullable
@Override
public BuildResult getBuildRuleResult(BuildTarget buildTarget)
throws ExecutionException, InterruptedException {
ListenableFuture<BuildResult> result = results.get(buildTarget);
if (result == null) {
return null;
}
return result.get();
}
@Override
public ListenableFuture<ServiceFilterResponse> handleRequest(
final ServiceFilterRequest request,
final NextServiceFilterCallback nextServiceFilterCallback) {
// In this example, if authentication is already in progress we block the request
// until authentication is complete to avoid unnecessary authentications as
// a result of HTTP status code 401.
// If authentication was detected, add the token to the request.
waitAndUpdateRequestToken(request);
// Send the request down the filter chain
// retrying up to 5 times on 401 response codes.
ListenableFuture<ServiceFilterResponse> future = null;
ServiceFilterResponse response = null;
int responseCode = 401;
for (int i = 0; (i < 5) && (responseCode == 401); i++) {
future = nextServiceFilterCallback.onNext(request);
try {
response = future.get();
responseCode = response.getStatus().getStatusCode();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
if (e.getCause().getClass() == MobileServiceException.class) {
MobileServiceException mEx = (MobileServiceException) e.getCause();
responseCode = mEx.getResponse().getStatus().getStatusCode();
if (responseCode == 401) {
// Two simultaneous requests from independent threads could get HTTP status 401.
// Protecting against that right here so multiple authentication requests are
// not setup to run on the UI thread.
// We only want to authenticate once. Requests should just wait and retry
// with the new token.
if (mAtomicAuthenticatingFlag.compareAndSet(false, true)) {
// Authenticate on UI thread
runOnUiThread(
new Runnable() {
@Override
public void run() {
// Force a token refresh during authentication.
authenticate(true);
}
});
}
// Wait for authentication to complete then update the token in the request.
waitAndUpdateRequestToken(request);
mAtomicAuthenticatingFlag.set(false);
}
}
}
}
return future;
}
@Override
public JsonObject visit(UpdateOperation operation) throws Throwable {
MobileServiceJsonTable table = this.getRemoteTable(operation.getTableName());
table.setSystemProperties(getSystemProperties(this.mItem));
ListenableFuture<JsonObject> future = table.update(this.mItem);
try {
return future.get();
} catch (ExecutionException ex) {
throw ex.getCause();
}
}
// TODO use NeedModelBuilder here instead
@RequestMapping(value = "/create", method = RequestMethod.POST)
public String createNeedPost(@ModelAttribute("SpringWeb") NeedPojo needPojo, Model model)
throws Exception {
URI needURI;
try {
URI ownerURI = this.uriService.getOwnerProtocolOwnerServiceEndpointURI();
NeedPojoNeedModelBuilder needPojoNeedModelBuilder = new NeedPojoNeedModelBuilder(needPojo);
needPojoNeedModelBuilder.setUri("no:uri");
com.hp.hpl.jena.rdf.model.Model needModel = needPojoNeedModelBuilder.build();
needModel.setNsPrefix("", "no:uri");
if (needPojo.getWonNode().equals("")) {
ListenableFuture<URI> futureResult =
ownerService.createNeed(needModel, needPojo.getState() == NeedState.ACTIVE, null);
needURI = futureResult.get();
} else {
ListenableFuture<URI> futureResult =
ownerService.createNeed(
needModel,
needPojo.getState() == NeedState.ACTIVE,
URI.create(needPojo.getWonNode()),
null);
needURI = futureResult.get();
}
List<Need> needs = needRepository.findByNeedURI(needURI);
// TODO: race condition between need saving logic and redirect. adapt interface.
if (needs.size() == 1) return "redirect:/need/" + needs.get(0).getId().toString();
// return viewNeed(need.getId().toString(), model);
} catch (IllegalNeedContentException e) {
logger.warn("caught IllegalNeedContentException:", e);
}
model.addAttribute("command", new NeedPojo());
return "createNeed";
}
public void shutdown(int exitStatusCode) {
try {
if (_systemConfig != null) {
ListenableFuture<Void> closeResult = _systemConfig.closeAsync();
closeResult.get(30000l, TimeUnit.MILLISECONDS);
}
} catch (TimeoutException | InterruptedException | ExecutionException e) {
LOGGER.warn("Attempting to cleanly shutdown took too long, exiting immediately");
} finally {
cleanUp(exitStatusCode);
}
}
@Override
public JsonObject visit(InsertOperation operation) throws Throwable {
MobileServiceJsonTable table = this.getRemoteTable(operation.getTableName());
table.setSystemProperties(EnumSet.allOf(MobileServiceSystemProperty.class));
JsonObject item = removeSystemProperties(this.mItem);
ListenableFuture<JsonObject> future = table.insert(item);
try {
return future.get();
} catch (ExecutionException ex) {
throw ex.getCause();
}
}
@Test
public void testBufferCloseOnCancel() throws Exception {
SqlTask sqlTask = createInitialTask();
updateTask(
sqlTask,
EMPTY_SOURCES,
INITIAL_EMPTY_OUTPUT_BUFFERS.withBuffer("out", new UnpartitionedPagePartitionFunction()));
ListenableFuture<BufferResult> bufferResult =
sqlTask.getTaskResults("out", 0, new DataSize(1, MEGABYTE));
assertFalse(bufferResult.isDone());
sqlTask.cancel();
assertEquals(sqlTask.getTaskInfo().getState(), TaskState.CANCELED);
// buffer will be closed by cancel event.. the event is async so wait a bit for event to
// propagate
assertTrue(bufferResult.get(200, MILLISECONDS).isBufferClosed());
bufferResult = sqlTask.getTaskResults("out", 0, new DataSize(1, MEGABYTE));
assertTrue(bufferResult.isDone());
assertTrue(bufferResult.get().isBufferClosed());
}
// Call a method that will sleep for longer than the channel timeout, and expect a
// TimeoutException (wrapped in a TTransportException)
@Test
public void testAsyncTimeout() throws Exception {
try (DelayedMap.AsyncClient client =
createClient(DelayedMap.AsyncClient.class, syncServer).get()) {
ListenableFuture<String> getFuture =
client.getValueSlowly(1500, TimeUnit.MILLISECONDS, "testKey");
try {
getFuture.get(2000, TimeUnit.MILLISECONDS);
fail("Call did not timeout as expected");
} catch (java.util.concurrent.TimeoutException e) {
fail("Waited too long for channel timeout");
} catch (ExecutionException e) {
checkTransportException(e.getCause(), ReadTimeoutException.class);
}
}
}
private ClientResponse extractWebSocketUriFromRpc(final String methodName)
throws ExecutionException, InterruptedException, UnsupportedEncodingException {
ListenableFuture<ClientResponse> clientFuture =
restconfClient.get(
ResourceUri.STREAM.getPath() + "/" + encodeUri(this.streamInfo.getIdentifier()),
MediaType.APPLICATION_XML,
new Function<ClientResponse, ClientResponse>() {
@Override
public ClientResponse apply(final ClientResponse clientResponse) {
return clientResponse;
}
});
return clientFuture.get();
}
@Test
public void requestQueuedBuilds_callback_registers_exception_on_ack_future() throws Exception {
// Setup
when(_mockRequestController.sendRequest(getApiVersion(), "buildQueue", QueuedBuildList.class))
.thenReturn(
Futures.immediateFailedFuture(new RuntimeException("Unexpected test exception")));
// Exercise
final ListenableFuture<Void> ackFuture = _apiController.requestQueuedBuilds();
// Verify
try {
ackFuture.get();
} catch (ExecutionException e) {
if (e.getCause().getClass() == RuntimeException.class
&& e.getCause().getMessage().equals("Unexpected test exception")) return;
}
TestCase.fail();
}
@Override
public JsonObject visit(DeleteOperation operation) throws Throwable {
MobileServiceJsonTable table = this.getRemoteTable(operation.getTableName());
ListenableFuture<Void> future = table.delete(this.mItem);
try {
future.get();
return null;
} catch (ExecutionException ex) {
if (!ExceptionIs404NotFound(ex)) {
throw ex.getCause();
}
return null;
}
}
private void checkItemDoesNotExists(
final DOMDataReadWriteTransaction rWTransaction,
final LogicalDatastoreType store,
final YangInstanceIdentifier path) {
final ListenableFuture<Boolean> futureDatastoreData = rWTransaction.exists(store, path);
try {
if (futureDatastoreData.get()) {
final String errMsg =
"Post Configuration via Restconf was not executed because data already exists";
LOG.trace("{}:{}", errMsg, path);
rWTransaction.cancel();
throw new RestconfDocumentedException(
"Data already exists for path: " + path, ErrorType.PROTOCOL, ErrorTag.DATA_EXISTS);
}
} catch (InterruptedException | ExecutionException e) {
LOG.warn("It wasn't possible to get data loaded from datastore at path {}", path, e);
}
}
@Test
public void testEmptyPath() throws Exception {
ImmutableMap<String, List<FileStatus>> paths =
ImmutableMap.<String, List<FileStatus>>builder()
.put("/", ImmutableList.<FileStatus>of())
.build();
AsyncRecursiveWalker walker =
new AsyncRecursiveWalker(createMockFileSystem(paths), MoreExecutors.sameThreadExecutor());
MockFileStatusCallback callback = new MockFileStatusCallback();
ListenableFuture<Void> listenableFuture = walker.beginWalk(new Path("/"), callback);
Assert.assertTrue(listenableFuture.isDone());
Assert.assertTrue(callback.getProcessedFiles().isEmpty());
// Should not have an exception
listenableFuture.get();
}
@Test
public void testHiddenFiles() throws Exception {
ImmutableMap<String, List<FileStatus>> paths =
ImmutableMap.<String, List<FileStatus>>builder()
.put(
"/",
ImmutableList.of(
fileStatus("/.a", true),
fileStatus("/_b", true),
fileStatus("/c", true),
fileStatus("/file1", false),
fileStatus("/_file2", false),
fileStatus("/.file3", false)))
.put(
"/.a",
ImmutableList.of(fileStatus("/.a/file4", false), fileStatus("/.a/file5", false)))
.put(
"/_b",
ImmutableList.of(fileStatus("/_b/file6", false), fileStatus("/_b/file7", false)))
.put(
"/c",
ImmutableList.of(
fileStatus("/c/file8", false),
fileStatus("/c/.file9", false),
fileStatus("/c/_file10", false)))
.build();
AsyncRecursiveWalker walker =
new AsyncRecursiveWalker(createMockFileSystem(paths), MoreExecutors.sameThreadExecutor());
MockFileStatusCallback callback = new MockFileStatusCallback();
ListenableFuture<Void> listenableFuture = walker.beginWalk(new Path("/"), callback);
Assert.assertTrue(listenableFuture.isDone());
Assert.assertEquals(
ImmutableSet.copyOf(callback.getProcessedFiles()), ImmutableSet.of("/file1", "/c/file8"));
// Should not have an exception
listenableFuture.get();
}
private List<Bucket> getBuckets(CollectPhase collectNode)
throws InterruptedException, java.util.concurrent.ExecutionException {
List<Bucket> results = new ArrayList<>();
for (String nodeName : internalCluster().getNodeNames()) {
ContextPreparer contextPreparer =
internalCluster().getInstance(ContextPreparer.class, nodeName);
JobContextService contextService =
internalCluster().getInstance(JobContextService.class, nodeName);
JobExecutionContext.Builder builder = contextService.newBuilder(collectNode.jobId());
ListenableFuture<Bucket> future =
contextPreparer.prepare(
collectNode.jobId(),
NodeOperation.withDownstream(collectNode, mock(ExecutionPhase.class)),
builder);
assert future != null;
JobExecutionContext context = contextService.createContext(builder);
context.start();
results.add(future.get());
}
return results;
}
@Test
public void requestLastBuildStatus_callback_registers_exception_on_ack_future() throws Exception {
// Setup
final BuildTypeData bt1 = new BuildTypeData("bt1", "btName", "pname", "pId");
when(_mockRequestController.sendRequest(
getApiVersion(),
"builds/?locator=buildType:bt1,running:any,branch:(default:any),count:"
+ ApiController.MAX_BUILDS_TO_CONSIDER,
BuildList.class))
.thenReturn(
Futures.immediateFailedFuture(new RuntimeException("Unexpected test exception")));
// Exercise
final ListenableFuture<Void> ackFuture = _apiController.requestLastBuildStatus(bt1);
// Verify
try {
ackFuture.get();
} catch (ExecutionException e) {
if (e.getCause().getClass() == RuntimeException.class
&& e.getCause().getMessage().equals("Unexpected test exception")) return;
}
TestCase.fail();
}
private void createAndRegisterAckMailboxes(
final Set<Integer> localPartitions, HostMessenger messenger) {
m_zk = messenger.getZK();
m_mailboxesZKPath = VoltZK.exportGenerations + "/" + m_timestamp + "/" + "mailboxes";
m_mbox =
new LocalMailbox(messenger) {
@Override
public void deliver(VoltMessage message) {
if (message instanceof BinaryPayloadMessage) {
BinaryPayloadMessage bpm = (BinaryPayloadMessage) message;
ByteBuffer buf = ByteBuffer.wrap(bpm.m_payload);
final int partition = buf.getInt();
final int length = buf.getInt();
byte stringBytes[] = new byte[length];
buf.get(stringBytes);
String signature = new String(stringBytes, Constants.UTF8ENCODING);
final long ackUSO = buf.getLong();
final HashMap<String, ExportDataSource> partitionSources =
m_dataSourcesByPartition.get(partition);
if (partitionSources == null) {
exportLog.error(
"Received an export ack for partition "
+ partition
+ " which does not exist on this node");
return;
}
final ExportDataSource eds = partitionSources.get(signature);
if (eds == null) {
exportLog.error(
"Received an export ack for partition "
+ partition
+ " source signature "
+ signature
+ " which does not exist on this node");
return;
}
try {
eds.ack(ackUSO);
} catch (RejectedExecutionException ignoreIt) {
// ignore it: as it is already shutdown
}
} else {
exportLog.error("Receive unexpected message " + message + " in export subsystem");
}
}
};
messenger.createMailbox(null, m_mbox);
for (Integer partition : localPartitions) {
final String partitionDN = m_mailboxesZKPath + "/" + partition;
ZKUtil.asyncMkdirs(m_zk, partitionDN);
ZKUtil.StringCallback cb = new ZKUtil.StringCallback();
m_zk.create(
partitionDN + "/" + m_mbox.getHSId(),
null,
Ids.OPEN_ACL_UNSAFE,
CreateMode.EPHEMERAL,
cb,
null);
}
ListenableFuture<?> fut =
m_childUpdatingThread.submit(
new Runnable() {
@Override
public void run() {
List<Pair<Integer, ZKUtil.ChildrenCallback>> callbacks =
new ArrayList<Pair<Integer, ZKUtil.ChildrenCallback>>();
for (Integer partition : localPartitions) {
ZKUtil.ChildrenCallback callback = new ZKUtil.ChildrenCallback();
m_zk.getChildren(
m_mailboxesZKPath + "/" + partition,
constructMailboxChildWatcher(),
callback,
null);
callbacks.add(Pair.of(partition, callback));
}
for (Pair<Integer, ZKUtil.ChildrenCallback> p : callbacks) {
final Integer partition = p.getFirst();
List<String> children = null;
try {
children = p.getSecond().getChildren();
} catch (InterruptedException e) {
Throwables.propagate(e);
} catch (KeeperException e) {
Throwables.propagate(e);
}
ImmutableList.Builder<Long> mailboxes = ImmutableList.builder();
for (String child : children) {
if (child.equals(Long.toString(m_mbox.getHSId()))) continue;
mailboxes.add(Long.valueOf(child));
}
ImmutableList<Long> mailboxHsids = mailboxes.build();
for (ExportDataSource eds : m_dataSourcesByPartition.get(partition).values()) {
eds.updateAckMailboxes(Pair.of(m_mbox, mailboxHsids));
}
}
}
});
try {
fut.get();
} catch (Throwable t) {
Throwables.propagate(t);
}
}
// since surefire and eclipse don't otherwise guarantee the order, we are
// starting this one alphabetically before create2nodes..
@Test(
enabled = true,
dependsOnMethods = {"testCompareSizes"})
public void testAScriptExecutionAfterBootWithBasicTemplate() throws Exception {
String group = this.group + "r";
try {
client.destroyNodesMatching(inGroup(group));
} catch (Exception e) {
}
template = buildTemplate(client.templateBuilder());
template.getOptions().blockOnPort(22, 120);
try {
Set<? extends NodeMetadata> nodes = client.createNodesInGroup(group, 1, template);
NodeMetadata node = get(nodes, 0);
LoginCredentials good = node.getCredentials();
assert good.identity != null : nodes;
for (Entry<? extends NodeMetadata, ExecResponse> response :
client
.runScriptOnNodesMatching(
runningInGroup(group),
"hostname",
wrapInInitScript(false).runAsRoot(false).overrideLoginCredentials(good))
.entrySet()) {
checkResponseEqualsHostname(response.getValue(), response.getKey());
}
// test single-node execution
ExecResponse response =
client.runScriptOnNode(
node.getId(), "hostname", wrapInInitScript(false).runAsRoot(false));
checkResponseEqualsHostname(response, node);
OperatingSystem os = node.getOperatingSystem();
// test bad password
tryBadPassword(group, good);
runScriptWithCreds(group, os, good);
checkNodes(nodes, group, "runScriptWithCreds");
// test adding AdminAccess later changes the default boot user, in this
// case to foo, with home dir /over/ridden/foo
ListenableFuture<ExecResponse> future =
client.submitScriptOnNode(
node.getId(),
AdminAccess.builder().adminUsername("foo").adminHome("/over/ridden/foo").build(),
nameTask("adminUpdate"));
response = future.get(3, TimeUnit.MINUTES);
assert response.getExitStatus() == 0 : node.getId() + ": " + response;
node = client.getNodeMetadata(node.getId());
// test that the node updated to the correct admin user!
assertEquals(node.getCredentials().identity, "foo");
assert node.getCredentials().credential != null : nodes;
weCanCancelTasks(node);
assert response.getExitStatus() == 0 : node.getId() + ": " + response;
response =
client.runScriptOnNode(
node.getId(), "echo $USER", wrapInInitScript(false).runAsRoot(false));
assert response.getOutput().trim().equals("foo") : node.getId() + ": " + response;
} finally {
client.destroyNodesMatching(inGroup(group));
}
}
private void eq(int i, ListenableFuture<IntegerReply> zadd)
throws ExecutionException, InterruptedException {
eq(i, zadd.get());
}
@SuppressWarnings("PMD.EmptyCatchBlock")
public static int runTests(
final CommandRunnerParams params,
Iterable<TestRule> tests,
BuildContext buildContext,
ExecutionContext executionContext,
final TestRunningOptions options,
ListeningExecutorService service,
BuildEngine buildEngine,
final StepRunner stepRunner)
throws IOException, ExecutionException, InterruptedException {
if (options.isUsingOneTimeOutputDirectories()) {
BuckConstant.setOneTimeTestSubdirectory(UUID.randomUUID().toString());
}
ImmutableSet<JavaLibrary> rulesUnderTest;
// If needed, we first run instrumentation on the class files.
if (options.isCodeCoverageEnabled()) {
rulesUnderTest = getRulesUnderTest(tests);
if (!rulesUnderTest.isEmpty()) {
try {
stepRunner.runStepForBuildTarget(
new MakeCleanDirectoryStep(JUnitStep.JACOCO_OUTPUT_DIR),
Optional.<BuildTarget>absent());
} catch (StepFailedException e) {
params.getConsole().printBuildFailureWithoutStacktrace(e);
return 1;
}
}
} else {
rulesUnderTest = ImmutableSet.of();
}
final ImmutableSet<String> testTargets =
FluentIterable.from(tests)
.transform(HasBuildTarget.TO_TARGET)
.transform(Functions.toStringFunction())
.toSet();
final int totalNumberOfTests = Iterables.size(tests);
params
.getBuckEventBus()
.post(
TestRunEvent.started(
options.isRunAllTests(),
options.getTestSelectorList(),
options.shouldExplainTestSelectorList(),
testTargets));
// Start running all of the tests. The result of each java_test() rule is represented as a
// ListenableFuture.
List<ListenableFuture<TestResults>> results = Lists.newArrayList();
// Unless `--verbose 0` is specified, print out test results as they become available.
// Failures with the ListenableFuture should always be printed, as they indicate an error with
// Buck, not the test being run.
Verbosity verbosity = params.getConsole().getVerbosity();
final boolean printTestResults = (verbosity != Verbosity.SILENT);
// For grouping results!
final TestResultsGrouper grouper;
if (options.isIgnoreFailingDependencies()) {
grouper = new TestResultsGrouper(tests);
} else {
grouper = null;
}
TestRuleKeyFileHelper testRuleKeyFileHelper =
new TestRuleKeyFileHelper(executionContext.getProjectFilesystem(), buildEngine);
final AtomicInteger lastReportedTestSequenceNumber = new AtomicInteger();
final List<TestRun> separateTestRuns = Lists.newArrayList();
List<TestRun> parallelTestRuns = Lists.newArrayList();
for (final TestRule test : tests) {
// Determine whether the test needs to be executed.
boolean isTestRunRequired;
isTestRunRequired =
isTestRunRequiredForTest(
test,
buildEngine,
executionContext,
testRuleKeyFileHelper,
options.isResultsCacheEnabled(),
!options.getTestSelectorList().isEmpty());
List<Step> steps;
if (isTestRunRequired) {
params.getBuckEventBus().post(IndividualTestEvent.started(testTargets));
ImmutableList.Builder<Step> stepsBuilder = ImmutableList.builder();
Preconditions.checkState(buildEngine.isRuleBuilt(test.getBuildTarget()));
final Map<String, UUID> testUUIDMap = new HashMap<>();
List<Step> testSteps =
test.runTests(
buildContext,
executionContext,
options.isDryRun(),
options.isShufflingTests(),
options.getTestSelectorList(),
new TestRule.TestReportingCallback() {
@Override
public void testsDidBegin() {
LOG.debug("Tests for rule %s began", test.getBuildTarget());
}
@Override
public void testDidBegin(String testCaseName, String testName) {
LOG.debug(
"Test rule %s test case %s test name %s began",
test.getBuildTarget(), testCaseName, testName);
UUID testUUID = UUID.randomUUID();
// UUID is immutable and thread-safe as of Java 7, so it's
// safe to stash in a map and use later:
//
// http://bugs.java.com/view_bug.do?bug_id=6611830
testUUIDMap.put(testCaseName + ":" + testName, testUUID);
params
.getBuckEventBus()
.post(TestSummaryEvent.started(testUUID, testCaseName, testName));
}
@Override
public void testDidEnd(TestResultSummary testResultSummary) {
LOG.debug(
"Test rule %s test did end: %s", test.getBuildTarget(), testResultSummary);
UUID testUUID =
testUUIDMap.get(
testResultSummary.getTestCaseName()
+ ":"
+ testResultSummary.getTestName());
Preconditions.checkNotNull(testUUID);
params
.getBuckEventBus()
.post(TestSummaryEvent.finished(testUUID, testResultSummary));
}
@Override
public void testsDidEnd(List<TestCaseSummary> testCaseSummaries) {
LOG.debug(
"Test rule %s tests did end: %s", test.getBuildTarget(), testCaseSummaries);
}
});
if (!testSteps.isEmpty()) {
stepsBuilder.addAll(testSteps);
stepsBuilder.add(testRuleKeyFileHelper.createRuleKeyInDirStep(test));
}
steps = stepsBuilder.build();
} else {
steps = ImmutableList.of();
}
TestRun testRun =
TestRun.of(
test,
steps,
getCachingStatusTransformingCallable(
isTestRunRequired,
test.interpretTestResults(
executionContext,
/*isUsingTestSelectors*/ !options.getTestSelectorList().isEmpty(),
/*isDryRun*/ options.isDryRun())));
// Always run the commands, even if the list of commands as empty. There may be zero
// commands because the rule is cached, but its results must still be processed.
if (test.runTestSeparately()) {
LOG.debug("Running test %s in serial", test);
separateTestRuns.add(testRun);
} else {
LOG.debug("Running test %s in parallel", test);
parallelTestRuns.add(testRun);
}
}
final StepRunner.StepRunningCallback testStepRunningCallback =
new StepRunner.StepRunningCallback() {
@Override
public void stepsWillRun(Optional<BuildTarget> buildTarget) {
Preconditions.checkState(buildTarget.isPresent());
LOG.debug("Test steps will run for %s", buildTarget);
params.getBuckEventBus().post(TestRuleEvent.started(buildTarget.get()));
}
@Override
public void stepsDidRun(Optional<BuildTarget> buildTarget) {
Preconditions.checkState(buildTarget.isPresent());
LOG.debug("Test steps did run for %s", buildTarget);
params.getBuckEventBus().post(TestRuleEvent.finished(buildTarget.get()));
}
};
for (TestRun testRun : parallelTestRuns) {
ListenableFuture<TestResults> testResults =
stepRunner.runStepsAndYieldResult(
testRun.getSteps(),
testRun.getTestResultsCallable(),
Optional.of(testRun.getTest().getBuildTarget()),
service,
testStepRunningCallback);
results.add(
transformTestResults(
params,
testResults,
grouper,
testRun.getTest(),
testTargets,
printTestResults,
lastReportedTestSequenceNumber,
totalNumberOfTests));
}
ListenableFuture<List<TestResults>> parallelTestStepsFuture = Futures.allAsList(results);
final List<TestResults> completedResults = Lists.newArrayList();
final ListeningExecutorService directExecutorService = MoreExecutors.newDirectExecutorService();
ListenableFuture<Void> uberFuture =
stepRunner.addCallback(
parallelTestStepsFuture,
new FutureCallback<List<TestResults>>() {
@Override
public void onSuccess(List<TestResults> parallelTestResults) {
LOG.debug("Parallel tests completed, running separate tests...");
completedResults.addAll(parallelTestResults);
List<ListenableFuture<TestResults>> separateResultsList = Lists.newArrayList();
for (TestRun testRun : separateTestRuns) {
separateResultsList.add(
transformTestResults(
params,
stepRunner.runStepsAndYieldResult(
testRun.getSteps(),
testRun.getTestResultsCallable(),
Optional.of(testRun.getTest().getBuildTarget()),
directExecutorService,
testStepRunningCallback),
grouper,
testRun.getTest(),
testTargets,
printTestResults,
lastReportedTestSequenceNumber,
totalNumberOfTests));
}
ListenableFuture<List<TestResults>> serialResults =
Futures.allAsList(separateResultsList);
try {
completedResults.addAll(serialResults.get());
} catch (ExecutionException e) {
LOG.error(e, "Error fetching serial test results");
throw new HumanReadableException(e, "Error fetching serial test results");
} catch (InterruptedException e) {
LOG.error(e, "Interrupted fetching serial test results");
try {
serialResults.cancel(true);
} catch (CancellationException ignored) {
// Rethrow original InterruptedException instead.
}
Thread.currentThread().interrupt();
throw new HumanReadableException(e, "Test cancelled");
}
LOG.debug("Done running serial tests.");
}
@Override
public void onFailure(Throwable e) {
LOG.error(e, "Parallel tests failed, not running serial tests");
throw new HumanReadableException(e, "Parallel tests failed");
}
},
directExecutorService);
try {
// Block until all the tests have finished running.
uberFuture.get();
} catch (ExecutionException e) {
e.printStackTrace(params.getConsole().getStdErr());
return 1;
} catch (InterruptedException e) {
try {
uberFuture.cancel(true);
} catch (CancellationException ignored) {
// Rethrow original InterruptedException instead.
}
Thread.currentThread().interrupt();
throw e;
}
params.getBuckEventBus().post(TestRunEvent.finished(testTargets, completedResults));
// Write out the results as XML, if requested.
Optional<String> path = options.getPathToXmlTestOutput();
if (path.isPresent()) {
try (Writer writer = Files.newWriter(new File(path.get()), Charsets.UTF_8)) {
writeXmlOutput(completedResults, writer);
}
}
// Generate the code coverage report.
if (options.isCodeCoverageEnabled() && !rulesUnderTest.isEmpty()) {
try {
Optional<DefaultJavaPackageFinder> defaultJavaPackageFinderOptional =
Optional.fromNullable(params.getBuckConfig().createDefaultJavaPackageFinder());
stepRunner.runStepForBuildTarget(
getReportCommand(
rulesUnderTest,
defaultJavaPackageFinderOptional,
params.getRepository().getFilesystem(),
JUnitStep.JACOCO_OUTPUT_DIR,
options.getCoverageReportFormat()),
Optional.<BuildTarget>absent());
} catch (StepFailedException e) {
params.getConsole().printBuildFailureWithoutStacktrace(e);
return 1;
}
}
boolean failures =
Iterables.any(
completedResults,
new Predicate<TestResults>() {
@Override
public boolean apply(TestResults results) {
LOG.debug("Checking result %s for failure", results);
return !results.isSuccess();
}
});
return failures ? TEST_FAILURES_EXIT_CODE : 0;
}