int pyllbc_Service::UnifyPreSubscribe(PyObject *preHandler, int flags)
{
if (_started)
{
pyllbc_SetError("service already started", LLBC_ERROR_INITED);
return LLBC_RTN_FAILED;
}
pyllbc_PacketHandler *wrapHandler = LLBC_New1(pyllbc_PacketHandler, 0);
if (wrapHandler->SetHandler(preHandler) != LLBC_RTN_OK)
{
LLBC_Delete(wrapHandler);
return LLBC_RTN_FAILED;
}
if (_unifyPreHandler)
{
pyllbc_SetError("repeat to unify pre-subscribe packet");
return LLBC_RTN_FAILED;
}
_unifyPreHandler = wrapHandler;
_llbcSvc->UnifyPreSubscribe(_cppFacade, &pyllbc_Facade::OnDataUnifyPreReceived);
return LLBC_RTN_OK;
}
int pyllbc_Service::PreSubscribe(int opcode, PyObject *preHandler, int flags)
{
if (_started)
{
pyllbc_SetError("service already started", LLBC_ERROR_INITED);
return LLBC_RTN_FAILED;
}
else if (_llbcSvcType == LLBC_IService::Raw && opcode != 0)
{
pyllbc_SetError("RAW type service could not pre-subscribe opcode != 0's packet", LLBC_ERROR_INVALID);
return LLBC_RTN_FAILED;
}
pyllbc_PacketHandler *wrapHandler = LLBC_New1(pyllbc_PacketHandler, opcode);
if (wrapHandler->SetHandler(preHandler) != LLBC_RTN_OK)
{
LLBC_Delete(wrapHandler);
return LLBC_RTN_FAILED;
}
if (!_preHandlers.insert(std::make_pair(opcode, wrapHandler)).second)
{
LLBC_Delete(wrapHandler);
LLBC_String err;
pyllbc_SetError(err.format(
"repeat to pre-subscribe opcode: %d, the opcode already pre-subscribed", opcode), LLBC_ERROR_REPEAT);
return LLBC_RTN_FAILED;
}
_llbcSvc->PreSubscribe(opcode, _cppFacade, &pyllbc_Facade::OnDataPreReceived);
return LLBC_RTN_OK;
}
void LLBC_IocpPoller::HandleEv_AsyncConn(LLBC_PollerEvent &ev)
{
bool succeed = true;
LLBC_String reason = "Success";
do {
LLBC_SocketHandle handle = LLBC_CreateTcpSocketEx();
if (handle == LLBC_INVALID_SOCKET_HANDLE)
{
succeed = false;
reason = LLBC_FormatLastError();
break;
}
LLBC_Socket *socket = LLBC_New1(LLBC_Socket, handle);
socket->SetNonBlocking();
socket->SetPollerType(LLBC_PollerType::IocpPoller);
if (socket->AttachToIocp(_iocp) != LLBC_OK)
{
LLBC_Delete(socket);
succeed = false;
reason = LLBC_FormatLastError();
break;
}
LLBC_POverlapped ol = LLBC_New(LLBC_Overlapped);
ol->opcode = LLBC_OverlappedOpcode::Connect;
ol->sock = handle;
if (socket->ConnectEx(ev.peerAddr, ol) != LLBC_OK &&
LLBC_GetLastError() != LLBC_ERROR_PENDING)
{
LLBC_Delete(ol);
LLBC_Delete(socket);
succeed = false;
reason = LLBC_FormatLastError();
break;
}
socket->InsertOverlapped(ol);
LLBC_AsyncConnInfo asyncInfo;
asyncInfo.socket = socket;
asyncInfo.peerAddr = ev.peerAddr;
asyncInfo.sessionId = ev.sessionId;
_connecting.insert(std::make_pair(handle, asyncInfo));
} while (false);
if (!succeed)
_svc->Push(LLBC_SvcEvUtil::
BuildAsyncConnResultEv(succeed, reason, ev.peerAddr));
}
void pyllbc_Service::CreateLLBCService(LLBC_IService::Type svcType)
{
ASSERT(!_llbcSvc && "llbc service pointer not NULL");
_llbcSvc = LLBC_IService::Create(svcType);
_llbcSvc->SetId(++This::_maxLLBCSvcId); // llbc library ServiceId we not use, so, let's simple set it.
_llbcSvc->SetDriveMode(LLBC_IService::ExternalDrive);
_llbcSvc->DisableTimerScheduler();
_cppFacade = LLBC_New1(pyllbc_Facade, this);
_llbcSvc->RegisterFacade(_cppFacade);
}
int LLBC_PacketHeaderParts::SetPart(int serialNo, const void *val, size_t valSize)
{
This::_Part part;
part.type = _PartTypes::BytesType;
part.value.bytesVal = LLBC_New1(LLBC_MessageBlock, valSize);
if (part.value.bytesVal->Write(val, valSize) != LLBC_OK)
{
This::CleanupPart(part);
return LLBC_FAILED;
}
SetConstructedPart(serialNo, part);
return LLBC_OK;
}
int pyllbc_Service::Subscribe(int opcode, PyObject *handler, int flags)
{
if (_started)
{
pyllbc_SetError("service already started", LLBC_ERROR_INITED);
return LLBC_RTN_FAILED;
}
else if (_llbcSvcType == LLBC_IService::Raw && opcode != 0)
{
pyllbc_SetError(LLBC_String().format(
"RAW type service could not subscribe opcode[%d] != 0's packet", opcode), LLBC_ERROR_INVALID);
return LLBC_RTN_FAILED;
}
_PacketHandlers::const_iterator it = _handlers.find(opcode);
if (it != _handlers.end())
{
const LLBC_String handlerDesc = pyllbc_ObjUtil::GetObjStr(handler);
LLBC_String err;
err.append_format("repeat to subscribeopcode: %d:%s, ", opcode, handlerDesc.c_str());
err.append_format("the opcode already subscribed by ");
err.append_format("%s", it->second->ToString().c_str());
pyllbc_SetError(err, LLBC_ERROR_REPEAT);
return LLBC_RTN_FAILED;
}
pyllbc_PacketHandler *wrapHandler = LLBC_New1(pyllbc_PacketHandler, opcode);
if (wrapHandler->SetHandler(handler) != LLBC_RTN_OK)
{
LLBC_Delete(wrapHandler);
return LLBC_RTN_FAILED;
}
_handlers.insert(std::make_pair(opcode, wrapHandler));
_llbcSvc->Subscribe(opcode, _cppFacade, &pyllbc_Facade::OnDataReceived);
return LLBC_RTN_OK;
}
__LLBC_NS_BEGIN
This *LLBC_IService::Create(Type type)
{
return LLBC_New1(LLBC_Service, type);
}
