KjServerTest.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "KjServerTest.h"

KjServerTest::KjServerTest()
{
        cout << "KjServerTest::KjServerTest()" << endl;
        m_pServer = NULL;
        m_strReadMsg = "";
        m_strWriteMsg = "";
        m_bIsConnected = false;
}

KjServerTest::~KjServerTest()
{
        cout << "KjServerTest::~KjServerTest()" << endl;
}

bool KjServerTest::CanRead(const int _iClientId)
{
        if(m_pServer)
        {
                KjClientConn *pClient = m_pServer->GetClient(_iClientId);
                if(pClient)
                {
                        if(pClient->GetConn())
                        {
                                if(pClient->GetConn()->GetIsValid() == true)
                                {
                                        if(pClient->GetCanRead())
                                        {
                                                return true;
                                        }
                                }
                        }
                }
        }
        return false;
}

const char *KjServerTest::Read(const int _iClientId)
{
        if(m_pServer)
        {
                KjClientConn *pClient = m_pServer->GetClient(_iClientId);
                if(pClient)
                {
                        if(pClient->GetConn())
                        {
                                if(pClient->GetConn()->GetIsValid() == true)
                                {
                                        m_strReadMsg = pClient->ReadMsg();
                                        return m_strReadMsg.c_str();
                                }
                        }
                }
        }
        m_strReadMsg = "Error: Client is disconnected !!!";
        return m_strReadMsg.c_str();
}

void KjServerTest::Write(const int _iClientId, const char* _strMsg)
{
        if(m_pServer)
        {
                KjClientConn *pClient = m_pServer->GetClient(_iClientId);
                if(pClient)
                {
                        if(pClient->GetConn())
                        {
                                if(pClient->GetConn()->GetIsValid() == true)
                                {
                                        m_strWriteMsg = _strMsg;
                                        pClient->WriteMsg(m_strWriteMsg);
                                        return;
                                }
                        }
                }
        }
        cout << "Client id " << _iClientId << " is disconnected !!!" << endl;;
}

int KjServerTest::GetNumClients()
{
        return m_pServer->GetNumClients();
}

void KjServerTest::Connect(char* _strConn, const char* _strCertFile,const char* _strKeyFile)
{
        cout << "KjPerlServer::Connect()" << endl;
        m_pServer = new KjServerThread(_strConn, _strCertFile, _strKeyFile);
}

void KjServerTest::ConnectServer()
{
        cout << "Try connection ssl server" << endl;
        Connect(KJ_TEST_SERVER_CONN, KJ_TEST_CRT, KJ_TEST_KEY);
        m_bIsConnected = true;
}

int KjServerTest::Start()
{
        cout << "int KjServerTest::Start()" << endl;
        if(m_pServer)
        {
                if(!m_pServer->Start())
                {
                        if(m_pServer)
                        {
                                delete m_pServer;
                                m_pServer = NULL;
                        }
                }
        }
        return 0;
}

void *KjServerTest::NewThread(void *_pArg)
{
        cout << "KjServerThread::NewThread()" << pthread_self() << endl;
        printf("Process %s: start\n", (char *)_pArg);
        // Start server in this thread
        class KjServerTest *pServerTest = (class KjServerTest *) _pArg;
        cout << "pServerTest " << pServerTest << endl;
        pServerTest->Start();
        cout << "Thread" << pthread_self() << "Exiting" << endl;
        printf("Process %s: end\n", (char *)_pArg);
        return NULL;
}

void KjServerTest::CreateNewThread()
{
        int iRet;
        pthread_t *pThread = new pthread_t;
        // Create new thread and send client connection to the thread
        iRet = pthread_create(pThread, NULL, &NewThread, this);
        if (iRet != 0) fprintf(stderr, "create a failed %d\n", iRet);
}

int KjServerTest::Update()
{
        cout << "int KjServerTest::Update()" << endl;
        ConnectServer();
        if(m_bIsConnected == true)
        {
                // Start server in new thread
                CreateNewThread();
                // Check server in this thread
                for(;;) 
                {
                        int iNumClients = GetNumClients();
                        // Go through all clients
                        for(int i=0; i<iNumClients; i++)
                        {
                                // If can read client
                                if(CanRead(i))
                                {
                                        cout << "Client id = " << i << "Can read ..." << endl;
                                        // Read client message
                                        const char* strReadMsg = Read(i);
                                        cout << "strReadMsg = " << strReadMsg << endl;
                                        cout << endl;
                                        // Write client message
                                        stringstream strWriteMsg;
                                        strWriteMsg << "Client id " << i << " reads next message..." << strReadMsg << endl;
                                        Write(i, strWriteMsg.str().c_str());
                                }
                        }
                }
        }
        else
        {
                cerr << "Error -- int KjServerTest::Start() -- Server doesn`t connected !!!"  << endl;
        }
        return 0;
}

---