void Admintest::test_SetOperation_obj_IG()
{
Account_SetOperation_called = 0;
long cid = m_id_counter++;
Entity * c = new Entity(compose("%1", cid), cid);
m_account->m_charactersDict.insert(std::make_pair(cid, c));
Atlas::Objects::Operation::Set op;
OpVector res;
Anonymous arg;
arg->setObjtype("obj");
arg->setId(c->getId());
op->setArgs1(arg);
m_account->SetOperation(op, res);
ASSERT_EQUAL(Account_SetOperation_called, m_account);
// The operation returned would have come from Account::SetOperation
// but that is stubbed out
ASSERT_EQUAL(res.size(), 0u);
delete c;
}
void Admintest::test_GetOperation_obj_IG()
{
long cid = m_id_counter++;
std::string cid_str = String::compose("%1", cid);
Entity * to = new Entity(cid_str, cid);
m_server->m_world.addEntity(to);
Atlas::Objects::Operation::Get op;
OpVector res;
Anonymous arg;
arg->setObjtype("obj");
arg->setId(cid_str);
op->setArgs1(arg);
m_account->GetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
const Operation & reply = res.front();
ASSERT_EQUAL(reply->getClassNo(),
Atlas::Objects::Operation::INFO_NO);
ASSERT_EQUAL(reply->getArgs().size(), 1u);
const Root & reply_arg = reply->getArgs().front();
ASSERT_TRUE(!reply_arg->isDefaultId());
ASSERT_EQUAL(reply_arg->getId(), to->getId());
delete to;
}
void Admintest::test_GetOperation_rule_found()
{
Atlas::Objects::Operation::Get op;
OpVector res;
Anonymous arg;
arg->setObjtype("class");
arg->setId("root");
op->setArgs1(arg);
m_account->GetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
const Operation & reply = res.front();
ASSERT_EQUAL(reply->getClassNo(),
Atlas::Objects::Operation::INFO_NO);
ASSERT_EQUAL(reply->getArgs().size(), 1u);
const Root & reply_arg = reply->getArgs().front();
ASSERT_TRUE(!reply_arg->isDefaultId());
ASSERT_EQUAL(reply_arg->getId(), "root");
}
// check() description with op_definition objtype
void PropertyRuleHandlertest::test_check_pass()
{
Anonymous description;
description->setObjtype("type");
description->setParents(std::list<std::string>(1, "foo"));
int ret = rh->check(description);
assert(ret == 0);
}
void PropertyRuleHandlertest::test_install_noparent()
{
Anonymous description;
description->setObjtype("type");
std::string dependent, reason;
int ret = rh->install("new_int_type", "int", description, dependent, reason);
assert(ret == 0);
}
void PropertyRuleHandlertest::test_install_exists()
{
PropertyManager::instance()->installFactory("existing_int_type",
Root(),
new PropertyFactory<Property<int>>);
Anonymous description;
description->setObjtype("type");
std::string dependent, reason;
int ret = rh->install("existing_int_type", "int", description, dependent, reason);
assert(ret == 0);
}
void Admintest::test_SetOperation_no_id()
{
Atlas::Objects::Operation::Set op;
OpVector res;
Anonymous arg;
arg->setObjtype("obj");
op->setArgs1(arg);
m_account->SetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
}
void Admintest::test_GetOperation_unknown()
{
Atlas::Objects::Operation::Get op;
OpVector res;
Anonymous arg;
arg->setObjtype("unknownobjtype");
arg->setId("1741");
op->setArgs1(arg);
m_account->GetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
}
void Admintest::test_GetOperation_obj_unconnected()
{
m_account->m_connection = 0;
Atlas::Objects::Operation::Get op;
OpVector res;
Anonymous arg;
arg->setObjtype("obj");
arg->setId("9287");
op->setArgs1(arg);
m_account->GetOperation(op, res);
ASSERT_EQUAL(res.size(), 0u);
}
void Admintest::test_SetOperation_unknown()
{
Atlas::Objects::Operation::Set op;
OpVector res;
Anonymous arg;
arg->setObjtype("unimportant_unknown_string");
arg->setId("root");
op->setArgs1(arg);
m_account->SetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
}
void Admintest::test_SetOperation_rule_unknown()
{
Ruleset_modifyRule_called = false;
Atlas::Objects::Operation::Set op;
OpVector res;
Anonymous arg;
arg->setObjtype("class");
arg->setId("unimportant_unmatched_string");
op->setArgs1(arg);
m_account->SetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
ASSERT_TRUE(!Ruleset_modifyRule_called);
}
void Admintest::test_SetOperation_rule_fail()
{
Ruleset_modifyRule_called = false;
Ruleset_modifyRule_retval = -1;
Atlas::Objects::Operation::Set op;
OpVector res;
Anonymous arg;
arg->setObjtype("class");
arg->setId("root");
op->setArgs1(arg);
m_account->SetOperation(op, res);
ASSERT_EQUAL(res.size(), 1u);
ASSERT_EQUAL(res.front()->getClassNo(),
Atlas::Objects::Operation::ERROR_NO);
ASSERT_TRUE(Ruleset_modifyRule_called);
}
void Admintest::test_SetOperation_obj_not_found()
{
Account_SetOperation_called = 0;
long cid = m_id_counter++;
Atlas::Objects::Operation::Set op;
OpVector res;
Anonymous arg;
arg->setObjtype("obj");
arg->setId(compose("%1", cid));
op->setArgs1(arg);
m_account->SetOperation(op, res);
ASSERT_NULL(Account_SetOperation_called);
// FIXME No error? Is that right?
ASSERT_EQUAL(res.size(), 0u);
}
int main()
{
EntityBuilder::init();
{
RuleHandler * rh = new EntityRuleHandler(EntityBuilder::instance());
delete rh;
}
// check() not a class
{
RuleHandler * rh = new EntityRuleHandler(EntityBuilder::instance());
Anonymous description;
description->setParents(std::list<std::string>(1, "foo"));
int ret = rh->check(description);
assert(ret == -1);
delete rh;
}
// check() stub says it's a task
{
RuleHandler * rh = new EntityRuleHandler(EntityBuilder::instance());
stub_isTask_result = true;
Anonymous description;
description->setObjtype("class");
description->setParents(std::list<std::string>(1, "foo"));
int ret = rh->check(description);
assert(ret == -1);
stub_isTask_result = false;
delete rh;
}
// check() stub says it's not a task
{
RuleHandler * rh = new EntityRuleHandler(EntityBuilder::instance());
Anonymous description;
description->setObjtype("class");
description->setParents(std::list<std::string>(1, "foo"));
int ret = rh->check(description);
assert(ret == 0);
delete rh;
}
{
RuleHandler * rh = new EntityRuleHandler(EntityBuilder::instance());
Anonymous description;
description->setId("class_name");
std::string dependent, reason;
int ret = rh->install("class_name", "parent_name",
description, dependent, reason);
assert(ret == 1);
assert(dependent == "parent_name");
delete rh;
}
// Install a rule with addChild rigged to give a correct result
{
RuleHandler * rh = new EntityRuleHandler(EntityBuilder::instance());
Anonymous description;
description->setId("class_name");
std::string dependent, reason;
stub_addChild_result = (TypeNode *) malloc(sizeof(TypeNode));
int ret = rh->install("class_name", "parent_name",
description, dependent, reason);
assert(ret == 1);
assert(dependent == "parent_name");
free(stub_addChild_result);
stub_addChild_result = 0;
delete rh;
}
{
RuleHandler * rh = new EntityRuleHandler(EntityBuilder::instance());
Anonymous description;
int ret = rh->update("", description);
// FIXME Currently does nothing
assert(ret == -1);
delete rh;
}
}
int main()
{
EntityBuilder eb;
{
RuleHandler * rh = new EntityRuleHandler(&eb);
delete rh;
}
// check() not a class
{
RuleHandler * rh = new EntityRuleHandler(&eb);
Anonymous description;
description->setParent("foo");
int ret = rh->check(description);
assert(ret == -1);
delete rh;
}
// check() stub says it's not a task
{
RuleHandler * rh = new EntityRuleHandler(&eb);
Anonymous description;
description->setObjtype("class");
description->setParent("foo");
int ret = rh->check(description);
assert(ret == 0);
delete rh;
}
{
RuleHandler * rh = new EntityRuleHandler(&eb);
std::map<const TypeNode*, TypeNode::PropertiesUpdate> changes;
Anonymous description;
description->setId("class_name");
std::string dependent, reason;
int ret = rh->install("class_name", "parent_name",
description, dependent, reason, changes);
assert(ret == 1);
assert(dependent == "parent_name");
delete rh;
}
// Install a rule with addChild rigged to give a correct result
{
RuleHandler * rh = new EntityRuleHandler(&eb);
std::map<const TypeNode*, TypeNode::PropertiesUpdate> changes;
Anonymous description;
description->setId("class_name");
std::string dependent, reason;
stub_addChild_result = (TypeNode *) malloc(sizeof(TypeNode));
int ret = rh->install("class_name", "parent_name",
description, dependent, reason, changes);
assert(ret == 1);
assert(dependent == "parent_name");
free(stub_addChild_result);
stub_addChild_result = 0;
delete rh;
}
{
RuleHandler * rh = new EntityRuleHandler(&eb);
std::map<const TypeNode*, TypeNode::PropertiesUpdate> changes;
Anonymous description;
int ret = rh->update("", description, changes);
// FIXME Currently does nothing
assert(ret == -1);
delete rh;
}
}
void Interactive::exec(const std::string & cmd, const std::string & arg)
{
bool reply_expected = true;
reply_flag = false;
error_flag = false;
boost::shared_ptr<ObjectContext> command_context = m_currentContext.lock();
if (!command_context) {
std::cout << "ERROR: Context free" << std::endl << std::flush;
return;
}
if (cmd == "stat") {
Get g;
send(g);
} else if (cmd == "install") {
size_t space = arg.find(' ');
if (space == std::string::npos || space >= (arg.size() - 1)) {
std::cout << "usage: install <type id> <parent id>"
<< std::endl << std::flush;
} else {
Create c;
c->setFrom(m_accountId);
Anonymous ent;
ent->setId(std::string(arg, 0, space));
ent->setObjtype("class");
ent->setParents(std::list<std::string>(1, std::string(arg, space + 1)));
c->setArgs1(ent);
send(c);
}
reply_expected = false;
} else if (cmd == "look") {
Look l;
if (!arg.empty()) {
Anonymous cmap;
cmap->setId(arg);
l->setArgs1(cmap);
}
l->setSerialno(newSerialNo());
command_context->setFromContext(l);
send(l);
reply_expected = false;
} else if (cmd == "logout") {
Logout l;
l->setFrom(m_accountId);
if (!arg.empty()) {
Anonymous lmap;
lmap->setId(arg);
l->setArgs1(lmap);
reply_expected = false;
}
send(l);
} else if (cmd == "say") {
Talk t;
Anonymous ent;
ent->setAttr("say", arg);
t->setArgs1(ent);
t->setFrom(m_accountId);
send(t);
} else if (cmd == "help" || cmd == "?") {
reply_expected = false;
help();
} else if (cmd == "query") {
Get g;
if (!arg.empty()) {
Anonymous cmap;
if (::isdigit(arg[0])) {
cmap->setObjtype("obj");
} else {
cmap->setObjtype("meta");
}
cmap->setId(arg);
g->setArgs1(cmap);
}
g->setFrom(m_accountId);
send(g);
} else if (cmd == "reload") {
if (arg.empty()) {
reply_expected = false;
std::cout << "reload: Argument required" << std::endl << std::flush;
} else {
Set s;
Anonymous tmap;
tmap->setObjtype("class");
tmap->setId(arg);
s->setArgs1(tmap);
s->setFrom(m_accountId);
send(s);
}
} else if (cmd == "get") {
Get g;
if (!arg.empty()) {
Anonymous cmap;
if (::isdigit(arg[0])) {
cmap->setObjtype("obj");
} else {
cmap->setObjtype("meta");
}
cmap->setId(arg);
g->setArgs1(cmap);
}
g->setFrom(m_accountId);
send(g);
} else if (cmd == "monitor") {
ClientTask * task = new OperationMonitor;
if (runTask(task, arg) == 0) {
Monitor m;
m->setArgs1(Anonymous());
m->setFrom(m_accountId);
send(m);
}
reply_expected = false;
} else if (cmd == "unmonitor") {
OperationMonitor * om = dynamic_cast<OperationMonitor *>(m_currentTask);
if (om != 0) {
Monitor m;
m->setFrom(m_accountId);
send(m);
reply_expected = false;
SystemTime now;
now.update();
time_t monitor_time = now.seconds() - om->startTime();
std::cout << om->count() << " operations monitored in "
<< monitor_time << " seconds = "
<< om->count() / monitor_time
<< " operations per second"
<< std::endl << std::flush;
endTask();
}
} else if (cmd == "connect") {
std::vector<std::string> args;
tokenize(arg, args);
if (args.size() != 2) {
std::cout << "usage: connect <hostname> <port>"
<< std::endl << std::flush;
reply_expected = false;
} else {
Anonymous cmap;
cmap->setAttr("hostname", args[0]);
cmap->setAttr("port", strtol(args[1].c_str(), 0, 10));
Connect m;
m->setArgs1(cmap);
// No serialno yet
// FIXME add serialno once Juncture context can handle this
command_context->setFromContext(m);
send(m);
}
} else if (cmd == "add_agent") {
std::string agent_type("creator");
if (!arg.empty()) {
agent_type = arg;
}
Create c;
Anonymous cmap;
cmap->setParents(std::list<std::string>(1, agent_type));
cmap->setName("cycmd agent");
cmap->setObjtype("obj");
c->setArgs1(cmap);
c->setSerialno(newSerialNo());
command_context->setFromContext(c);
send(c);
} else if (cmd == "delete") {
if (arg.empty()) {
std::cout << "Please specify the entity to delete" << std::endl << std::flush;
reply_expected = false;
} else {
Delete del;
Anonymous del_arg;
del_arg->setId(arg);
del->setArgs1(del_arg);
command_context->setFromContext(del);
send(del);
reply_expected = false;
}
} else if (cmd == "find_by_name") {
if (arg.empty()) {
std::cout << "Please specify the name to search for" << std::endl << std::flush;
reply_expected = false;
} else {
Look l;
Anonymous lmap;
lmap->setName(arg);
l->setArgs1(lmap);
l->setSerialno(newSerialNo());
command_context->setFromContext(l);
send(l);
reply_expected = false;
}
} else if (cmd == "find_by_type") {
if (arg.empty()) {
std::cout << "Please specify the type to search for" << std::endl << std::flush;
reply_expected = false;
} else {
Look l;
Anonymous lmap;
lmap->setParents(std::list<std::string>(1, arg));
l->setArgs1(lmap);
l->setSerialno(newSerialNo());
command_context->setFromContext(l);
send(l);
reply_expected = false;
}
} else if (cmd == "flush") {
if (arg.empty()) {
// FIXME usage
std::cout << "Please specify the type to flush" << std::endl << std::flush;
reply_expected = false;
} else {
ClientTask * task = new Flusher(command_context);
runTask(task, arg);
reply_expected = false;
}
} else if (cmd == "cancel") {
if (endTask() != 0) {
std::cout << "No task currently running" << std::endl << std::flush;
}
} else if (cmd == "dump") {
if (command_context->repr() != "avatar") {
std::cout << "You must have an agent in the world in order to dump the world." << std::endl << std::flush;
} else {
//Extract the avatar id by "misusing" the setFromContext method
Operation op;
command_context->setFromContext(op);
ClientTask * task = new EntityExporter(m_accountId, op->getFrom());
runTask(task, "world.xml");
reply_expected = false;
}
} else if (cmd == "restore") {
if (command_context->repr() != "avatar") {
std::cout << "You must have an agent in the world in order to dump the world." << std::endl << std::flush;
} else {
//Extract the avatar id by "misusing" the setFromContext method
Operation op;
command_context->setFromContext(op);
ClientTask * task = new EntityImporter(m_accountId, op->getFrom());
runTask(task, "world.xml");
reply_expected = false;
}
} else if (cmd == "create") {
std::vector<std::string> args;
tokenize(arg, args);
if (args.size() < 1) {
std::cout << "usage: create <type> <params> ... "
<< std::endl << std::flush;
} else {
Anonymous cmap;
cmap->setParents(std::list<std::string>(1, args[0]));
cmap->setObjtype("obj");
Create c;
c->setArgs1(cmap);
c->setSerialno(newSerialNo());
command_context->setFromContext(c);
send(c);
}
reply_expected = false;
} else if (cmd == "login") {
std::vector<std::string> args;
tokenize(arg, args);
if (args.size() != 2) {
std::cout << "usage: login <username> <password>"
<< std::endl << std::flush;
reply_expected = false;
} else {
Anonymous cmap;
cmap->setAttr("username", args[0]);
cmap->setAttr("password", args[1]);
Login m;
m->setArgs1(cmap);
m->setSerialno(newSerialNo());
command_context->setFromContext(m);
send(m);
}
} else {
reply_expected = false;
std::cout << cmd << ": Command not known" << std::endl << std::flush;
}
if (!reply_expected) {
updatePrompt();
return;
}
// Wait for reply
time_t wait_start_time = time(NULL);
while (!reply_flag) {
if (time(NULL) - wait_start_time > 5) {
std::cout << cmd << ": No reply from server" << std::endl << std::flush;
return;
}
if (select(false) != 0) {
return;
}
}
}
