bool EntityImporterBase::getEntity(const std::string & id, OpVector & res)
{
std::map<std::string, Root>::const_iterator I = mPersistedEntities.find(id);
if (I == mPersistedEntities.end()) {
S_LOG_VERBOSE("Could not find entity with id " << id << "; this one was probably transient.");
//This will often happen if the child entity was transient, and therefore wasn't exported (but is still references from the parent entity).
return false;
}
const RootEntity& obj = smart_dynamic_cast<RootEntity>(I->second);
if (!obj.isValid()) {
S_LOG_FAILURE("Corrupt dump - non entity found " << id << ".");
return false;
}
m_state = ENTITY_WALKING;
mTreeStack.emplace_back(obj);
Anonymous get_arg;
get_arg->setId(id);
get_arg->setObjtype("obj");
Get get;
get->setArgs1(get_arg);
get->setFrom(mAccountId);
get->setSerialno(newSerialNumber());
res.push_back(get);
S_LOG_VERBOSE("EntityImporterBase: Getting entity with id " << id);
return true;
}
bool test1Thread()
{
Put() = 42;
// dbg1();
for(auto& m: Get())
{
// std::cout << "m: " << m << std::endl;
// dbg1();
if(m != 42)
{
return false;
}
}
// dbg1();
Put() = 101;
// dbg1();
Put() = 202;
// dbg1();
{
Get g;
// dbg1();
D::Iterator b(g.begin());
D::Iterator e(g.end());
D::Msg m1 = *b++;
D::Msg m2 = *b++;
// std::cout << "m1: " << m1 << ", m2: " << m2 << std::endl;
// std::cout << "b: " << b << ", e: " << e << std::endl;
return m1 == 101 && m2 == 202 && b == e;
}
}
bool EntityImporterBase::getRule(const std::string & id, OpVector & res)
{
auto I = mPersistedRules.find(id);
if (I == mPersistedRules.end()) {
S_LOG_WARNING("Could not find rule with id " << id << ".");
return false;
}
auto definition = I->second;
m_state = RULE_WALKING;
std::list<std::string> children;
extractChildren(definition, children);
RuleStackEntry entry = { id, definition, children };
mRuleStack.push_back(entry);
Get get;
Anonymous arg;
arg->setId(id);
get->setArgs1(arg);
// get->setObjtype("op");
get->setSerialno(newSerialNumber());
res.push_back(get);
Anonymous get_arg;
get_arg->setId(id);
get_arg->setObjtype("obj");
return true;
}
void ClientConnection::processAnonymousGet(const Get& get)
{
const std::vector<Root>& args = get->getArgs();
if (args.empty())
{
Info serverInfo;
RootEntity svObj;
Atlas::Message::ListType prs;
prs.push_back("server");
svObj->setParentsAsList(prs);
svObj->setName("Bob's StubServer");
svObj->setAttr("server", "stubserver");
svObj->setAttr("ruleset", "stub-world");
svObj->setAttr("uptime", 666.0);
svObj->setAttr("clients", 42);
serverInfo->setArgs1(svObj);
send(serverInfo);
} else {
std::string typeName = args.front()->getId();
if (m_server->m_types.count(typeName))
{
Info typeInfo;
typeInfo->setArgs1(m_server->m_types[typeName]);
typeInfo->setRefno(get->getSerialno());
send(typeInfo);
} else
sendError("unknown type " + typeName, get);
}
}
void Accountintegration::test_GetOperation()
{
Anonymous op_arg;
op_arg->setParents(std::list<std::string>());
Get op;
op->setArgs1(op_arg);
OpVector res;
m_ac->operation(op, res);
}
void RuleTraversalTask::getRule(const std::string & id, OpVector & res)
{
Get get;
Anonymous arg;
arg->setId(id);
get->setArgs1(arg);
get->setObjtype("op");
get->setSerialno(newSerialNo());
mSerial = get->getSerialno();
res.push_back(get);
}
void Connection::refreshServerInfo()
{
if (_status != CONNECTED) {
warning() << "called refreshServerInfo while not connected, ignoring";
return;
}
m_info.setStatus(ServerInfo::QUERYING);
Get gt;
gt->setSerialno(getNewSerialno());
send(gt);
}
int main () {
// Redirect stdout to this stream, so that involuntary
// writes to stdout do not interfere with our protocol.
std::ostringstream oss;
stdout_redir = oss.rdbuf();
stdout_orig = std::cout.rdbuf();
std::cout.rdbuf(stdout_redir);
#ifdef SET_BINARY_STREAMS
_setmode(_fileno(stdout), _O_BINARY);
std::cout.setf(std::ios_base::binary);
_setmode(_fileno(stdin), _O_BINARY);
std::cin.setf(std::ios_base::binary);
#endif
bool has_more = false;
IfcGeom::Iterator<float>* iterator = 0;
Hello().write(std::cout);
int exit_code = 0;
for (;;) {
const int32_t msg_type = sread<int32_t>(std::cin);
switch (msg_type) {
case IFC_MODEL: {
IfcModel m; m.read(std::cin);
std::string::size_type len = m.string().size();
char* data = new char[len];
memcpy(data, m.string().c_str(), len);
IfcGeom::IteratorSettings settings;
settings.set(IfcGeom::IteratorSettings::USE_WORLD_COORDS, false);
settings.set(IfcGeom::IteratorSettings::WELD_VERTICES, false);
settings.set(IfcGeom::IteratorSettings::CONVERT_BACK_UNITS, true);
settings.set(IfcGeom::IteratorSettings::INCLUDE_CURVES, true);
iterator = new IfcGeom::Iterator<float>(settings, data, (int)len);
has_more = iterator->initialize();
More(has_more).write(std::cout);
continue;
}
case GET: {
Get g; g.read(std::cin);
if (!has_more) {
exit_code = 1;
break;
}
const IfcGeom::TriangulationElement<float>* geom = static_cast<const IfcGeom::TriangulationElement<float>*>(iterator->get());
Entity(geom).write(std::cout);
continue;
}
case NEXT: {
Next n; n.read(std::cin);
has_more = iterator->next();
if (!has_more) {
delete iterator;
iterator = 0;
}
More(has_more).write(std::cout);
continue;
}
case GET_LOG: {
GetLog gl; gl.read(std::cin);
WriteLog(iterator->getLog()).write(std::cout);
continue;
}
case BYE: {
Bye().write(std::cout);
exit_code = 0;
break;
}
default:
exit_code = 1;
break;
}
break;
}
std::cout.rdbuf(stdout_orig);
return exit_code;
}
int main()
{
// WorldRouter world;
// Entity & e = world.m_gameWorld;
ServerRouting server(*(BaseWorld*)0, "noruleset", "unittesting",
"1", 1, "2", 2);
CommServer commServer(server);
TestCommClient * tcc = new TestCommClient(commServer);
TestConnection * tc = new TestConnection(*tcc, server, "addr", "3", 3);
Account * ac = tc->testAddAccount("bob", "foo");
assert(ac != 0);
ac = tc->testRemoveAccount(ac);
assert(ac != 0);
tc->removeObject(ac);
assert(tc->numObjects() == 0);
{
Create op;
OpVector res;
tc->operation(op, res);
op->setArgs1(Root());
tc->operation(op, res);
restricted_flag = true;
tc->operation(op, res);
restricted_flag = false;
Anonymous op_arg;
op->setArgs1(op_arg);
tc->operation(op, res);
op_arg->setId("jim");
// Legacy op
tc->operation(op, res);
op_arg->setAttr("username", 1);
// Malformed username
tc->operation(op, res);
op_arg->setAttr("username", "jim");
// username, no password
tc->operation(op, res);
op_arg->setAttr("password", "");
// zero length password
tc->operation(op, res);
op_arg->setAttr("username", "");
op_arg->setAttr("password", "foo");
// zero length username
tc->operation(op, res);
op_arg->setAttr("username", "jim");
// valid username and password
tc->operation(op, res);
assert(tc->numObjects() != 0);
}
{
Login op;
OpVector res;
tc->operation(op, res);
op->setArgs1(Root());
tc->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
tc->operation(op, res);
op_arg->setId("bob");
tc->operation(op, res);
op_arg->setAttr("username", 1);
tc->operation(op, res);
op_arg->setAttr("username", "");
tc->operation(op, res);
op_arg->setAttr("username", "bob");
tc->operation(op, res);
op_arg->setAttr("password", "foo");
tc->operation(op, res);
tc->operation(op, res);
}
{
Get op;
OpVector res;
tc->operation(op, res);
Root op_arg;
op->setArgs1(op_arg);
tc->operation(op, res);
op_arg->setId("1");
tc->operation(op, res);
op_arg->setId("game_entity");
tc->operation(op, res);
}
{
Logout op;
OpVector res;
tc->operation(op, res);
op->setSerialno(24);
tc->operation(op, res);
Root op_arg;
op->setArgs1(op_arg);
tc->operation(op, res);
op_arg->setId("-1");
tc->operation(op, res);
op_arg->setId("23");
tc->operation(op, res);
// How to determine the real ID?
const RouterMap rm = tc->getObjects();
RouterMap::const_iterator I = rm.begin();
for (;I != rm.end(); ++I) {
std::string object_id = String::compose("%1", I->first);
std::cout << "ID: " << object_id << std::endl;
op_arg->setId(object_id);
tc->operation(op, res);
}
}
delete tc;
}
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;
}
}
}
int main()
{
database_flag = false;
(void)new Domain;
WorldRouter world;
Entity & e = world.m_gameWorld;
ServerRouting server(world, "noruleset", "unittesting",
"1", 1, "2", 2);
CommServer commServer(server);
TestCommClient * tc = new TestCommClient(commServer);
Connection * c = new Connection(*tc, server, "addr", "3", 3);
TestAccount * ac = new TestAccount(c, "user", "password", "4", 4);
Entity * chr;
{
chr = new Entity("5", 5);
chr->m_location.m_loc = &e;
chr->m_location.m_loc->makeContainer();
assert(chr->m_location.m_loc->m_contains != 0);
chr->m_location.m_loc->m_contains->insert(chr);
ac->addCharacter(chr);
chr->destroy();
}
{
chr = new Character("6", 6);
chr->m_location.m_loc = &e;
chr->m_location.m_loc->makeContainer();
assert(chr->m_location.m_loc->m_contains != 0);
chr->m_location.m_loc->m_contains->insert(chr);
ac->addCharacter(chr);
chr->destroy();
}
{
chr = new Character("7", 7);
chr->m_location.m_loc = &e;
chr->m_location.m_loc->makeContainer();
assert(chr->m_location.m_loc->m_contains != 0);
chr->m_location.m_loc->m_contains->insert(chr);
ac->addCharacter(chr);
}
{
Anonymous new_char;
Entity * chr = ac->testAddNewCharacter("thing", new_char,
RootEntity());
assert(chr != 0);
}
ac->getType();
{
MapType emap;
ac->addToMessage(emap);
}
{
RootEntity ent;
ac->addToEntity(ent);
}
{
Create op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
op_arg->setParents(std::list<std::string>(1, "game_entity"));
ac->operation(op, res);
op_arg->setName("Bob");
ac->operation(op, res);
}
{
Get op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
}
{
Imaginary op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
op->setSerialno(1);
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setLoc("2");
ac->operation(op, res);
}
{
Look op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setId("1");
ac->operation(op, res);
op_arg->setId(chr->getId());
ac->operation(op, res);
}
{
Set op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setId("1");
ac->operation(op, res);
op_arg->setId(chr->getId());
ac->operation(op, res);
op_arg->setAttr("guise", "foo");
ac->operation(op, res);
op_arg->setAttr("height", 3.0);
ac->operation(op, res);
BBox newBox(WFMath::Point<3>(-0.5, -0.5, 0.0),
WFMath::Point<3>(-0.5, -0.5, 2.0));
chr->m_location.setBBox(newBox);
op_arg->setAttr("height", 3.0);
ac->operation(op, res);
op_arg->setAttr("tasks", ListType());
ac->operation(op, res);
}
{
Talk op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
op->setSerialno(1);
ac->operation(op, res);
op_arg->setLoc("1");
ac->operation(op, res);
}
{
Logout op;
OpVector res;
ac->operation(op, res);
op->setSerialno(1);
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
}
{
// Move has no meaning
Move op;
OpVector res;
ac->operation(op, res);
op->setArgs1(Root());
ac->operation(op, res);
Anonymous op_arg;
op->setArgs1(op_arg);
ac->operation(op, res);
op_arg->setParents(std::list<std::string>());
ac->operation(op, res);
}
{
Entity e("7", 7);
int ret = ac->connectCharacter(&e);
assert(ret == -1);
}
{
Character e("8", 8);
int ret = ac->connectCharacter(&e);
assert(ret == 0);
}
delete ac;
return 0;
}