void pyllbc_Service::AfterStop()
{
_cppFacade = NULL;
// Recreate service.
LLBC_XDelete(_llbcSvc);
this->CreateLLBCService(_llbcSvcType);
// Cleanup all python layer facades.
for (_Facades::iterator it = _facades.begin();
it != _facades.end();
it++)
Py_DECREF(*it);
_facades.clear();
// Cleanup all python layer codecs.
for (_Codecs::iterator it = _codecs.begin();
it != _codecs.end();
it++)
Py_DECREF(it->second);
_codecs.clear();
// Cleanup all python layer handlers/prehandlers/unify_prehandlers(if enabled).
LLBC_STLHelper::DeleteContainer(_handlers);
LLBC_STLHelper::DeleteContainer(_preHandlers);
#if LLBC_CFG_COMM_ENABLE_UNIFY_PRESUBSCRIBE
LLBC_XDelete(_unifyPreHandler);
#endif // LLBC_CFG_COMM_ENABLE_UNIFY_PRESUBSCRIBE
// Destroy all frame callables.
_handledBeforeFrameCallables = false;
this->DestroyFrameCallables(_beforeFrameCallables, _handlingBeforeFrameCallables);
this->DestroyFrameCallables(_afterFrameCallables, _handlingAfterFrameCallables);
}
LLBC_Variant::Holder::~Holder()
{
if (type == LLBC_VariantType::VT_DICT_DFT)
{
LLBC_XDelete(dict);
}
}
int pyllbc_Service::Broadcast(int opcode, PyObject *data, int status, PyObject *parts)
{
// Started check.
if (UNLIKELY(!this->IsStarted()))
{
pyllbc_SetError("service not start");
return LLBC_RTN_FAILED;
}
// Build parts, if exists.
LLBC_PacketHeaderParts *cLayerParts = NULL;
if (parts && _llbcSvcType != LLBC_IService::Raw)
{
if (!(cLayerParts = this->BuildCLayerParts(parts)))
return LLBC_RTN_FAILED;
}
// Serialize python layer 'data' object to stream.
LLBC_Stream stream;
if (this->SerializePyObj2Stream(data, stream) != LLBC_RTN_OK)
{
LLBC_XDelete(cLayerParts);
return LLBC_RTN_FAILED;
}
// Send it.
const void *bytes = stream.GetBuf();
const size_t len = stream.GetPos();
return _llbcSvc->Broadcast2(opcode, bytes, len, status, cLayerParts);
}
void LLBC_Variant::OptimizePerformance()
{
if (IsDict())
{
if (_holder.dict && _holder.dict->empty())
{
LLBC_XDelete(_holder.dict);
}
}
}
int pyllbc_Service::Send(int sessionId, int opcode, PyObject *data, int status, PyObject *parts)
{
// Started check.
if (UNLIKELY(!this->IsStarted()))
{
pyllbc_SetError("service not start");
return LLBC_RTN_FAILED;
}
// Build parts, if exists.
LLBC_PacketHeaderParts *cLayerParts = NULL;
if (parts && _llbcSvcType != LLBC_IService::Raw)
{
if (!(cLayerParts = this->BuildCLayerParts(parts)))
return LLBC_RTN_FAILED;
}
// Serialize python layer 'data' object to stream.
LLBC_Stream stream;
const int ret = this->SerializePyObj2Stream(data, stream);
if (UNLIKELY(ret != LLBC_RTN_OK))
{
LLBC_XDelete(cLayerParts);
return LLBC_RTN_FAILED;
}
// Build packet & send.
LLBC_Packet *packet = LLBC_New(LLBC_Packet);
packet->Write(stream.GetBuf(), stream.GetPos());
packet->SetSessionId(sessionId);
if (_llbcSvcType != LLBC_IService::Raw)
{
packet->SetOpcode(opcode);
packet->SetStatus(status);
if (cLayerParts)
{
cLayerParts->SetToPacket(*packet);
LLBC_Delete(cLayerParts);
}
}
if (UNLIKELY(_llbcSvc->Send(packet) == LLBC_RTN_FAILED))
{
pyllbc_TransferLLBCError(__FILE__, __LINE__);
return LLBC_RTN_FAILED;
}
return LLBC_RTN_OK;
}
int LLBC_IocpPoller::StartupMonitor()
{
LLBC_IDelegate0 *deleg = new LLBC_Delegate0<
LLBC_IocpPoller>(this, &LLBC_IocpPoller::MonitorSvc);
_monitor = new LLBC_PollerMonitor(deleg);
if (_monitor->Start() != LLBC_OK)
{
LLBC_XDelete(_monitor);
return LLBC_FAILED;
}
return LLBC_OK;
}
int LLBC_BaseLogAppender::Initialize(const LLBC_LogAppenderInitInfo &initInfo)
{
if (_chain)
{
LLBC_SetLastError(LLBC_ERROR_REENTRY);
return LLBC_FAILED;
}
_chain = new LLBC_LogTokenChain;
if (_chain->Build(initInfo.pattern) != LLBC_OK)
{
LLBC_XDelete(_chain);
return LLBC_FAILED;
}
return LLBC_OK;
}
void LLBC_Variant::CleanDictData()
{
LLBC_XDelete(_holder.dict);
}
bool LLBC_Variant::DeSerialize(LLBC_Stream &stream)
{
BecomeNil();
if (!stream.Read(_holder.type))
{
return false;
}
if (IsNil())
{
return true;
}
if (IsRaw())
{
if (!stream.Read(_holder.raw.uint64Val))
{
_holder.type = LLBC_VariantType::VT_NIL;
return false;
}
}
else if (IsStr())
{
if (!stream.Read(_holder.str))
{
_holder.type = LLBC_VariantType::VT_NIL;
return false;
}
}
else if (IsDict())
{
uint32 count = 0;
if (!stream.Read(count))
{
_holder.type = LLBC_VariantType::VT_NIL;
return false;
}
if (count == 0)
{
return true;
}
_holder.dict = new Dict;
for (uint32 i = 0; i < count; i ++)
{
LLBC_Variant key;
LLBC_Variant val;
if (!stream.Read(key) || !stream.Read(val))
{
LLBC_XDelete(_holder.dict);
_holder.type = LLBC_VariantType::VT_NIL;
return false;
}
_holder.dict->insert(std::make_pair(key, val));
}
return true;
}
return false;
}
void LLBC_IocpPoller::StopMonitor()
{
LLBC_XDelete(_monitor);
}
LLBC_Session::~LLBC_Session()
{
LLBC_XDelete(_socket);
LLBC_XDelete(_protoStack);
}
LLBC_SvcEv_DataArrival::~LLBC_SvcEv_DataArrival()
{
LLBC_XDelete(packet);
}
LLBC_SvcEv_SessionDestroy::~LLBC_SvcEv_SessionDestroy()
{
LLBC_XDelete(closeInfo);
}
void LLBC_TimerScheduler::DestroyEntryThreadScheduler()
{
LLBC_XDelete(LLBC_INTERNAL_NS __g_entryThreadTimerScheduler);
}
LLBC_SvcEv_SubscribeEv::~LLBC_SvcEv_SubscribeEv()
{
LLBC_XDelete(deleg);
}
LLBC_SvcEv_FireEv::~LLBC_SvcEv_FireEv()
{
LLBC_XDelete(ev);
}
void LLBC_BaseLogAppender::Finalize()
{
LLBC_XDelete(_chain);
}
pyllbc_PackLemma_Dict::~pyllbc_PackLemma_Dict()
{
LLBC_XDelete(_keyLemma);
LLBC_XDelete(_valueLemma);
}
int LLBC_LogTokenChain::Build(const LLBC_String &pattern)
{
if (_head)
{
LLBC_SetLastError(LLBC_ERROR_REENTRY);
return LLBC_RTN_FAILED;
}
char ch = '\0';
const char *curPattern = NULL;
LLBC_String::size_type patternLength = 0;
int state = LLBC_INTERNAL_NS __g_literal_state;
LLBC_ILogToken *token = NULL;
LLBC_LogFormattingInfo *formatter = NULL;
LLBC_String buf;
if (pattern.empty())
{
curPattern = LLBC_INTERNAL_NS __g_default_pattern;
patternLength = LLBC_StrLenA(LLBC_INTERNAL_NS __g_default_pattern);
}
else
{
curPattern = pattern.data();
patternLength = pattern.size();
}
for (size_t i = 0; i < patternLength;)
{
ch = curPattern[i ++];
switch(state)
{
case LLBC_INTERNAL_NS __g_literal_state:
if (i == patternLength)
{
buf.append(1, ch);
break;
}
if (ch == LLBC_LogTokenType::EscapeToken)
{
if (curPattern[i] == LLBC_LogTokenType::EscapeToken)
{
buf.append(1, ch);
i ++;
}
else
{
if (!buf.empty())
{
token = LLBC_LogTokenBuilderSingleton->BuildLogToken(LLBC_LogTokenType::StrToken);
token->Initialize(formatter, buf);
this->AppendToken(token);
buf.clear();
formatter = NULL;
}
buf.append(1, ch);
LLBC_XDelete(formatter);
state = LLBC_INTERNAL_NS __g_converter_state;
}
}
else
{
buf.append(1, ch);
}
break;
case LLBC_INTERNAL_NS __g_converter_state:
buf.append(1, ch);
if ((ch >= 0x30 && ch <= 0x39) || ch == '-')
{
state = LLBC_INTERNAL_NS __g_number_state;
break;
}
buf.erase(buf.rfind(LLBC_LogTokenType::EscapeToken));
token = LLBC_LogTokenBuilderSingleton->BuildLogToken(ch);
if (!formatter)
{
formatter = new LLBC_LogFormattingInfo;
}
token->Initialize(formatter, "");
this->AppendToken(token);
formatter = NULL;
state = LLBC_INTERNAL_NS __g_literal_state;
break;
case LLBC_INTERNAL_NS __g_number_state:
if ((ch < 0x30 || ch > 0x39) && ch != '-')
{
int minLength = LLBC_Str2Int32(&buf[buf.rfind(LLBC_LogTokenType::EscapeToken) + 1]);
if (!formatter)
{
formatter = new LLBC_LogFormattingInfo(minLength < 0 ? true : false, ::abs(minLength), INT_MAX);
}
else
{
formatter->SetLeftAligh(minLength < 0 ? true : false);
formatter->SetMinLen(minLength);
formatter->SetMaxLen(INT_MAX);
}
i --;
state = LLBC_INTERNAL_NS __g_converter_state;
break;
}
buf.append(1, ch);
break;
default:
LLBC_XDelete(formatter);
this->Cleanup();
LLBC_SetLastError(LLBC_ERROR_FORMAT);
return LLBC_RTN_FAILED;
break;
}
}
if (!buf.empty())
{
token = LLBC_LogTokenBuilderSingleton->BuildLogToken(LLBC_LogTokenType::StrToken);
token->Initialize(NULL, buf);
this->AppendToken(token);
}
return LLBC_RTN_OK;
}
