//-------------------------------------------------------------------------------------
PyObject* RemoteEntityMethod::tp_call(PyObject* self, PyObject* args,
PyObject* kwds)
{
RemoteEntityMethod* rmethod = static_cast<RemoteEntityMethod*>(self);
MethodDescription* methodDescription = rmethod->getDescription();
EntityMailboxAbstract* mailbox = rmethod->getMailbox();
// DEBUG_MSG(boost::format("RemoteEntityMethod::tp_call:%1%.\n") % methodDescription->getName());
if(methodDescription->checkArgs(args))
{
Mercury::Bundle* pBundle = Mercury::Bundle::ObjPool().createObject();
mailbox->newMail((*pBundle));
MemoryStream mstream;
methodDescription->addToStream(&mstream, args);
if(mstream.wpos() > 0)
(*pBundle).append(mstream.data(), mstream.wpos());
mailbox->postMail((*pBundle));
Mercury::Bundle::ObjPool().reclaimObject(pBundle);
}
else
{
ERROR_MSG(boost::format("RemoteEntityMethod::tp_call:%1% checkArgs is error!\n") %
methodDescription->getName());
}
S_Return;
}
//-------------------------------------------------------------------------------------
PyObject* RemoteEntityMethod::tp_call(PyObject* self, PyObject* args,
PyObject* kwds)
{
RemoteEntityMethod* rmethod = static_cast<RemoteEntityMethod*>(self);
MethodDescription* methodDescription = rmethod->getDescription();
EntityMailboxAbstract* mailbox = rmethod->getMailbox();
// DEBUG_MSG(fmt::format("RemoteEntityMethod::tp_call:{}.\n"), methodDescription->getName()));
if(methodDescription->checkArgs(args))
{
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
mailbox->newMail((*pBundle));
MemoryStream mstream;
methodDescription->addToStream(&mstream, args);
if(mstream.wpos() > 0)
(*pBundle).append(mstream.data(), mstream.wpos());
mailbox->postMail(pBundle);
}
else
{
ERROR_MSG(fmt::format("RemoteEntityMethod::tp_call:{} checkArgs error!\n",
methodDescription->getName()));
}
S_Return;
}
//-------------------------------------------------------------------------------------
PyObject* BaseRemoteMethod::tp_call(PyObject* self, PyObject* args,
PyObject* kwds)
{
BaseRemoteMethod* rmethod = static_cast<BaseRemoteMethod*>(self);
MethodDescription* methodDescription = rmethod->getDescription();
EntityMailboxAbstract* mailbox = rmethod->getMailbox();
if(!mailbox->isClient())
{
return RemoteEntityMethod::tp_call(self, args, kwds);
}
Base* pEntity = Baseapp::getSingleton().findEntity(mailbox->id());
if(pEntity == NULL)
{
//WARNING_MSG(fmt::format("BaseRemoteMethod::callClientMethod: not found entity({}).\n",
// mailbox->id()));
return RemoteEntityMethod::tp_call(self, args, kwds);
}
// 如果是调用客户端方法， 我们记录事件并且记录带宽
if(methodDescription->checkArgs(args))
{
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
mailbox->newMail((*pBundle));
MemoryStream* mstream = MemoryStream::ObjPool().createObject();
methodDescription->addToStream(mstream, args);
if(mstream->wpos() > 0)
(*pBundle).append(mstream->data(), mstream->wpos());
// 记录这个事件产生的数据量大小
g_privateClientEventHistoryStats.trackEvent(pEntity->scriptName(),
methodDescription->getName(),
pBundle->currMsgLength(),
"::");
static_cast<Proxy*>(pEntity)->sendToClient(ClientInterface::onRemoteMethodCall, pBundle);
//Network::Bundle::ObjPool().reclaimObject(pBundle);
MemoryStream::ObjPool().reclaimObject(mstream);
}
S_Return;
}
//-------------------------------------------------------------------------------------
PyObject* EntityMailboxAbstract::__py_reduce_ex__(PyObject* self, PyObject* protocol)
{
EntityMailboxAbstract* emailbox = static_cast<EntityMailboxAbstract*>(self);
PyObject* args = PyTuple_New(2);
PyObject* unpickleMethod = script::Pickler::getUnpickleFunc("Mailbox");
PyTuple_SET_ITEM(args, 0, unpickleMethod);
PyObject* args1 = PyTuple_New(4);
PyTuple_SET_ITEM(args1, 0, PyLong_FromUnsignedLong(emailbox->getID()));
PyTuple_SET_ITEM(args1, 1, PyLong_FromUnsignedLongLong(emailbox->getComponentID()));
PyTuple_SET_ITEM(args1, 2, PyLong_FromUnsignedLong(emailbox->getUType()));
PyTuple_SET_ITEM(args1, 3, PyLong_FromUnsignedLong(emailbox->getType()));
PyTuple_SET_ITEM(args, 1, args1);
if(unpickleMethod == NULL){
Py_DECREF(args);
return NULL;
}
return args;
}
//-------------------------------------------------------------------------------------
PyObject* Base::createCellEntity(PyObject* pyobj)
{
if(isDestroyed())
{
PyErr_Format(PyExc_Exception, "%s::createCellEntity: %d is destroyed!\n",
getScriptName(), getID());
PyErr_PrintEx(0);
S_Return;
}
if(Baseapp::getSingleton().findEntity(getID()) == NULL)
{
PyErr_Format(PyExc_Exception, "%s::createCellEntity: %d not found!\n", getScriptName(), getID());
PyErr_PrintEx(0);
S_Return;
}
if(creatingCell_ || this->getCellMailbox())
{
PyErr_Format(PyExc_Exception, "%s::createCellEntity: %d has a cell!\n", getScriptName(), getID());
PyErr_PrintEx(0);
S_Return;
}
if(!PyObject_TypeCheck(pyobj, EntityMailbox::getScriptType()))
{
PyErr_Format(PyExc_TypeError, "create %s arg1 is not cellMailbox!", this->getScriptName());
PyErr_PrintEx(0);
S_Return;
}
EntityMailboxAbstract* cellMailbox = static_cast<EntityMailboxAbstract*>(pyobj);
if(cellMailbox->getType() != MAILBOX_TYPE_CELL)
{
PyErr_Format(PyExc_TypeError, "create %s args1 not is a direct cellMailbox!", this->getScriptName());
PyErr_PrintEx(0);
S_Return;
}
creatingCell_ = true;
Baseapp::getSingleton().createCellEntity(cellMailbox, this);
S_Return;
}
//-------------------------------------------------------------------------------------
PyObject* EntityRemoteMethod::tp_call(PyObject* self, PyObject* args,
PyObject* kwds)
{
EntityRemoteMethod* rmethod = static_cast<EntityRemoteMethod*>(self);
MethodDescription* methodDescription = rmethod->getDescription();
EntityMailboxAbstract* mailbox = rmethod->getMailbox();
if(!mailbox->isClient())
{
return RemoteEntityMethod::tp_call(self, args, kwds);
}
Entity* pEntity = Cellapp::getSingleton().findEntity(mailbox->id());
if(pEntity == NULL || pEntity->pWitness() == NULL)
{
//WARNING_MSG(fmt::format("EntityRemoteMethod::callClientMethod: not found entity({}).\n",
// mailbox->id()));
return RemoteEntityMethod::tp_call(self, args, kwds);
}
Network::Channel* pChannel = pEntity->pWitness()->pChannel();
if(!pChannel)
{
PyErr_Format(PyExc_AssertionError, "%s:EntityRemoteMethod(%s)::tp_call: no client, srcEntityID(%d).\n",
pEntity->scriptName(), methodDescription->getName(), pEntity->id());
PyErr_PrintEx(0);
return RemoteEntityMethod::tp_call(self, args, kwds);
}
// 如果是调用客户端方法， 我们记录事件并且记录带宽
if(methodDescription->checkArgs(args))
{
Network::Bundle* pBundle = pChannel->createSendBundle();
mailbox->newMail((*pBundle));
MemoryStream* mstream = MemoryStream::createPoolObject();
methodDescription->addToStream(mstream, args);
if(mstream->wpos() > 0)
(*pBundle).append(mstream->data(), (int)mstream->wpos());
if(Network::g_trace_packet > 0)
{
if(Network::g_trace_packet_use_logfile)
DebugHelper::getSingleton().changeLogger("packetlogs");
DEBUG_MSG(fmt::format("EntityRemoteMethod::tp_call: pushUpdateData: ClientInterface::onRemoteMethodCall({}::{})\n",
pEntity->scriptName(), methodDescription->getName()));
switch(Network::g_trace_packet)
{
case 1:
mstream->hexlike();
break;
case 2:
mstream->textlike();
break;
default:
mstream->print_storage();
break;
};
if(Network::g_trace_packet_use_logfile)
DebugHelper::getSingleton().changeLogger(COMPONENT_NAME_EX(g_componentType));
}
// 记录这个事件产生的数据量大小
g_privateClientEventHistoryStats.trackEvent(pEntity->scriptName(),
methodDescription->getName(),
pBundle->currMsgLength(),
"::");
pEntity->pWitness()->sendToClient(ClientInterface::onRemoteMethodCall, pBundle);
MemoryStream::reclaimPoolObject(mstream);
}
S_Return;
}
