package edu.brown.hstore;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.voltdb.BackendTarget;
import org.voltdb.CatalogContext;
import org.voltdb.ClientResponseImpl;
import org.voltdb.ParameterSet;
import org.voltdb.VoltTable;
import edu.brown.hstore.Hstoreservice.WorkFragment;
import edu.brown.utils.PartitionEstimator;
import edu.brown.hstore.txns.LocalTransaction;
/**
*
* @author pavlo
*/
public class MockPartitionExecutor extends PartitionExecutor {
private static final BackendTarget BACKEND_TARGET = BackendTarget.HSQLDB_BACKEND;
private final Map<Long, VoltTable> dependencies = new HashMap<Long, VoltTable>();
private final Map<Long, CountDownLatch> latches = new HashMap<Long, CountDownLatch>();
public MockPartitionExecutor(int partition_id, CatalogContext catalogContext, PartitionEstimator p_estimator) {
super(partition_id, catalogContext, BACKEND_TARGET, p_estimator, null);
this.initializeVoltProcedures();
}
@Override
public void processClientResponse(LocalTransaction ts, ClientResponseImpl cresponse) {
// Nothing!
}
@Override
public VoltTable[] dispatchWorkFragments(LocalTransaction ts, int batchSize, ParameterSet[] parameters, Collection<WorkFragment.Builder> fragments, boolean finalTask) {
return (new VoltTable[]{ });
}
public synchronized void storeDependency(long txnId, int senderPartitionId, int dependencyId, VoltTable data) {
System.err.println("STORING TXN #" + txnId);
this.dependencies.put(txnId, data);
CountDownLatch latch = this.latches.get(txnId);
if (latch != null) {
System.err.println("UNBLOCKING TXN #" + txnId);
latch.countDown();
}
}
public synchronized VoltTable getDependency(long txnId) {
return this.dependencies.get(txnId);
}
public synchronized VoltTable waitForDependency(long txnId) {
VoltTable vt = this.dependencies.get(txnId);
if (vt == null) {
CountDownLatch latch = this.latches.get(txnId);
if (latch == null) {
latch = new CountDownLatch(1);
this.latches.put(txnId, latch);
}
try {
System.err.println("WAITING FOR TXN #" + txnId);
latch.await(100, TimeUnit.MILLISECONDS);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
vt = this.dependencies.get(txnId);
}
return (vt);
}
}