qdnsserver.cpp

BCB下的高效开发包。包含大并发的网络库

//---------------------------------------------------------------------------


#pragma hdrstop

#include "QDNSServer.h"
#include <assert.h>
#include "../QNetBase/QNetBase.h"
#include "../QStdlib/QStdlib.h"
#pragma package(smart_init)
using namespace qdns_server;
//---------------------------------------------------------------------------
void QDNSThread::Execute(void* Param)
{
        QDNSServer* Server = (QDNSServer*)Param;
        while(!this->IsCmdStop()) {
                if (!Server->ProcessThread())
                Sleep(500);

                this->DoPause();
        }
}
//---------------------------------------------------------------------------
IQDNSServer* __stdcall IQDNSServer::Create(void)
{
        return new QDNSServer;
}
//---------------------------------------------------------------------------
__stdcall QDNSServer::~QDNSServer()
{
        this->Stop();
}
//---------------------------------------------------------------------------
void __stdcall QDNSServer::Release(void)
{
        assert(this);
        delete this;
}
//---------------------------------------------------------------------------
bool __stdcall QDNSServer::Start(int Thread)
{
        if (this->IsPowerOn())
                return false;
        m_Input.clear(); 
        for(int i = 0; i < Thread; ++i) {
                QDNSThread* Thread = new QDNSThread;
                assert(Thread);
                m_Thread.push_back(Thread);
                assert(Thread->Start(this));
        }
        return true;
}
//---------------------------------------------------------------------------
void __stdcall QDNSServer::Stop(void)
{
        if (!this->IsPowerOn())
                return;
        m_Input.clear();
        for(unsigned int i = 0; i < m_Thread.size(); ++i) {
                m_Thread[i]->PostStop();
        }
        for(unsigned int i = 0; i < m_Thread.size(); ++i) {
                m_Thread[i]->Stop();
                delete m_Thread[i];
        }
        m_Thread.clear();
}
//---------------------------------------------------------------------------
bool __stdcall QDNSServer::IsPowerOn(void)const
{
        return !m_Thread.empty();
}
//---------------------------------------------------------------------------
bool __stdcall QDNSServer::PushTask(const std::string& HostName, const std::string& TaskName)
{
        if (!this->IsPowerOn())
                return false;
        TASK_ITEM item;
        item.Data = HostName;
        item.TaskName = TaskName;
        m_Input.send(item);
        return true;
}
//---------------------------------------------------------------------------
bool __stdcall QDNSServer::ReadResult(std::string* pTaskName, std::string* pIp)
{
        if (!pTaskName || !pIp)
                return false;
        TASK_ITEM item;
        if (!m_OutPut.recv(&item)) {
                return false;
        }
        *pTaskName = item.TaskName;
        *pIp = item.Data;
        return true;
}
//---------------------------------------------------------------------------
int  __stdcall QDNSServer::GetBuzy(void)const
{
        return m_BuzyCount;
}
//---------------------------------------------------------------------------
bool QDNSServer::ProcessThread(void)
{
        TASK_ITEM item;
        if (!m_Input.recv(&item))
                return false;

        m_Lock.Lock();
        if (m_LastHost == item.Data) {
                item.Data = m_LastIp;
                m_Lock.Free();
                m_OutPut.send(item);
                return true;
        }
        ++ m_BuzyCount;

        m_Lock.Free();

        const std::string HostName = item.Data;
        item.Data = _QNameToIp(HostName);

        m_OutPut.send(item);

        m_Lock.Lock();
        m_LastHost = HostName;
        m_LastIp   = item.Data;

        -- m_BuzyCount;
        m_Lock.Free();

        return true;
}