/** intValue returns current value. */
public void testIntValue() {
AtomicInteger ai = new AtomicInteger();
assertEquals(0, ai.intValue());
for (int x : VALUES) {
ai.set(x);
assertEquals(x, ai.intValue());
}
}
public void testWatchChildren() throws Exception {
try (ZkConnection conn = new ZkConnection()) {
final SolrZkClient zkClient = conn.getClient();
final AtomicInteger cnt = new AtomicInteger();
final CountDownLatch latch = new CountDownLatch(1);
zkClient.makePath("/collections", true);
zkClient.getChildren(
"/collections",
new Watcher() {
@Override
public void process(WatchedEvent event) {
if (DEBUG) {
System.out.println("children changed");
}
cnt.incrementAndGet();
// remake watch
try {
zkClient.getChildren("/collections", this, true);
latch.countDown();
} catch (KeeperException | InterruptedException e) {
throw new RuntimeException(e);
}
}
},
true);
zkClient.makePath("/collections/collection99/shards", true);
latch.await(); // wait until watch has been re-created
zkClient.makePath("collections/collection99/config=collection1", true);
zkClient.makePath("collections/collection99/config=collection3", true);
zkClient.makePath("/collections/collection97/shards", true);
if (DEBUG) {
zkClient.printLayoutToStdOut();
}
// pause for the watches to fire
Thread.sleep(700);
if (cnt.intValue() < 2) {
Thread.sleep(4000); // wait a bit more
}
if (cnt.intValue() < 2) {
Thread.sleep(4000); // wait a bit more
}
assertEquals(2, cnt.intValue());
}
}
@Test
public void shouldFailUntilImportExecutes() throws Exception {
final GremlinExecutor gremlinExecutor = GremlinExecutor.build().create();
final Set<String> imports =
new HashSet<String>() {
{
add("import java.awt.Color");
}
};
final AtomicInteger successes = new AtomicInteger(0);
final AtomicInteger failures = new AtomicInteger(0);
// issue 1000 scripts in one thread using a class that isn't imported. this will result in
// failure.
// while that thread is running start a new thread that issues an addImports to include that
// class.
// this should block further evals in the first thread until the import is complete at which
// point
// evals in the first thread will resume and start to succeed
final Thread t1 =
new Thread(
() ->
IntStream.range(0, 1000)
.mapToObj(i -> gremlinExecutor.eval("Color.BLACK"))
.forEach(
f -> {
f.exceptionally(t -> failures.incrementAndGet()).join();
if (!f.isCompletedExceptionally()) successes.incrementAndGet();
}));
final Thread t2 =
new Thread(
() -> {
while (failures.get() < 500) {}
gremlinExecutor.getScriptEngines().addImports(imports);
});
t1.start();
t2.start();
t1.join();
t2.join();
assertTrue(successes.intValue() > 0);
assertTrue(failures.intValue() >= 500);
gremlinExecutor.close();
}
@Test
public void testFormulaDependency() {
SBook book = SBooks.createBook("book1");
SSheet sheet = book.createSheet("Sheet 1");
SRanges.range(sheet, 0, 0).setEditText("999");
SRanges.range(sheet, 0, 1).setValue("=SUM(A1)");
SCell cell = sheet.getCell(0, 0);
Assert.assertEquals(CellType.NUMBER, cell.getType());
Assert.assertEquals(999, cell.getNumberValue().intValue());
cell = sheet.getCell(0, 1);
Assert.assertEquals(CellType.FORMULA, cell.getType());
Assert.assertEquals(CellType.NUMBER, cell.getFormulaResultType());
Assert.assertEquals("SUM(A1)", cell.getFormulaValue());
Assert.assertEquals(999D, cell.getValue());
final AtomicInteger a0counter = new AtomicInteger(0);
final AtomicInteger b0counter = new AtomicInteger(0);
final AtomicInteger unknowcounter = new AtomicInteger(0);
book.addEventListener(
new ModelEventListener() {
public void onEvent(ModelEvent event) {
if (event.getName().equals(ModelEvents.ON_CELL_CONTENT_CHANGE)) {
CellRegion region = event.getRegion();
if (region.getRow() == 0 && region.getColumn() == 0) {
a0counter.incrementAndGet();
} else if (region.getRow() == 0 && region.getColumn() == 1) {
b0counter.incrementAndGet();
} else {
unknowcounter.incrementAndGet();
}
}
}
});
SRanges.range(sheet, 0, 0).setEditText("888");
Assert.assertEquals(1, b0counter.intValue());
Assert.assertEquals(1, a0counter.intValue());
Assert.assertEquals(0, unknowcounter.intValue());
SRanges.range(sheet, 0, 0).setEditText("777");
Assert.assertEquals(2, b0counter.intValue());
Assert.assertEquals(2, a0counter.intValue());
Assert.assertEquals(0, unknowcounter.intValue());
SRanges.range(sheet, 0, 0)
.setEditText("777"); // in last update, set edit text is always notify cell change
Assert.assertEquals(3, b0counter.intValue());
Assert.assertEquals(3, a0counter.intValue());
Assert.assertEquals(0, unknowcounter.intValue());
}
public void testSelect() throws Exception {
cache.put(new MyKey("a"), 1);
cache.put(new MyKey("b"), 2);
cache.put(new MyKey("c"), 3);
final AtomicInteger count = new AtomicInteger();
CachedObjectSelector<Serializable, Object> selector =
new CachedObjectSelector<Serializable, Object>() {
public void onSelect(
ExoCache<? extends Serializable, ? extends Object> cache,
Serializable key,
ObjectCacheInfo<? extends Object> ocinfo)
throws Exception {
assertTrue(
key.equals(new MyKey("a"))
|| key.equals(new MyKey("b"))
|| key.equals(new MyKey("c")));
assertTrue(ocinfo.get().equals(1) || ocinfo.get().equals(2) || ocinfo.get().equals(3));
count.incrementAndGet();
}
public boolean select(Serializable key, ObjectCacheInfo<? extends Object> ocinfo) {
return true;
}
};
try {
cache.select(selector);
assertEquals(3, count.intValue());
} catch (UnsupportedOperationException e) {
// OK
}
}
@Test
public void shouldNotExhaustThreads() throws Exception {
final ScheduledExecutorService executorService =
Executors.newScheduledThreadPool(2, testingThreadFactory);
final GremlinExecutor gremlinExecutor =
GremlinExecutor.build()
.executorService(executorService)
.scheduledExecutorService(executorService)
.create();
final AtomicInteger count = new AtomicInteger(0);
assertTrue(
IntStream.range(0, 1000)
.mapToObj(i -> gremlinExecutor.eval("1+1"))
.allMatch(
f -> {
try {
return (Integer) f.get() == 2;
} catch (Exception ex) {
throw new RuntimeException(ex);
} finally {
count.incrementAndGet();
}
}));
assertEquals(1000, count.intValue());
executorService.shutdown();
executorService.awaitTermination(30000, TimeUnit.MILLISECONDS);
}
public int getNextQueryNumber() {
synchronized (queryCounter) {
int i = queryCounter.intValue();
queryCounter.set(i + 1);
return i;
}
}
/**
* Load preferences from an input stream.
*
* <p>Each line is a different preference, with tab-separated fields indicating user, item, weight
* and other information.
*
* @param <U> type of the users
* @param <I> type of the items
* @param in input stream to read from
* @param uParser user type parser
* @param iParser item type parser
* @param dp double parse
* @param uIndex user index
* @param iIndex item index
* @return a simple list-of-lists FastPreferenceData with the information read
* @throws IOException when path does not exists of IO error
*/
public static <U, I> SimpleFastPreferenceData<U, I> load(
InputStream in,
Parser<U> uParser,
Parser<I> iParser,
DoubleParser dp,
FastUserIndex<U> uIndex,
FastItemIndex<I> iIndex)
throws IOException {
AtomicInteger numPreferences = new AtomicInteger();
List<List<IdxPref>> uidxList = new ArrayList<>();
for (int uidx = 0; uidx < uIndex.numUsers(); uidx++) {
uidxList.add(null);
}
List<List<IdxPref>> iidxList = new ArrayList<>();
for (int iidx = 0; iidx < iIndex.numItems(); iidx++) {
iidxList.add(null);
}
try (BufferedReader reader = new BufferedReader(new InputStreamReader(in))) {
reader
.lines()
.forEach(
l -> {
CharSequence[] tokens = split(l, '\t', 4);
U user = uParser.parse(tokens[0]);
I item = iParser.parse(tokens[1]);
double value;
if (tokens.length >= 3) {
value = dp.parse(tokens[2]);
} else {
value = dp.parse(null);
}
int uidx = uIndex.user2uidx(user);
int iidx = iIndex.item2iidx(item);
numPreferences.incrementAndGet();
List<IdxPref> uList = uidxList.get(uidx);
if (uList == null) {
uList = new ArrayList<>();
uidxList.set(uidx, uList);
}
uList.add(new IdxPref(iidx, value));
List<IdxPref> iList = iidxList.get(iidx);
if (iList == null) {
iList = new ArrayList<>();
iidxList.set(iidx, iList);
}
iList.add(new IdxPref(uidx, value));
});
}
return new SimpleFastPreferenceData<>(
numPreferences.intValue(), uidxList, iidxList, uIndex, iIndex);
}
public void returnSync(final String key) {
synchronized (this.locks) {
final AtomicInteger c = this.locks.get(key);
if (c != null) {
c.decrementAndGet();
if (c.intValue() < 1) this.locks.remove(key);
}
}
}
public void process(Exchange exchange) throws Exception {
if (count.intValue() % 2 == 1) {
exchange.setException(new RecoverableException("Unexpected error, try again"));
count.incrementAndGet();
} else {
logger.info(String.format("Receiving message=%s", exchange.getIn().getBody()));
}
}
@Override
public void run() {
while (true) {
if (outerCounter.intValue() > innerCounter) {
innerCounter = outerCounter.intValue();
try {
saveToFile();
} catch (Exception e) {
innerCounter--;
}
try {
sleep(SLEEPING_TIME);
} catch (InterruptedException e) {
System.out.println("Interrupt sleeping saver ");
}
}
}
}
/** 1. 从Number中继承过来的几个方法， 并实现了它。 */
public void testValue() {
AtomicInteger ai = new AtomicInteger(22);
System.out.println(ai.byteValue());
System.out.println(ai.shortValue());
System.out.println(ai.intValue());
System.out.println(ai.longValue());
System.out.println(ai.floatValue());
System.out.println(ai.doubleValue());
}
public void doFinalReport() {
await();
doPeriodReport(false);
test.processCacheStats();
clusterTestCount.addAndGet(nodeTestCount.intValue());
clusterReads.addAndGet(processor.getRead());
clusterWrites.addAndGet(processor.getWrite());
// * 100 to get better average as it will convert to Long
if (getConfiguration().isStandalone()) {
clusterLatency.addAndGet(
(long) cumulativeLatencyStats.getTotal() * 100 / testCountAtLastReport);
}
await();
long totalNode = nodeTestCount.get();
long totalCluster = clusterTestCount.get();
long totalRead = clusterReads.get();
long totalWrite = clusterWrites.get();
log.info("------- FINAL REPORT -------- ");
long testDuration = (actualTestEndTime - testStartTime) / 1000;
log.info(String.format("Node TPS: %.1f", (double) totalNode / testDuration));
log.info(String.format("Cluster TPS: %.1f", (double) totalCluster / testDuration));
log.info("------- Cache Stats -------- ");
log.info(String.format("Cluster Cache Read TPS: %.1f", (double) totalRead / testDuration));
log.info(String.format("Cluster Cache Write TPS: %.1f", (double) totalWrite / testDuration));
log.info(
String.format(
"Cluster Cache Total TPS: %.1f", (double) (totalRead + totalWrite) / testDuration));
if (getConfiguration().isStandalone()) {
log.info(
String.format(
"Cluster Avg Latency: %.1f",
(double) clusterLatency.get() / (configuration.getNodesNum() * 100)));
log.info(String.format("Warmup Cache TPS: %d", clusterCacheWarmup.get()));
log.info(
String.format(
"Warmup Cluster TPS: %d , Time taken for clusterCoherent: %d",
clusterWarmup.get(), bulkLoadCompleteTime));
}
int totalWrites = test.getWritesCount();
if (totalWrites > 0) {
log.info(
String.format(
"Node Total Write operations: %d (%.1f %%)",
totalWrites, (totalWrites * 100.0 / totalNode)));
}
int exceptions = nonstopCacheExceptionCount.get();
if (exceptions > 0) {
log.info(
String.format(
"Node NonstopCache Exception Count: %d (%.1f %%)",
exceptions, (exceptions * 100.0 / totalNode)));
}
}
@Override
public void run() {
while (true) {
// log.debug("Status available="+availableSlots+" used="+usedSlots+" queue="+queue.size());
if (availableSlots.intValue() > usedSlots.intValue() && queue.size() > 0) {
usedSlots.incrementAndGet();
AnalysisRunner currentRun = queue.removeFirst();
currentRun.addAnalysisListener(this);
Thread t = new Thread(currentRun);
t.start();
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
}
}
}
@SmallTest
@Feature({"Android-AppBase"})
public void testFindAndUploadAllCrashes() throws IOException {
// Setup prerequisites.
final AtomicInteger numServiceStarts = new AtomicInteger(0);
final File[] minidumpFiles = {
new File(mCrashDir, "chromium_renderer-111.dmp1"),
new File(mCrashDir, "chromium_renderer-222.dmp2"),
new File(mCrashDir, "chromium_renderer-333.dmp3"),
};
MinidumpPreparationContext context =
new MinidumpPreparationContext(getInstrumentation().getTargetContext()) {
@Override
public ComponentName startService(Intent intentToCheck) {
String filePath =
intentToCheck.getStringExtra(MinidumpUploadService.FILE_TO_UPLOAD_KEY);
// Assuming numServicesStart value corresponds to minidumpFiles index.
assertEquals(
"Minidump path should be the absolute path",
minidumpFiles[numServiceStarts.intValue()].getAbsolutePath(),
filePath);
assertTrue(
"Should not call service more than number of files",
numServiceStarts.incrementAndGet() <= minidumpFiles.length);
assertEquals(
"Action should be correct",
MinidumpUploadService.ACTION_UPLOAD,
intentToCheck.getAction());
return new ComponentName(getPackageName(), MinidumpUploadService.class.getName());
}
};
MinidumpUploadService service = new TestMinidumpUploadService(context);
for (File minidumpFile : minidumpFiles) {
setUpMinidumpFile(minidumpFile, BOUNDARY);
}
// Run test.
Intent findAndUploadAllCrashesIntent =
MinidumpUploadService.createFindAndUploadAllCrashesIntent(context);
findAndUploadAllCrashesIntent.putExtra(
MinidumpUploadService.FINISHED_LOGCAT_EXTRACTION_KEY, true);
service.onCreate();
service.onHandleIntent(findAndUploadAllCrashesIntent);
// Verify.
for (File minidumpFile : minidumpFiles) {
assertTrue("Minidump file should exist: " + minidumpFile, minidumpFile.isFile());
}
assertEquals(
"Should have called startService() same number of times as there are files",
minidumpFiles.length,
numServiceStarts.intValue());
}
private <T extends SingularityId> List<T> getChildrenAsIdsForParentsThrows(
final String pathNameforLogs,
final Collection<String> parents,
final IdTranscoder<T> idTranscoder)
throws Exception {
if (parents.isEmpty()) {
return Collections.emptyList();
}
final List<T> objects = Lists.newArrayListWithExpectedSize(parents.size());
final CountDownLatch latch = new CountDownLatch(parents.size());
final AtomicInteger missing = new AtomicInteger();
final BackgroundCallback callback =
new BackgroundCallback() {
@Override
public void processResult(CuratorFramework client, CuratorEvent event) throws Exception {
if (event.getChildren() == null || event.getChildren().size() == 0) {
LOG.trace("Expected children for node {} - but found none", event.getPath());
missing.incrementAndGet();
latch.countDown();
return;
}
objects.addAll(Lists.transform(event.getChildren(), idTranscoder));
latch.countDown();
}
};
final long start = System.currentTimeMillis();
for (String parent : parents) {
curator.getChildren().inBackground(callback).forPath(parent);
}
checkLatch(latch, pathNameforLogs);
LOG.trace(
"Fetched {} objects from {} (missing {}) in {}",
objects.size(),
pathNameforLogs,
missing.intValue(),
JavaUtils.duration(start));
return objects;
}
public static void execute(
final KyotoTycoonClient client, final int numOperations, final int numThreads)
throws Exception {
final CountDownLatch latch = new CountDownLatch(numOperations);
client.start();
client.clear();
long start = System.currentTimeMillis();
final AtomicInteger errorCount = new AtomicInteger(0);
ExecutorService executor = Executors.newFixedThreadPool(numThreads);
Random r = new Random();
for (int i = 0; i < numOperations; ++i) {
final String key = "key" + i;
final String value = String.valueOf(Math.abs(r.nextInt()));
executor.submit(
new Runnable() {
@Override
public void run() {
try {
client.set(key, value);
assertEquals(value, client.get(key));
// assertTrue(client.remove(key));
} catch (RuntimeException e) {
e.printStackTrace();
fail();
} finally {
latch.countDown();
}
}
});
}
executor.shutdown();
latch.await();
if (errorCount.intValue() > 0) {
fail();
}
long timeElapsed = System.currentTimeMillis() - start;
int qps = (int) ((numOperations / (float) timeElapsed) * 1000);
System.out.println(
client.getClass().getSimpleName() + " - result: " + timeElapsed + "ms, " + qps + "qps");
client.clear();
client.stop();
}
private <T> List<T> getAsyncThrows(
final String pathNameForLogs, final Collection<String> paths, final Transcoder<T> transcoder)
throws Exception {
final List<T> objects = Lists.newArrayListWithCapacity(paths.size());
if (paths.isEmpty()) {
return objects;
}
final CountDownLatch latch = new CountDownLatch(paths.size());
final AtomicInteger missing = new AtomicInteger();
final BackgroundCallback callback =
new BackgroundCallback() {
@Override
public void processResult(CuratorFramework client, CuratorEvent event) throws Exception {
if (event.getData() == null || event.getData().length == 0) {
LOG.trace("Expected active node {} but it wasn't there", event.getPath());
missing.incrementAndGet();
latch.countDown();
return;
}
objects.add(transcoder.transcode(event.getData()));
latch.countDown();
}
};
final long start = System.currentTimeMillis();
for (String path : paths) {
curator.getData().inBackground(callback).forPath(path);
}
checkLatch(latch, pathNameForLogs);
LOG.trace(
"Fetched {} objects from {} (missing {}) in {}",
objects.size(),
pathNameForLogs,
missing.intValue(),
JavaUtils.duration(start));
return objects;
}
@Test
public void testGet() {
final AtomicInteger count = new AtomicInteger(0);
final PId idToQuery = new PiId(messageId.toStringFull(), 0);
koalaGCPastImpl =
new KoalaGCPastImpl(
node,
storageManager,
null,
0,
instance,
new KoalaPastPolicy(),
0,
storageManager,
KoalaNode.DEFAULT_NUMBER_OF_DHT_BACKUPS,
koalaIdFactory,
koalaPiEntityFactory) {
@Override
protected Continuation getResponseContinuation(PastMessage msg) {
if (msg.equals(message)) return continuation;
return null;
}
@Override
protected void getHandles(rice.p2p.commonapi.Id id, int max, Continuation command) {
NodeHandleSet nodeSet = mock(NodeHandleSet.class);
when(nodeSet.size()).thenReturn(3);
command.receiveResult(nodeSet);
}
@Override
public void lookupHandle(
rice.p2p.commonapi.Id id, NodeHandle handle, Continuation command) {
assertEquals(Id.build(idToQuery.toStringFull()), id);
count.addAndGet(1);
}
};
// act
koalaGCPastImpl.get(idToQuery, continuation);
// assert
assertEquals(3, count.intValue());
}
public void testPromptForSetting() throws Exception {
final AtomicInteger counter = new AtomicInteger();
final AtomicReference<String> promptedSecretValue = new AtomicReference<>(null);
final AtomicReference<String> promptedTextValue = new AtomicReference<>(null);
final Terminal terminal =
new MockTerminal() {
@Override
public char[] readSecret(String text, Object... args) {
counter.incrementAndGet();
assertThat(args, arrayContaining((Object) "foo.password"));
return "changeit".toCharArray();
}
@Override
public String readText(String text, Object... args) {
counter.incrementAndGet();
assertThat(args, arrayContaining((Object) "replace"));
return "replaced";
}
};
final NamedCommand cmd =
new NamedCommand("noop", terminal) {
@Override
public CliTool.ExitStatus execute(Settings settings, Environment env) {
promptedSecretValue.set(settings.get("foo.password"));
promptedTextValue.set(settings.get("replace"));
return OK;
}
};
System.setProperty("es.foo.password", InternalSettingsPreparer.SECRET_PROMPT_VALUE);
System.setProperty("es.replace", InternalSettingsPreparer.TEXT_PROMPT_VALUE);
try {
new SingleCmdTool("tool", terminal, cmd).execute();
} finally {
System.clearProperty("es.foo.password");
System.clearProperty("es.replace");
}
assertThat(counter.intValue(), is(2));
assertThat(promptedSecretValue.get(), is("changeit"));
assertThat(promptedTextValue.get(), is("replaced"));
}
private void doTestDataStore() {
log.info("Starting...");
long start = System.currentTimeMillis();
for (int i = 0; i < THREAD_COUNT; ++i) {
new Thread(new Read1Runnable()).start();
}
for (int i = 0; i < THREAD_COUNT; ++i) {
new Thread(new Read2Runnable()).start();
}
for (int i = 0; i < THREAD_COUNT; ++i) {
new Thread(new SaveRunnable()).start();
}
while (!(read1Done.get() && read2Done.get() && saveDone.get())) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
log.error(e.getMessage(), e);
}
}
if (exceptionThrownByThread != null) {
throw new RuntimeException("One of the worker threads failed.", exceptionThrownByThread);
}
long duration = System.currentTimeMillis() - start;
log.info("Took: " + duration + " ms");
log.info("Save: " + saveCount.intValue() + " files, " + bytesWritten.get() + " bytes");
log.info(
"Read: " + (read1Count.get() + read2Count.get()) + " files, " + bytesRead.get() + " bytes");
log.info("Average save time (ns): " + (double) saveTime.get() / (double) saveCount.get());
assertEquals(0, failures.get());
for (String s : sessionCounter.keySet()) {
dataStore.removeData(s);
}
}
public void classificate() {
initializeMe();
String[] attr = this.getAttrs();
features:
for (int i = 0; i < 600; i++) {
String featureValue = attr[i];
if (featureValue.charAt(0) == '1') {
for (String label : Globals.categories) {
Classification classTmp = classification.get(label);
AtomicInteger valFeatureModel =
Globals.modelDict.get(label + "_" + i); // Count of this feature in this label
if (valFeatureModel == null) // This feature was unknown always, skip it
classTmp.addFeature(0);
else classTmp.addFeature(valFeatureModel.intValue());
}
}
}
}
private static File createExperimentalFolder(
List<IDesign> problems, File experimentalFolder, String expFolderId) throws InPUTException {
if (expFolderId != null) {
File expFolder;
synchronized (globalExperimentCounter) { // make sure that the
// counter is
// consistent
expFolder = new File(expFolderId);
while (expFolder.exists()) {
repetitionCounter = globalExperimentCounter.incrementAndGet();
expFolder = new File(initExperimentalFolder(expFolderId));
}
repetitionCounter = globalExperimentCounter.intValue();
}
expFolder.mkdirs();
experimentalFolder = expFolder;
}
addProblems(experimentalFolder, problems);
return experimentalFolder;
}
private void insertPending() {
Pair pair;
for (Iterator iterator = mPendingItemsToInsert.iterator();
iterator.hasNext();
mInsertable.add(((Integer) pair.first).intValue(), pair.second)) {
pair = (Pair) iterator.next();
Iterator iterator1 = mActiveIndexes.iterator();
do {
if (!iterator1.hasNext()) {
break;
}
AtomicInteger atomicinteger = (AtomicInteger) iterator1.next();
if (atomicinteger.intValue() >= ((Integer) pair.first).intValue()) {
atomicinteger.incrementAndGet();
}
} while (true);
mActiveIndexes.add(new AtomicInteger(((Integer) pair.first).intValue()));
}
mPendingItemsToInsert.clear();
}
/**
* Tests basic configuration with polling activation.
*
* @throws StreamException if test fails
*/
@Test
public void configureWithPollingTest() throws Exception {
final AtomicInteger count = new AtomicInteger(0);
final ContextBuilderConfigurator cfg =
new ContextBuilderConfigurator() {
/** {@inheritDoc} */
@Override
public int internalConfigure(final ContextBuilder ctxBuilder) {
return 1;
}
/** {@inheritDoc} */
@Override
public String getTag() {
return "test";
}
/** {@inheritDoc} */
@Override
protected Long getLastUpdateTimestampFor(final String path) throws StreamException {
synchronized (ContextBuilderConfiguratorTest.class) {
count.incrementAndGet();
ContextBuilderConfiguratorTest.class.notify();
}
return System.currentTimeMillis();
}
};
final ContextBuilder builder = Mockito.mock(ContextBuilder.class);
cfg.configure(builder);
synchronized (ContextBuilderConfiguratorTest.class) {
ContextBuilderConfiguratorTest.class.wait(1500L);
}
Assert.assertEquals(count.intValue(), NumberUtils.TWO);
}
@SmallTest
@Feature({"Android-AppBase"})
public void testFindAndUploadLastCrash() throws IOException {
// Setup prerequisites.
final AtomicInteger numServiceStarts = new AtomicInteger(0);
final File minidumpFile = new File(mCrashDir, "chromium_renderer-123.dmp");
MinidumpPreparationContext context =
new MinidumpPreparationContext(getInstrumentation().getTargetContext()) {
@Override
public ComponentName startService(Intent intentToCheck) {
String filePath =
intentToCheck.getStringExtra(MinidumpUploadService.FILE_TO_UPLOAD_KEY);
assertEquals(
"Minidump path should be the absolute path",
minidumpFile.getAbsolutePath(),
filePath);
assertEquals("Should only call service once", 1, numServiceStarts.incrementAndGet());
assertEquals(
"Action should be correct",
MinidumpUploadService.ACTION_UPLOAD,
intentToCheck.getAction());
return new ComponentName(getPackageName(), MinidumpUploadService.class.getName());
}
};
MinidumpUploadService service = new TestMinidumpUploadService(context);
setUpMinidumpFile(minidumpFile, BOUNDARY);
// Run test.
Intent findAndUploadLastCrashIntent =
MinidumpUploadService.createFindAndUploadLastCrashIntent(context);
service.onCreate();
findAndUploadLastCrashIntent.putExtra(
MinidumpUploadService.FINISHED_LOGCAT_EXTRACTION_KEY, true);
service.onHandleIntent(findAndUploadLastCrashIntent);
// Verify.
assertTrue("Minidump file should exist", minidumpFile.isFile());
assertEquals("Should have called startService() once", 1, numServiceStarts.intValue());
}
public void insert(List list) {
if (mActiveIndexes.isEmpty() && mPendingItemsToInsert.isEmpty()) {
Pair pair;
for (list = list.iterator();
list.hasNext();
mInsertable.add(((Integer) pair.first).intValue(), pair.second)) {
pair = (Pair) list.next();
Iterator iterator = mActiveIndexes.iterator();
do {
if (!iterator.hasNext()) {
break;
}
AtomicInteger atomicinteger = (AtomicInteger) iterator.next();
if (atomicinteger.intValue() >= ((Integer) pair.first).intValue()) {
atomicinteger.incrementAndGet();
}
} while (true);
mActiveIndexes.add(new AtomicInteger(((Integer) pair.first).intValue()));
}
} else {
mPendingItemsToInsert.addAll(list);
}
}
@Override
public void scheduleCleanup() {
if (!cleanupEnabled || scheduledCleanup.intValue() > 2) {
// Scheduled cleanup was already scheduled before.. never mind!
// or we have cleanup disabled
return;
}
scheduledCleanup.incrementAndGet();
executor.execute(
new Runnable() {
public void run() {
storageManager.setContext(storageManager.newSingleThreadContext());
try {
cleanup();
} finally {
storageManager.clearContext();
scheduledCleanup.decrementAndGet();
}
}
});
}
public static void main(String[] args) {
if (args.length < 8) {
System.err.println(
"use: -dbhost -dbname -downloadHost -downloadFolderName -user -password"
+ "-sleeptime -maxthread");
return;
}
dbHost = args[0];
dbName = args[1];
downloadHost = args[2];
downloadFolderName = args[3];
username = args[4];
password = args[5];
try {
sleeptime = Long.parseLong(args[6]);
maxthread = Integer.parseInt(args[7]);
} catch (Exception e) {
System.err.println("Error: -sleeptime and -maxthread must be valid integer values");
return;
}
try {
java.sql.Connection c = DBConnector.connect(dbName, dbHost, username, password);
DBConnector.setConnect(c);
AtomicInteger count = new AtomicInteger(0);
while (true) {
System.out.println(
"Searching for tasks.. Still available to start: " + (maxthread - count.intValue()));
try {
List<Task> tasks = fetchTasks(count);
for (Task t : tasks) {
for (String r : t.initializeResource()) DBConnector.addScheduledTasks(t, r);
}
List<Task> scheduled_tasks = fetchScheduledTasks(count);
c.commit();
for (Task scheduledTask : scheduled_tasks) {
if (!check(scheduledTask))
switch (scheduledTask.getType()) {
case Constants.IMAGE:
new ImageDownloader(scheduledTask, count).start();
break;
case Constants.TEXT:
new TextDownloader(scheduledTask, count).start();
break;
case Constants.VIDEO:
new VideoDownloader(scheduledTask, count).start();
break;
case Constants.SOUND:
new SoundDownloader(scheduledTask, count).start();
break;
case Constants._3D:
new Downloader3D(scheduledTask, count).start();
break;
}
}
} catch (SQLException e) {
c.rollback();
System.out.println("rollbacking");
}
System.out.println("sleeping");
Thread.sleep(sleeptime);
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void run() {
String dbChangeId;
String dbPluginType;
// Order db changes by create date before starting to run them
ArrayList<String> unsortedDbChangeIds = new ArrayList<String>();
ArrayList<String> sortedDbChangeIds = new ArrayList<String>();
for (int i = 0; i < dbChanges.length(); i++) {
unsortedDbChangeIds.add(dbChanges.getString(i));
}
sortedDbChangeIds = repHandler.getDbChangesSortedByCreateDate(unsortedDbChangeIds);
for (int i = 0; i < sortedDbChangeIds.size(); i++) {
dbChangeId = sortedDbChangeIds.get(i);
String dbChangeScript = repHandler.getDatabaseChangeScript(dbChangeId);
dbPluginType = repHandler.getDBPluginTypeForDbChange(dbChangeId);
DBService dbService = DBService.getDBService(dbPluginType);
HashMap<String, String> globalParameters = null;
try {
String dbcadServerHostname = InetAddress.getLocalHost().getHostName();
globalParameters = repHandler.getDBPluginConfig(dbPluginType, dbcadServerHostname);
} catch (UnknownHostException e) {
e.printStackTrace();
}
ArrayList<DeploymentDetails> deploymentDetailsList =
repHandler.getDeployableDatabaseInstancesAndSchemaNamesForLobIdAndDbChange(
dbChangeId, lobId);
for (DeploymentDetails deploymentDetails : deploymentDetailsList) {
if (!repHandler.isDbChangeDeployed(
dbChangeId,
deploymentDetails.getDbGroupId(),
deploymentDetails.getDbInstance().getDbId())) {
if (!markOnly) {
repHandler.markDbChangeDeploymentStatus(
dbChangeId,
deploymentDetails.getDbGroupId(),
deploymentDetails.getDbInstance().getDbId(),
DBCADController.RUNNING_STATUS);
HashMap<String, HashMap<String, String>> parameterAttributes =
dbService.getInstanceParameterAttributes();
String dbSchemaName = deploymentDetails.getSchemaName();
Cipher aes = null;
try {
aes = Cipher.getInstance("AES");
// SecretKeySpec k = new SecretKeySpec(DBCADController.ENCRYPTION_KEY.getBytes(),
// "AES");
aes.init(Cipher.DECRYPT_MODE, DBCADController.ENC_KEY);
HashMap<String, String> pluginInstanceParameters =
deploymentDetails.getDbInstance().getPluginInstanceParameters();
for (Map.Entry<String, String> entry : pluginInstanceParameters.entrySet()) {
String key = entry.getKey();
if (parameterAttributes.get(key) != null
&& parameterAttributes.get(key).get("ENCRYPTED").equals("TRUE")) {
BasicTextEncryptor textEncryptor = new BasicTextEncryptor();
textEncryptor.setPassword(DBCADController.ENCRYPTION_KEY);
String encTextValue = (String) pluginInstanceParameters.get(key);
pluginInstanceParameters.put(key, textEncryptor.decrypt(encTextValue));
}
}
} catch (Exception e) {
e.printStackTrace();
}
dbService.initializeDBService(deploymentDetails.getDbInstance(), globalParameters);
String output;
AtomicInteger exitCode = new AtomicInteger(0);
output = dbService.runScript(dbChangeScript, dbSchemaName, exitCode);
repHandler.addDeploymentLog(dbChangeId, deploymentDetails.getDbInstance(), output);
dbService.close();
if (exitCode.intValue() == 0) {
repHandler.markDbChangeDeploymentStatus(
dbChangeId,
deploymentDetails.getDbGroupId(),
deploymentDetails.getDbInstance().getDbId(),
DBCADController.OK_STATUS);
} else {
repHandler.markDbChangeDeploymentStatus(
dbChangeId,
deploymentDetails.getDbGroupId(),
deploymentDetails.getDbInstance().getDbId(),
DBCADController.ERROR_STATUS);
}
} else {
repHandler.addDeploymentLog(
dbChangeId, deploymentDetails.getDbInstance(), "-- MARK ONLY --");
repHandler.markDbChangeDeploymentStatus(
dbChangeId,
deploymentDetails.getDbGroupId(),
deploymentDetails.getDbInstance().getDbId(),
DBCADController.OK_STATUS);
}
}
}
}
}