bool send_rpc(ErlTerm *t, MailBox *mailbox)
throw(EpiException)
{
std::cout << "Sending RPC: reply_server:print(" <<
t->toString() << ")\n";
ErlTermPtr<ErlConsList> list = new ErlConsList(t);
mailbox->sendRPC(REMOTENODE, "reply_server", "print", list.get());
std::cout << "Sent. Receiving response:\n";
ErlTermPtr<ErlTerm> t2(mailbox->receiveRPC());
std::cout << "Got term: " << t2->toString() << "\n";
bool equals = t->equals(*t2);
if (equals) {
std::cout << "Equals, ok" << "\n";
} else {
std::cout << "Not equals, error!" << "\n";
}
return equals;
}
void MailBox::sendRPC( const std::string nodename,
const std::string mod,
const std::string fun,
ErlList* args )
throw ( EpiBadArgument, EpiInvalidTerm,
EpiEncodeException, EpiConnectionException )
{
ErlTerm* inner_terms[] = {
new ErlAtom("call"),
new ErlAtom(mod.c_str()),
new ErlAtom(fun.c_str()),
args,
new ErlAtom("user")
};
ErlTermPtr<ErlTerm> execTuple =
new ErlTuple(self(), new ErlTuple(inner_terms, 5));
std::auto_ptr<OutputBuffer> buffer(mSender->newOutputBuffer());
buffer->writeTerm(execTuple.get());
sendBuf(nodename, "rex", buffer.get());
}
bool test_connect(LocalNode &node)
throw (EpiException)
{
std::cout << "Testing connect to a node with a reply server\n";
std::cout << "Connecting to " << REMOTENODE << "\n";
std::auto_ptr<Connection> connection(node.connect(REMOTENODE));
std::auto_ptr<MailBox> mailbox(node.createMailBox(connection.get()));
connection->start();
bool ret=true;
ErlTermPtr<ErlTerm> *test_set = create_test_set();
ErlTermPtr<ErlTerm> *p = test_set;
/*
std::cout << "Testing send and receive data\n";
while(p->get()) {
if (!send_reply_server(p->get(), mailbox.get())) {
ret = false;
break;
}
p++;
}
*/
std::cout << "Testing pattern Matching\n";
ErlTermPtr<ErlTerm> hellomoon(new ErlTuple(new ErlAtom("hello"), new ErlAtom("moon")));
ErlTermPtr<ErlTerm> helloworld(new ErlTuple(new ErlAtom("hello"), new ErlAtom("world")));
ErlTermPtr<ErlTerm> hellocat(new ErlTuple(new ErlAtom("hello"), new ErlAtom("cat")));
ErlTermPtr<ErlTerm> hellodog(new ErlTuple(new ErlAtom("hello"), new ErlAtom("dog")));
ErlTermPtr<ErlTerm> varmoon(new ErlTuple(new ErlVariable(), new ErlAtom("moon")));
ErlTermPtr<ErlTerm> varworld(new ErlTuple(new ErlVariable(), new ErlAtom("world")));
ErlTermPtr<ErlTerm> varcat(new ErlTuple(new ErlVariable("X"), new ErlAtom("cat")));
ErlTermPtr<ErlTerm> vardog(new ErlTuple(new ErlVariable(), new ErlAtom("dog")));
mailbox->send("reply_server", new ErlTuple(mailbox->self(), hellomoon.get()));
mailbox->send("reply_server", new ErlTuple(mailbox->self(), helloworld.get()));
mailbox->send("reply_server", new ErlTuple(mailbox->self(), hellocat.get()));
mailbox->send("reply_server", new ErlTuple(mailbox->self(), hellodog.get()));
ErlTermPtr<ErlTerm> received_pattern;
received_pattern.reset(mailbox->receive(varworld.get()));
std::cout << "Pattern matched: " << received_pattern->toString() << "\n";
received_pattern.reset(mailbox->receive(vardog.get()));
std::cout << "Pattern matched: " << received_pattern->toString() << "\n";
received_pattern.reset(mailbox->receive(varmoon.get()));
std::cout << "Pattern matched: " << received_pattern->toString() << "\n";
ComposedGuard *guard = new ComposedGuard();
guard->addGuard(new MatchingCommandGuard(vardog.get(), new TestCommand1()));
guard->addGuard(new MatchingCommandGuard(varcat.get(), new TestCommand2()));
std::auto_ptr<ErlangMessage> a_msg(mailbox->receive(guard));
std::cout << "Pattern matched: " << a_msg->getMsg()->toString() << "\n";
std::cout << "Testing rpc calls\n";
p = test_set;
while(p->get()) {
if (!send_rpc(p->get(), mailbox.get())) {
ret = false;
break;
}
p++;
}
delete [] test_set;
return ret;
}
inline ErlTermPtr<T>(const ErlTermPtr<U>& rhs):
mErlTerm(rhs.addRef())
{
Dout(dc::erlang_memory, "["<<mErlTerm<<"]"<<" \\- ErlTermPtr copy");
}
