@Override
public byte[] handle(byte[] requestBa) {
ClassLoadingCodeRunnerClient.RemoteCodeRequest request =
(ClassLoadingCodeRunnerClient.RemoteCodeRequest)
SerializationHelper.toObject(requestBa, getClass().getClassLoader());
ClassLoadingCodeRunnerClient.log.debug("handling {}", request);
try {
return SerializationHelper.toByteArray(handle(request));
} catch (Exception e) {
return SerializationHelper.toByteArray(new FailureResponse(e));
} finally {
ClassLoadingCodeRunnerClient.log.debug(
"handling " + request.getClass().getSimpleName() + " done");
}
}
@Test
public void testLocalVariableMVELConsequence() throws Exception {
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl(
new InputStreamReader(
getClass().getResourceAsStream("test_LocalVariableMVELConsequence.drl")));
final Package pkg = builder.getPackage();
RuleBase ruleBase = getRuleBase();
ruleBase.addPackage(pkg);
ruleBase = SerializationHelper.serializeObject(ruleBase);
final WorkingMemory workingMemory = ruleBase.newStatefulSession();
final List list = new ArrayList();
workingMemory.setGlobal("results", list);
workingMemory.insert(new Person("bob", "stilton"));
workingMemory.insert(new Person("mark", "brie"));
try {
workingMemory.fireAllRules();
assertEquals("should have fired twice", 2, list.size());
} catch (Exception e) {
e.printStackTrace();
fail("Should not raise any exception");
}
}
@Test
@Ignore
public void testStatefulSessionsCreation() throws Exception {
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl(
new InputStreamReader(getClass().getResourceAsStream("test_OutOfMemoryError.drl")));
final Package pkg = builder.getPackage();
RuleBase ruleBase = getRuleBase();
ruleBase.addPackage(pkg);
ruleBase = SerializationHelper.serializeObject(ruleBase);
int i = 0;
SessionConfiguration conf = new SessionConfiguration();
conf.setKeepReference(
true); // this is just for documentation purposes, since the default value is "true"
try {
for (i = 0; i < 300000; i++) {
final StatefulSession session = ruleBase.newStatefulSession(conf, null);
session.dispose();
}
} catch (Throwable e) {
System.out.println("Error at: " + i);
e.printStackTrace();
fail("Should not raise any error or exception.");
}
}
private StatelessSession getSession() throws Exception {
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl(
new InputStreamReader(getClass().getResourceAsStream("literal_rule_test.drl")));
final Package pkg = builder.getPackage();
RuleBase ruleBase = getRuleBase();
ruleBase.addPackage(pkg);
ruleBase = SerializationHelper.serializeObject(ruleBase);
StatelessSession session = ruleBase.newStatelessSession();
session = SerializationHelper.serializeObject(session);
session.setGlobalResolver(this.globalResolver);
session.setGlobal("list", this.list);
session.setGlobal("cheesery", this.cheesery);
return session;
}
private void readStageAck(SelectionKey key) throws IOException {
SocketChannel socketChannel = (SocketChannel) key.channel();
ByteBuffer byteBuffer = readBufferMap.get(socketChannel);
int value = socketChannel.read(byteBuffer);
if (value < 0) {
Integer slaveIndex = slave2Index.get(socketChannel);
log.warn("Slave stopped! Index: " + slaveIndex + ". Remote socket is: " + socketChannel);
key.cancel();
if (slaveIndex == null || slaves[slaveIndex] != socketChannel) {
throw new IllegalStateException("Socket " + socketChannel + " should have been there!");
}
throw new IOException("Slave stopped");
} else if (byteBuffer.position() >= 4) {
int expectedSize = byteBuffer.getInt(0);
if ((expectedSize + 4) > byteBuffer.capacity()) {
ByteBuffer replacer = ByteBuffer.allocate(expectedSize + 4);
replacer.put(byteBuffer.array(), 0, byteBuffer.position());
readBufferMap.put(socketChannel, replacer);
if (log.isTraceEnabled())
log.trace(
"Expected size("
+ expectedSize
+ ")"
+ " is > ByteBuffer's capacity("
+ byteBuffer.capacity()
+ ")"
+ ".Replacing "
+ byteBuffer
+ " with "
+ replacer);
byteBuffer = replacer;
}
if (log.isTraceEnabled())
log.trace(
"Expected size: "
+ expectedSize
+ ". byteBuffer.position() == "
+ byteBuffer.position());
if (byteBuffer.position() == expectedSize + 4) {
log.trace("Received response from " + socketChannel);
Object response = SerializationHelper.deserialize(byteBuffer.array(), 4, expectedSize);
byteBuffer.clear();
responses.add(response);
}
}
}
@Override
public List<DistStageAck> runStage(int stageId, Map<String, Object> masterData, int numSlaves)
throws IOException {
responses.clear();
clearBuffer();
mcastBuffer.putInt(stageId);
mcastBuffer =
SerializationHelper.serializeObjectWithLength((Serializable) masterData, mcastBuffer);
mcastBuffer(numSlaves);
flushBuffers(numSlaves);
ArrayList<DistStageAck> list = new ArrayList<>(responses.size());
for (Object o : responses) {
list.add((DistStageAck) o);
}
return list;
}
@SuppressWarnings("unchecked")
private ClassLoadingCodeRunnerClient.RemoteCodeResponse handle(
ClassLoadingCodeRunnerClient.RemoteCodeRequest request) {
if (request instanceof ClassLoadingCodeRunnerClient.GetToClientMessagesRequest) {
List<ClassLoadingCodeRunnerClient.RemoteCodeMessage> messages = new ArrayList<>();
try {
messages.add(toClient.take());
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
toClient.drainTo(messages);
ClassLoadingCodeRunnerClient.log.debug("sending to client: {}", messages);
return new ToClientMessagesResponse(messages);
} else if (request instanceof ClassLoadingCodeRunnerClient.SendToServerMessagesRequest) {
ClassLoadingCodeRunnerClient.SendToServerMessagesRequest sendToServerMessagesRequest =
(ClassLoadingCodeRunnerClient.SendToServerMessagesRequest) request;
for (ClassLoadingCodeRunnerClient.RemoteCodeMessage message :
sendToServerMessagesRequest.messages) {
ClassLoadingCodeRunnerClient.log.debug("handling toServer message " + message);
if (message instanceof ClassLoadingCodeRunnerClient.ServerCodeExitReceived) {
toServerDeserializer.shutdown();
exitConfirmationReceived.release();
} else if (message instanceof ClassLoadingCodeRunnerClient.SendResourceMessage) {
classLoader.addResource((ClassLoadingCodeRunnerClient.SendResourceMessage) message);
} else if (message instanceof ClassLoadingCodeRunnerClient.SendJarsMessage) {
classLoader.addJars(((ClassLoadingCodeRunnerClient.SendJarsMessage) message).jars);
} else if (message instanceof ClassLoadingCodeRunnerClient.CustomMessageWrapper) {
toServerDeserializer.execute(
() -> {
ClassLoadingCodeRunnerClient.CustomMessageWrapper wrapper =
(ClassLoadingCodeRunnerClient.CustomMessageWrapper) message;
TMessage wrappedMessage =
(TMessage) SerializationHelper.toObject(wrapper.message, classLoader);
ClassLoadingCodeRunnerClient.log.debug(
"received and deserialized custom message {}", wrappedMessage);
toServer.add(wrappedMessage);
});
} else {
throw new UnsupportedOperationException("Unknown message " + message);
}
}
return new EmptyResponse();
} else {
throw new UnsupportedOperationException(request.getClass().getName());
}
}
@SuppressWarnings("unchecked")
@Override
public void run() {
try {
((MessageHandlingServerCode<TMessage>)
SerializationHelper.toObject(codeDelegate, classLoader))
.run(this);
toClient.add(new ServerCodeExited(null));
} catch (Throwable e) {
ClassLoadingCodeRunnerClient.log.info("Error occurred: ", e);
toClient.add(new ServerCodeExited(e));
} finally {
try {
exitConfirmationReceived.acquire();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
@Test
public void testMVELUsingGlobalsInDebugMode() throws Exception {
MVELDebugHandler.setDebugMode(true);
try {
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl(
new InputStreamReader(getClass().getResourceAsStream("test_MVELGlobalDebug.drl")));
final Package pkg = builder.getPackage();
RuleBase ruleBase = getRuleBase();
ruleBase.addPackage(pkg);
ruleBase = SerializationHelper.serializeObject(ruleBase);
final StatefulSession session = ruleBase.newStatefulSession();
session.dispose();
MVELDebugHandler.setDebugMode(false);
} catch (Exception e) {
MVELDebugHandler.setDebugMode(false);
e.printStackTrace();
fail("Should not raise exceptions");
}
}
@Test
@Ignore
public void testAgendaLoop() throws Exception {
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl(
new InputStreamReader(getClass().getResourceAsStream("test_OutOfMemory.drl")));
final Package pkg = builder.getPackage();
RuleBase ruleBase = getRuleBase();
ruleBase.addPackage(pkg);
ruleBase = SerializationHelper.serializeObject(ruleBase);
final WorkingMemory workingMemory = ruleBase.newStatefulSession();
workingMemory.insert(new Cheese("stilton", 1));
workingMemory.fireAllRules(3000000);
// just for profiling
// Thread.currentThread().wait();
}
private StatelessKnowledgeSession getSession2(Resource resource) throws Exception {
KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add(resource, ResourceType.DRL);
if (kbuilder.hasErrors()) {
System.out.println(kbuilder.getErrors());
}
assertFalse(kbuilder.hasErrors());
Collection<KnowledgePackage> pkgs = kbuilder.getKnowledgePackages();
KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
kbase.addKnowledgePackages(pkgs);
kbase = SerializationHelper.serializeObject(kbase);
StatelessKnowledgeSession session = kbase.newStatelessKnowledgeSession();
session.setGlobal("list", this.list);
session.setGlobal("cheesery", this.cheesery);
return session;
}
@Override
public void fromData(DataInput in) throws IOException, ClassNotFoundException {
super.fromData(in);
this.excludedServers = SerializationHelper.readServerLocationSet(in);
}
@Test
public void testQuery() throws Exception {
String str = "";
str += "package org.drools.test \n";
str += "import org.drools.Cheese \n";
str += "query cheeses \n";
str += " stilton : Cheese(type == 'stilton') \n";
str += " cheddar : Cheese(type == 'cheddar', price == stilton.price) \n";
str += "end\n";
KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
kbuilder.add(ResourceFactory.newByteArrayResource(str.getBytes()), ResourceType.DRL);
if (kbuilder.hasErrors()) {
fail(kbuilder.getErrors().toString());
}
KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());
kbase = SerializationHelper.serializeObject(kbase);
StatelessKnowledgeSession ksession = kbase.newStatelessKnowledgeSession();
Cheese stilton1 = new Cheese("stilton", 1);
Cheese cheddar1 = new Cheese("cheddar", 1);
Cheese stilton2 = new Cheese("stilton", 2);
Cheese cheddar2 = new Cheese("cheddar", 2);
Cheese stilton3 = new Cheese("stilton", 3);
Cheese cheddar3 = new Cheese("cheddar", 3);
Set set = new HashSet();
List list = new ArrayList();
list.add(stilton1);
list.add(cheddar1);
set.add(list);
list = new ArrayList();
list.add(stilton2);
list.add(cheddar2);
set.add(list);
list = new ArrayList();
list.add(stilton3);
list.add(cheddar3);
set.add(list);
List<Command> cmds = new ArrayList<Command>();
cmds.add(CommandFactory.newInsert(stilton1));
cmds.add(CommandFactory.newInsert(stilton2));
cmds.add(CommandFactory.newInsert(stilton3));
cmds.add(CommandFactory.newInsert(cheddar1));
cmds.add(CommandFactory.newInsert(cheddar2));
cmds.add(CommandFactory.newInsert(cheddar3));
cmds.add(CommandFactory.newQuery("cheeses", "cheeses"));
ExecutionResults batchResult =
(ExecutionResults) ksession.execute(CommandFactory.newBatchExecution(cmds));
org.drools.runtime.rule.QueryResults results =
(org.drools.runtime.rule.QueryResults) batchResult.getValue("cheeses");
assertEquals(3, results.size());
assertEquals(2, results.getIdentifiers().length);
Set newSet = new HashSet();
for (org.drools.runtime.rule.QueryResultsRow result : results) {
list = new ArrayList();
list.add(result.get("stilton"));
list.add(result.get("cheddar"));
newSet.add(list);
}
assertEquals(set, newSet);
}
public ClassLoadingServerCode(MessageHandlingServerCode<TMessage> codeDelegate) {
this.codeDelegate = SerializationHelper.toByteArray(codeDelegate);
}
private void mcastObject(Serializable object, int numSlaves) throws IOException {
clearBuffer();
mcastBuffer = SerializationHelper.serializeObjectWithLength(object, mcastBuffer);
mcastBuffer(numSlaves);
}
@Override
public void toData(DataOutput out) throws IOException {
super.toData(out);
SerializationHelper.writeServerLocationSet(this.excludedServers, out);
}
@Override
public void sendToClient(TMessage msg) {
toClient.add(new CustomMessageWrapper(SerializationHelper.toByteArray(msg)));
}
