LocatedEntity * CreatorClient::make(const RootEntity & entity) { Create op; op->setArgs1(entity); op->setFrom(getId()); op->setTo(getId()); OpVector result; if (sendAndWaitReply(op, result) != 0) { std::cerr << "No reply to make" << std::endl << std::flush; return NULL; } assert(!result.empty()); const Operation & res = result.front(); if (!res.isValid()) { std::cerr << "NULL reply to make" << std::endl << std::flush; return NULL; } // FIXME Make this more robust against an info response if (res->getClassNo() == Atlas::Objects::Operation::SIGHT_NO) { if (res->getArgs().empty()) { std::cerr << "Reply to make has no args" << std::endl << std::flush; return NULL; } RootOperation arg = smart_dynamic_cast<RootOperation>(res->getArgs().front()); if (!arg.isValid()) { std::cerr << "Arg of reply to make is not an operation" << std::endl << std::flush; return NULL; } if (arg->getClassNo() != Atlas::Objects::Operation::CREATE_NO) { std::cerr << "Reply to make isn't sight of create" << std::endl << std::flush; return NULL; } return handleMakeResponse(arg, res->getSeconds()); } else if (res->getClassNo() == Atlas::Objects::Operation::INFO_NO) { return handleMakeResponse(res, res->getSeconds()); } else { std::cerr << "Reply to make isn't sight or info" << std::endl << std::flush; return NULL; } }
void EntityImporterBase::createEntity(const RootEntity & obj, OpVector & res) { ++mStats.entitiesProcessedCount; ++mStats.entitiesCreateCount; EventProgress.emit(); m_state = ENTITY_CREATING; assert(mTreeStack.size() > 1); std::deque<StackEntry>::reverse_iterator I = mTreeStack.rbegin(); ++I; assert(I != mTreeStack.rend()); const std::string & loc = I->restored_id; RootEntity create_arg = obj.copy(); create_arg->removeAttrFlag(Atlas::Objects::Entity::CONTAINS_FLAG); create_arg->removeAttrFlag(Atlas::Objects::Entity::VELOCITY_FLAG); create_arg->removeAttrFlag(Atlas::Objects::ID_FLAG); create_arg->setLoc(loc); //Remove any attribute which references another entity from the Create op. //This is because the attribute will at this time with certainty refer to the wrong or a non-existing entity. //The attribute will later on be set through a Set op in sendResolvedEntityReferences(). auto referenceMapEntryI = mEntitiesWithReferenceAttributes.find(obj->getId()); if (referenceMapEntryI != mEntitiesWithReferenceAttributes.end()) { for (const auto& attributeName : referenceMapEntryI->second) { create_arg->removeAttr(attributeName); } } Create create; create->setArgs1(create_arg); create->setFrom(mAvatarId); create->setSerialno(newSerialNumber()); mCreateEntityMapping.insert(std::make_pair(create->getSerialno(), obj->getId())); res.push_back(create); }
void EntityImporterBase::createEntity(const RootEntity & obj, OpVector & res) { ++mStats.entitiesProcessedCount; ++mStats.entitiesCreateCount; EventProgress.emit(); m_state = ENTITY_CREATING; assert(mTreeStack.size() > 1); auto I = mTreeStack.rbegin(); ++I; assert(I != mTreeStack.rend()); const std::string & loc = I->restored_id; RootEntity create_arg = obj.copy(); create_arg->removeAttrFlag(Atlas::Objects::Entity::CONTAINS_FLAG); create_arg->removeAttrFlag(Atlas::Objects::Entity::VELOCITY_FLAG); create_arg->removeAttrFlag(Atlas::Objects::ID_FLAG); create_arg->setLoc(loc); //Remove any attribute which references another entity from the Create op. //This is because the attribute will at this time with certainty refer to the wrong or a non-existing entity. //The attribute will later on be set through a Set op in sendResolvedEntityReferences(). auto referenceMapEntryI = mEntitiesWithReferenceAttributes.find(obj->getId()); if (referenceMapEntryI != mEntitiesWithReferenceAttributes.end()) { std::set<std::string> resolvedAttributes; for (const auto& referenceEntry : referenceMapEntryI->second) { size_t resolvedEntitiesCount = 0; //Check if all the referenced entities perhaps already have been created. for (const auto& entityId : referenceEntry.referencedEntities) { auto resolvedI = mEntityIdMap.find(entityId); if (resolvedI != mEntityIdMap.end()) { resolvedEntitiesCount++; } } //If all entities were resolved, we should resolve the property now. if (resolvedEntitiesCount == referenceEntry.referencedEntities.size()) { Element element = create_arg->getAttr(referenceEntry.propertyName); resolveEntityReferences(element); create_arg->setAttr(referenceEntry.propertyName, element); resolvedAttributes.insert(referenceEntry.propertyName); } else { create_arg->removeAttr(referenceEntry.propertyName); } } //Remove those attributes that were resolved if (resolvedAttributes.size() == referenceMapEntryI->second.size()) { //All attributes were resolved, remove the entry completely. mEntitiesWithReferenceAttributes.erase(referenceMapEntryI); } else { //Only remove those entries that were destroyed. std::vector<ReferencedEntry> copy; for (auto& referenceEntry : referenceMapEntryI->second) { if (resolvedAttributes.find(referenceEntry.propertyName) == resolvedAttributes.end()) { copy.push_back(std::move(referenceEntry)); } } referenceMapEntryI->second = std::move(copy); } } Create create; create->setArgs1(create_arg); create->setFrom(mAvatarId); create->setSerialno(newSerialNumber()); mCreateEntityMapping.insert(std::make_pair(create->getSerialno(), obj->getId())); res.push_back(create); }
/// \brief Teleport an entity to the connected peer /// /// @param ent The entity to be teleported /// @return Returns 0 on success and -1 on failure int Peer::teleportEntity(const Entity * ent) { if (m_state != PEER_AUTHENTICATED) { log(ERROR, "Peer not authenticated yet."); return -1; } long iid = ent->getIntId(); if (m_teleports.find(iid) != m_teleports.end()) { log(INFO, "Transfer of this entity already in progress"); return -1; } struct timeval timeVal; gettimeofday(&timeVal, NULL); time_t teleport_time = timeVal.tv_sec; // Add a teleport state object to identify this teleport request TeleportState * s = new TeleportState(teleport_time); if (s == NULL) { log(ERROR, "Unable to allocate teleport state object"); return -1; } // Check if the entity has a mind const Character * chr = dynamic_cast<const Character *>(ent); ExternalMind * mind = 0; if (chr != 0 && chr->m_externalMind != 0) { mind = dynamic_cast<ExternalMind*>(chr->m_externalMind); } Atlas::Objects::Entity::Anonymous atlas_repr; ent->addToEntity(atlas_repr); Create op; op->setFrom(m_accountId); op->setSerialno(iid); op->setArgs1(atlas_repr); if (mind != 0 && mind->isConnected()) { // Entities with a mind require an additional one-time possess key that // is used by the client to authenticate a teleport on the destination // peer std::string key; log(INFO, "Entity has a mind. Generating random key"); // FIXME non-random, plus potetial timing attack. WFMath::MTRand generator; for(int i=0;i<32;i++) { char ch = (char)((int)'a' + generator.rand(25)); key += ch; } s->setKey(key); // Add an additional possess key argument log(INFO, String::compose("Adding possess key %1 to Create op", key)); Anonymous key_arg; key_arg->setAttr("possess_key", key); std::vector<Root> & create_args = op->modifyArgs(); create_args.push_back(key_arg); } m_commClient.send(op); log(INFO, "Sent Create op to peer"); // Set it as validated and add to the list of teleports s->setRequested(); m_teleports[iid] = s; log(INFO, "Added new teleport state"); return 0; }
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; } } }
LocatedEntity * CreatorClient::make(const RootEntity & entity) { Create op; op->setArgs1(entity); op->setFrom(getId()); op->setTo(getId()); OpVector result; if (sendAndWaitReply(op, result) != 0) { std::cerr << "No reply to make" << std::endl << std::flush; return NULL; } assert(!result.empty()); const Operation & res = result.front(); if (!res.isValid()) { std::cerr << "NULL reply to make" << std::endl << std::flush; return NULL; } if (res->getClassNo() != Atlas::Objects::Operation::SIGHT_NO) { std::cerr << "Reply to make isn't sight" << std::endl << std::flush; return NULL; } if (res->getArgs().empty()) { std::cerr << "Reply to make has no args" << std::endl << std::flush; return NULL; } RootOperation arg = smart_dynamic_cast<RootOperation>(res->getArgs().front()); if (!arg.isValid()) { std::cerr << "Arg of reply to make is not an operation" << std::endl << std::flush; return NULL; } if (arg->getClassNo() != Atlas::Objects::Operation::CREATE_NO) { std::cerr << "Reply to make isn't sight of create" << std::endl << std::flush; return NULL; } if (arg->getArgs().empty()) { std::cerr << "Arg of reply to make has no args" << std::endl << std::flush; return NULL; } RootEntity created = smart_dynamic_cast<RootEntity>(arg->getArgs().front()); if (!created.isValid()) { std::cerr << "Created argument is not an entity" << std::endl << std::flush; return NULL; } if (!created->hasAttrFlag(Atlas::Objects::ID_FLAG)) { std::cerr << "Created entity has no id" << std::endl << std::flush; return NULL; } const std::string & created_id = created->getId(); if (created->getParents().empty()) { std::cerr << "Created entity " << created_id << " has no type" << std::endl << std::flush; return NULL; } const std::string & created_type = created->getParents().front(); std::cout << "Created: " << created_type << "(" << created_id << ")" << std::endl << std::flush; LocatedEntity * obj = m_map.updateAdd(created, res->getSeconds()); return obj; }