void ConnectedAdapter::setAttributes(Eris::Entity* entity, Atlas::Message::MapType& elements)
{
try {
Atlas::Objects::Entity::Anonymous what;
what->setId(entity->getId());
//We'll use this flag to make sure that nothing gets sent in the case that the only thing changed was immutable attributes (like "pos").
bool areAttributesToSend = false;
for (Atlas::Message::MapType::iterator I = elements.begin(); I != elements.end(); ++I) {
//The "pos" attribute is immutable and cannot be altered by a "set" op. Instead we must use a "move" op.
if (I->first == "pos") {
place(entity, entity->getLocation(), WFMath::Point<3>(I->second));
} else {
what->setAttr(I->first, I->second);
areAttributesToSend = true;
}
}
if (areAttributesToSend) {
Atlas::Objects::Operation::Set setOp;
setOp->setFrom(mAvatar.getEntity()->getId());
//setOp->setTo(entity->getId());
setOp->setArgs1(what);
S_LOG_INFO("Setting attributes of entity with id " << entity->getId() << ", named " << entity->getName());
mConnection.send(setOp);
}
} catch (const std::exception& ex) {
S_LOG_WARNING("Got error on setting attributes on entity." << ex);
}
}
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 ConnectedAdapter::setTypeInfo(const Atlas::Objects::Root& typeInfo)
{
try {
Atlas::Objects::Operation::Set setOp;
setOp->setFrom(mAccount.getId());
setOp->setArgs1(typeInfo);
S_LOG_INFO("Sending updated type info data.");
mConnection.send(setOp);
} catch (const std::exception& ex) {
S_LOG_WARNING("Got error on sending updated type info data." << ex);
}
}
void Admintest::test_SetOperation_no_objtype()
{
Atlas::Objects::Operation::Set op;
OpVector res;
Anonymous arg;
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_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 EntityImporterBase::updateRule(const Root& existingDefinition, const Root& newDefinition, OpVector & res)
{
m_state = RULE_UPDATING;
Root updatedDefinition = newDefinition.copy();
//If the existing definition had any children that aren't part of the import, we should preserve those
std::list<std::string> existingChildren, newChildren;
extractChildren(existingDefinition, existingChildren);
extractChildren(newDefinition, newChildren);
for (auto& child : newChildren) {
existingChildren.remove(child);
}
for (auto& child : existingChildren) {
if (mPersistedRules.find(child) == mPersistedRules.end()) {
newChildren.push_back(child);
}
}
if (!newChildren.empty() && !existingChildren.empty()) {
Atlas::Message::ListType childrenElement;
for (auto& child : newChildren) {
childrenElement.emplace_back(child);
}
updatedDefinition->setAttr("children", childrenElement);
}
if (updatedDefinition->asMessage() != existingDefinition->asMessage()) {
S_LOG_INFO("Updating server rule '"<< updatedDefinition->getId() << "'.");
Atlas::Objects::Operation::Set setOp;
setOp->setFrom(mAccountId);
setOp->setArgs1(updatedDefinition);
setOp->setSerialno(newSerialNumber());
res.push_back(setOp);
} else {
mStats.rulesProcessedCount++;
EventProgress.emit();
S_LOG_VERBOSE("Not updating server rule '"<< updatedDefinition->getId() << "' as nothing is changed.");
walkRules(res);
}
}
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()
{
TestWorld world;
{
Entity e("2", 2);
ExternalMind em(e);
}
{
Entity e("2", 2);
TestExternalMind em(e);
em.test_deleteEntity("3");
}
// Purge with empty contains
{
Entity e("2", 2);
e.m_contains = new LocatedEntitySet;
TestExternalMind em(e);
em.test_purgeEntity(e);
}
// Purge with populated contains
{
Entity e("2", 2);
e.m_contains = new LocatedEntitySet;
e.m_contains->insert(new Entity("3", 3));
TestExternalMind em(e);
em.test_purgeEntity(e);
}
// Connect to nothing
{
Entity e("2", 2);
ExternalMind em(e);
em.linkUp(0);
}
// Connect to something
{
Entity e("2", 2);
ExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
}
// Connect to something, then disconnect
{
Entity e("2", 2);
ExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
em.linkUp(0);
}
// Connect to something, then check connection ID
{
Entity e("2", 2);
ExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
const std::string & id = em.connectionId();
assert(id == "4");
}
// Send a random operation
{
Entity e("2", 2);
TestExternalMind em(e);
em.test_setLossTime(BaseWorld::instance().getTime());
stub_baseworld_receieved_op = -1;
OpVector res;
em.operation(Atlas::Objects::Operation::RootOperation(), res);
assert(stub_baseworld_receieved_op == -1);
}
// Send a Delete operation
{
Entity e("2", 2);
TestExternalMind em(e);
em.test_setLossTime(BaseWorld::instance().getTime());
stub_baseworld_receieved_op = -1;
OpVector res;
em.operation(Atlas::Objects::Operation::Delete(), res);
assert(stub_baseworld_receieved_op == -1);
}
// Send a Delete operation to an ephemeral entity
{
Entity e("2", 2);
e.setFlags(entity_ephem);
TestExternalMind em(e);
em.test_setLossTime(BaseWorld::instance().getTime());
stub_baseworld_receieved_op = -1;
OpVector res;
em.operation(Atlas::Objects::Operation::Delete(), res);
assert(stub_baseworld_receieved_op == -1);
}
// Send a non Delete operation to an ephemeral entity
{
Entity e("2", 2);
e.setFlags(entity_ephem);
TestExternalMind em(e);
em.test_setLossTime(BaseWorld::instance().getTime());
stub_baseworld_receieved_op = -1;
OpVector res;
em.operation(Atlas::Objects::Operation::RootOperation(), res);
assert(stub_baseworld_receieved_op == Atlas::Objects::Operation::DELETE_NO);
}
// Send a random operation to something that has been recorded as
// disconnected for a while
{
Entity e("2", 2);
// FIXME hard code the expiry time here.
TestExternalMind em(e);
em.test_setLossTime(BaseWorld::instance().getTime() - 60*60 - 5);
stub_baseworld_receieved_op = -1;
OpVector res;
em.operation(Atlas::Objects::Operation::RootOperation(), res);
assert(stub_baseworld_receieved_op == Atlas::Objects::Operation::DELETE_NO);
}
// Send a random operation to a connected mind
{
Entity e("2", 2);
TestExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
stub_link_send_op = -1;
stub_link_send_count = 0;
OpVector res;
em.operation(Atlas::Objects::Operation::RootOperation(), res);
assert(stub_link_send_op == Atlas::Objects::Operation::ROOT_OPERATION_NO);
assert(stub_link_send_count == 1);
}
// Send a Sight operation to a connected mind
{
Entity e("2", 2);
TestExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
stub_link_send_op = -1;
stub_link_send_count = 0;
OpVector res;
em.operation(Atlas::Objects::Operation::Sight(), res);
assert(stub_link_send_op == Atlas::Objects::Operation::SIGHT_NO);
assert(stub_link_send_count == 1);
}
// Send a Sight(Set) of hungry operation to a connected mind
{
Entity e("2", 2);
TestExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
stub_link_send_op = -1;
stub_link_send_count = 0;
// A sight(set) of a starving entity
Atlas::Objects::Root arg;
arg->setAttr("status", 0.05);
arg->setId(e.getId());
Atlas::Objects::Operation::Set set;
set->setArgs1(arg);
Atlas::Objects::Operation::Sight op;
op->setArgs1(set);
// It should trigger an extra Sight(Imaginary)
OpVector res;
em.operation(op, res);
assert(stub_link_send_op == Atlas::Objects::Operation::SIGHT_NO);
assert(stub_link_send_count > 1);
}
// Send a Sight(Set) of starving operation to a connected mind
{
Entity e("2", 2);
TestExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
stub_link_send_op = -1;
stub_link_send_count = 0;
// A sight(set) of a starving entity
Atlas::Objects::Root arg;
arg->setAttr("status", 0.005);
arg->setId(e.getId());
Atlas::Objects::Operation::Set set;
set->setArgs1(arg);
Atlas::Objects::Operation::Sight op;
op->setArgs1(set);
// It should trigger an extra Sight(Imaginary)
OpVector res;
em.operation(op, res);
assert(stub_link_send_op == Atlas::Objects::Operation::SIGHT_NO);
assert(stub_link_send_count > 1);
}
return 0;
}