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); }