@Override
public void onDestroy() {
super.onDestroy();
if (mThumbnailer != null) mThumbnailer.clearJobs();
mBarrier.reset();
mVideoAdapter.clear();
}
private void sendRequest(int id, int count) throws Exception {
int idx = id - 1;
if (idx < 0) throw new IllegalArgumentException("Connection ID <= 0");
_socket[idx] =
_socket[idx] == null ? new Socket("localhost", _connector.getLocalPort()) : _socket[idx];
_out[idx] =
_out[idx] == null ? new PrintWriter(_socket[idx].getOutputStream(), true) : _out[idx];
_in[idx] =
_in[idx] == null
? new BufferedReader(new InputStreamReader(_socket[idx].getInputStream()))
: _in[idx];
_connect.reset();
_out[idx].write("GET / HTTP/1.1\r\nHost: localhost\r\n\r\n");
_out[idx].flush();
_connect.await();
assertEquals(count, _statistics.getConnectionsOpen());
String line = _in[idx].readLine();
while (line != null) {
if ("Server response".equals(line)) break;
line = _in[idx].readLine();
}
}
@Override
public int scan(
String keyspace,
String lowerBound,
int recordCount,
Set<String> columns,
Vector<HashMap<String, ByteIterator>> result) {
try {
byte[] ks = keyspace.getBytes(UTF8);
ClientResponse response =
m_client.callProcedure("Scan", ks, lowerBound, lowerBound.getBytes(UTF8), recordCount);
if (response.getStatus() != ClientResponse.SUCCESS) {
return 1;
}
int nFound = 0;
String partKey = lowerBound;
CyclicBarrier barrier = new CyclicBarrier(2);
result.ensureCapacity(recordCount);
ScanCallback callback = null;
boolean proceed = true;
while (proceed) {
if (response.getStatus() != ClientResponse.SUCCESS) {
return 1;
}
VoltTable table = response.getResults()[0];
nFound += table.getRowCount();
proceed = nFound < recordCount && (partKey = nextPartitionKey(partKey)) != null;
if (proceed) {
barrier.reset();
callback = new ScanCallback(barrier);
m_client.callProcedure(callback, "Scan", ks, partKey, null, recordCount - nFound);
}
while (table.advanceRow()) {
result.add(unpackRowData(table, columns));
}
if (proceed) {
barrier.await();
response = callback.response;
}
}
return 0;
} catch (Exception e) {
e.printStackTrace();
return 1;
}
}
@Test
public void testCloseDuringPendingRequest() throws Exception {
CyclicBarrier beforeRequest = new CyclicBarrier(2);
CyclicBarrier afterRequest = new CyclicBarrier(2);
StaticRequestProcessor processor = new StaticRequestProcessor(beforeRequest, afterRequest);
processor.setResponse(
new TestingResponse(
HttpStatus.NO_CONTENT, ImmutableListMultimap.<String, String>of(), new byte[0]));
CyclicBarrier requestComplete = new CyclicBarrier(2);
TestingClientCallback callback = new TestingClientCallback(requestComplete);
URI location = URI.create("http://localhost:8080");
HttpPageBufferClient client =
new HttpPageBufferClient(
new TestingHttpClient(processor, executor),
new DataSize(10, Unit.MEGABYTE),
new Duration(1, TimeUnit.MINUTES),
location,
callback,
blockEncodingManager,
executor,
Stopwatch.createUnstarted());
assertStatus(client, location, "queued", 0, 0, 0, 0, "not scheduled");
// send request
client.scheduleRequest();
beforeRequest.await(10, TimeUnit.SECONDS);
assertStatus(client, location, "running", 0, 1, 0, 0, "PROCESSING_REQUEST");
assertEquals(client.isRunning(), true);
// request is pending, now close it
client.close();
try {
requestComplete.await(10, TimeUnit.SECONDS);
} catch (BrokenBarrierException ignored) {
}
try {
afterRequest.await(10, TimeUnit.SECONDS);
} catch (BrokenBarrierException ignored) {
afterRequest.reset();
}
// client.close() triggers a DELETE request, so wait for it to finish
beforeRequest.await(10, TimeUnit.SECONDS);
afterRequest.await(10, TimeUnit.SECONDS);
requestComplete.await(10, TimeUnit.SECONDS);
assertStatus(client, location, "closed", 0, 1, 2, 1, "not scheduled");
}
void resetForTxn() {
synchronized (barrier1) {
if (barrier1.isBroken()) {
barrier1.reset();
}
}
synchronized (barrier2) {
if (barrier2.isBroken()) {
barrier2.reset();
}
}
synchronized (txnBarrier) {
if (txnBarrier.isBroken()) {
txnBarrier.reset();
}
}
try {
txnBarrier.await();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void resetBarrier() {
mBarrier.reset();
}
@Test(timeout = 10000)
public void testIntervalTimerWithoutFire() throws Exception {
String str = "";
str += "package org.simple \n";
str += "global java.util.List list \n";
str += "rule xxx \n";
str += " timer (int:30s 10s) ";
str += "when \n";
str += "then \n";
str += " list.add(\"fired\"); \n";
str += "end \n";
KieSessionConfiguration conf = KnowledgeBaseFactory.newKnowledgeSessionConfiguration();
conf.setOption(ClockTypeOption.get("pseudo"));
KnowledgeBase kbase = loadKnowledgeBaseFromString(str);
KieSession ksession = createKnowledgeSession(kbase, conf);
final BlockingQueue<TimedRuleExecution> queue = new LinkedBlockingQueue<TimedRuleExecution>();
((StatefulKnowledgeSessionImpl) ksession).session.setTimedExecutionsQueue(queue);
final CyclicBarrier barrier = new CyclicBarrier(2);
final AtomicBoolean run = new AtomicBoolean(true);
Thread t =
new Thread(
new Runnable() {
public void run() {
try {
while (run.get()) {
queue.take().evauateAndFireRule();
try {
barrier.await();
} catch (BrokenBarrierException e) {
throw new RuntimeException(e);
}
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.setDaemon(true);
t.start();
List list = new ArrayList();
PseudoClockScheduler timeService =
(PseudoClockScheduler) ksession.<SessionClock>getSessionClock();
timeService.advanceTime(new Date().getTime(), TimeUnit.MILLISECONDS);
ksession.setGlobal("list", list);
ksession.fireAllRules();
assertEquals(0, list.size());
timeService.advanceTime(35, TimeUnit.SECONDS);
barrier.await();
barrier.reset();
assertEquals(1, list.size());
timeService.advanceTime(10, TimeUnit.SECONDS);
barrier.await();
barrier.reset();
assertEquals(2, list.size());
timeService.advanceTime(10, TimeUnit.SECONDS);
barrier.await();
barrier.reset();
assertEquals(3, list.size());
run.set(false);
barrier.reset();
}
