Changeset 736

Timestamp:

06/21/09 05:07:51 (15 months ago)

Author:

ghoulsblade

Message:

irc: implemented ping, now works on quakenet. multithreading : started experimenting with boost-thread for a second lua state

Location:

trunk/lugre

Files:

• include/lugre_scripting.h (modified) (1 diff)
• include/lugre_thread.h (modified) (2 diffs)
• lua/lib.irc.lua (modified) (4 diffs)
• src/lugre_scripting.cpp (modified) (2 diffs)
• src/lugre_scripting.general.cpp (modified) (2 diffs)
• src/lugre_thread.cpp (modified) (2 diffs)
• src/lugre_thread_L.cpp (modified) (3 diffs)

trunk/lugre/include/lugre_scripting.h

@@ -68 +68 @@
         bool    LuaCall         (const char *func, const char *sig = "", ...);
         
+        
+        void    InitLugreLuaEnvironment         (lua_State*     L);
+        
         // cInputListener methods
         virtual void    Notify_KeyPress         (const unsigned char iKey,const int iLetter);

trunk/lugre/include/lugre_thread.h

@@ -36 +36 @@
 class cThread_LoadFileImpl;
 
+int             MyThreadSleepMilliSeconds               (int iSleepTimeMilliSeconds);
+void    LuaRegisterThreading                    (lua_State*     L);
 
 /// connects to host:port , sends senddata and collects answer until the other side closes the connection
@@ -80 +82 @@
 
 
+
+
+
+
+
+
+
+
 };
 

trunk/lugre/lua/lib.irc.lua

@@ -31 +31 @@
         if not self:IsConnected() then return end
         
+        print("DEBUG:IRC:send",">"..tostring(line).."<")
+        
         local fifo = CreateFIFO()
         FIFO_PushPlainText(fifo,line .. "\r\n")
@@ -58 +60 @@
                 local message = ""
                 
+                
                 if string.find(line," ",pos) then
                         sender = trim(string.sub(line,pos,string.find(line," ",pos)))
@@ -78 +81 @@
                 end
                 
-                print("DEBUG",tostring(sender) .. "|" .. tostring(command) .. "|" .. tostring(param) .. "|" .. tostring(message))
-                
                 
                 local nick = trim(sender,":")
@@ -93 +94 @@
                         self:OnMessage(nick,param,message)
                 end
+                
+                
+                local a,b
+                local msg_prefix
+                local msg_command
+                local msg_params
+                if (string.find(line,"^:")) then 
+                        a,b,msg_prefix,msg_command,msg_params = string.find(line,"^:([^ ]+) ([^ ]+) (.*)\r\n$")
+                else 
+                        a,b,msg_command,msg_params = string.find(line,"([^ ]+) (.*)\r\n$")
+                end
+                
+                local RPL_MOTD = "372"
+                local RPL_UMODEIS = "221"
+
+                        
+                --~ print("DEBUG",tostring(sender) .. "|" .. tostring(command) .. "|" .. tostring(param) .. "|" .. tostring(message))
+                if (msg_command ~= RPL_MOTD) then 
+                        --~ print("DEBUG:IRC",">"..tostring(msg_command).."<",">"..tostring(msg_params).."<",">"..tostring(string.gsub(line,"\r\n$","")).."<")
+                        print("DEBUG:IRC:recv",">"..tostring(string.gsub(line,"\r\n$","")).."<")
+                end
+                
+                if (msg_command == RPL_UMODEIS) then -- final login message on quakenet 
+                        if (self.on_login_complete) then self:on_login_complete() end
+                end
+                if (msg_command == "PING") then
+                        local a,b,daemon = string.find(msg_params,"^:(.*)")
+                        if (not daemon) then daemon = tostring(msg_params) end
+                        -- quakenet sends  >PING :424867537<  so we just remove the :
+                        -- zw sends        >PING :zwischenwelt.org< 
+                        print("IRC: got ping, sending pong.. daemon="..daemon)
+                        self:SendLine("PONG "..daemon)
+                end
+                -- DEBUG   PING|||zwischenwelt.org
 
                 -- read out next line

trunk/lugre/src/lugre_scripting.cpp

@@ -376 +376 @@
         L = lua_open(); 
         assert(L);
+        InitLugreLuaEnvironment(L);
+        
+        cInput::RegisterListener(this);
+
+        int res = luaL_dofile(L,sLuaMainPath.c_str());
+        if (res) {
+                fprintf(stderr,"%s\n",lua_tostring(L,-1));
+                MyCrash("error in main script-initialisation\n");
+                exit(-1); 
+        }
+}
+
+
+
+void    cScripting::InitLugreLuaEnvironment             (lua_State*     L) {
         luaL_openlibs(L);
         //~ luaopen_base(L);
@@ -447 +462 @@
         { for (std::list<cScriptingPlugin*>::iterator itor=mlPlugins.begin();itor!=mlPlugins.end();++itor)
                 (*itor)->RegisterLua_Classes(L); }
-                
-        cInput::RegisterListener(this);
-
-        res = luaL_dofile(L,sLuaMainPath.c_str());
-        if (res) {
-                fprintf(stderr,"%s\n",lua_tostring(L,-1));
-                MyCrash("error in main script-initialisation\n");
-                exit(-1); 
-        }
 }
 

trunk/lugre/src/lugre_scripting.general.cpp

@@ -471 +471 @@
 
 
+        
 void    RegisterLua_General_Classes                     (lua_State*     L) {
         RegisterLuaXML(L);
         LuaRegisterFIFO(L);
         LuaRegisterNet(L);
+        LuaRegisterThreading(L);
         cGfx3D::LuaRegister(L);
         cGfx2D::LuaRegister(L);
@@ -482 +484 @@
         cSoundSource::LuaRegister(L);
         cRandom::LuaRegister(L);
-        cThread_NetRequest::LuaRegister(L);
-        cThread_LoadFile::LuaRegister(L);
         cTexAtlas::LuaRegister(L);
         cImage::LuaRegister(L);

trunk/lugre/src/lugre_thread.cpp

@@ -17 +17 @@
 // warning ! starting a thread makes a COPY of the passed in functor-object, so you cannot access the original
 // see http://boost.org/doc/html/boost/thread.html#id1291385-bb for details
+// http://www.boost.org/doc/libs/1_39_0/doc/html/thread.html
 
 // see also http://engineering.meta-comm.com/resources/cs-win32_1_30_2_metacomm/libs/thread/doc/thread.html
@@ -188 +189 @@
 
 
+
 };

trunk/lugre/src/lugre_thread_L.cpp

@@ -3 +3 @@
 #include "lugre_fifo.h"
 #include "lugre_luabind.h"
+#include "lugre_scripting.h"
+
+#ifdef ENABLE_THREADS
+#include <boost/thread/xtime.hpp>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/mutex.hpp>
+#endif
 
 namespace Lugre {
@@ -111 +118 @@
 };
 
+
+// result : 0:not supported,  1:success   2:interrupted
+int             MyThreadSleepMilliSeconds (int iSleepTimeMilliSeconds) {
+        #ifdef ENABLE_THREADS
+        
+        
+        /*
+        ancient boost version : 103401
+        boost::xtime xt;
+        boost::xtime_get(&xt, boost::TIME_UTC);
+        int big = 1000*1000*1000;
+        xt.sec += (iSleepTimeMilliSeconds / 1000);
+        while (xt.nsec > big) { xt.nsec -= big; xt.sec += 1; }
+        xt.nsec += (iSleepTimeMilliSeconds % 1000)*1000*1000;
+        while (xt.nsec > big) { xt.nsec -= big; xt.sec += 1; }
+        boost::thread::sleep(xt);
+        */
+        
+        
+        //~ #else
+        //~ #define BOOST_VERSION 103401 -- ghoul : old : linux
+        //~ #define BOOST_VERSION 103700 -- ghoul : new
+        //~ #define BOOST_VERSION 103800 -- hagish:win
+        // #define BOOST_LIB_VERSION "1_34_1"
+                
+        try {
+                // boost::this_thread::sleep(system_time const& abs_time);      
+                // boost::this_thread::sleep(TimeDuration const& rel_time);
+                boost::this_thread::sleep(boost::posix_time::milliseconds(iSleepTimeMilliSeconds));
+        } catch (...) {
+                return 2;
+        }
+        return 1;
+        #else
+        return 0;
+        #endif
+}
+
+#ifdef ENABLE_THREADS
+
+class cLuaThread : public cSmartPointable { public:
+        cFIFO                   mFIFO;
+        boost::mutex    mMutex;
+        boost::thread*  mThread;
+        std::string             msFilePath;
+        
+        cLuaThread      (std::string sFilePath);
+        virtual ~cLuaThread     () { if (mThread) { delete mThread; mThread = 0; } }
+        
+        cFIFO&  GetFIFO         () { return mFIFO; }
+        void    LockMutex       () { mMutex.lock(); }
+        void    UnLockMutex     () { mMutex.unlock(); }
+        void    Interrupt       () { if (mThread) mThread->interrupt(); }
+};
+
+class cLuaThread_Callable { public: // must be copyable
+        cLuaThread*             mSelfThreadHandle;
+        std::string             msFilePath;
+        cLuaThread_Callable (cLuaThread* mSelfThreadHandle,std::string msFilePath) : mSelfThreadHandle(mSelfThreadHandle),msFilePath(msFilePath) {}
+        
+        static int      DontUseWarning_Client_Sleep     (lua_State *L) { printf("DontUseWarning_Client_Sleep\n"); return 0; }
+        
+        // bool         Thread_Sleep    (iSleepTimeMilliSeconds)   // returns true if it was interrupted
+        static int      Thread_Sleep    (lua_State *L) { 
+                int iSleepTimeMilliSeconds = luaL_checkint(L,1);
+                if (MyThreadSleepMilliSeconds(iSleepTimeMilliSeconds) == 2) { lua_pushboolean(L,true); return 1; }
+                return 0;
+        }
+                
+    void operator()() {
+                //~ msFilePath
+                //  boost::thread::sleep()
+                
+                                
+                lua_State* L = lua_open();
+                if (!L) { printf("cLuaThread_Callable: failed to init lua state\n"); return; }
+                cScripting::GetSingletonPtr()->InitLugreLuaEnvironment(L);
+                
+                
+                lua_register(L,"Client_Sleep",  &cLuaThread_Callable::DontUseWarning_Client_Sleep);
+                lua_register(L,"Thread_Sleep",  &cLuaThread_Callable::Thread_Sleep);
+                
+                
+                cLuaBind<cLuaThread>::CreateUData(L,mSelfThreadHandle);
+                lua_setglobal(L,"this_thread");
+                
+                
+                int res = luaL_dofile(L,msFilePath.c_str());
+                if (res) {
+                        fprintf(stderr,"%s\n",lua_tostring(L,-1));
+                        MyCrash("error during cLuaThread_Callable run\n");
+                        exit(-1); 
+                }
+        }
+};
+
+
+
+cLuaThread::cLuaThread  (std::string sFilePath) : mThread(0),msFilePath(sFilePath) {
+        cLuaThread_Callable     myImpl(this,sFilePath);
+        mThread = new boost::thread(myImpl); // warning ! this COPIES the impl object
+}
+
+
+class cLuaThread_L : public cLuaBind<cLuaThread> { public:
+        // implementation of cLuaBind
+
+                /// called by Register(), registers object-methods (see cLuaBind constructor for examples)
+                virtual void RegisterMethods    (lua_State *L) { PROFILE
+                        #define REGISTER_METHOD(methodname) mlMethod.push_back(make_luaL_reg(#methodname,&cLuaThread_L::methodname));
+
+                        REGISTER_METHOD(Destroy);
+                        REGISTER_METHOD(CreateFifoHandle);
+                        REGISTER_METHOD(LockMutex);
+                        REGISTER_METHOD(UnLockMutex);
+                        REGISTER_METHOD(Interrupt); 
+
+                        #undef REGISTER_METHOD
+                        
+                        lua_register(L,"CreateLuaThread",                                       &cLuaThread_L::CreateLuaThread);
+                        lua_register(L,"Threads_GetHardwareConcurrency",        &cLuaThread_L::Threads_GetHardwareConcurrency);
+                }
+                
+        // static methods exported to lua
+                 
+                /// luathread           CreateLuaThread (sFilePath)
+                static int                      CreateLuaThread (lua_State *L) { PROFILE
+                        std::string     sFilePath               = luaL_checkstring(L,1);
+                        return CreateUData(L,new cLuaThread(sFilePath));
+                }
+                
+                /// int                         Threads_GetHardwareConcurrency  ()   
+                // The number of hardware threads available on the current system (e.g. number of CPUs or cores or hyperthreading units), or 0 if this information is not available. 
+                static int                      Threads_GetHardwareConcurrency  (lua_State *L) { PROFILE
+                        lua_pushnumber(L,boost::thread::hardware_concurrency()); //~ unsigned boost::thread::hardware_concurrency();
+                        return 1;
+                }
+                
+                
+                        
+        // object methods exported to lua
+
+                // use LockMutex -- UnLockMutex  around access to this fifo !
+                /// for lua     : fifo  CreateFifoHandle        ()
+                static int                      CreateFifoHandle        (lua_State *L) { PROFILE
+                        cFIFO& pFIFO = checkudata_alive(L)->GetFIFO();
+                        return cLuaBind<cFIFO>::CreateUData(L,&pFIFO);
+                }
+                
+                /// for lua     : void  LockMutex       ()
+                static int                      LockMutex       (lua_State *L) { PROFILE checkudata_alive(L)->LockMutex(); return 0; }
+                /// for lua     : void  UnLockMutex     ()
+                static int                      UnLockMutex     (lua_State *L) { PROFILE checkudata_alive(L)->UnLockMutex(); return 0; }
+                /// for lua     : void  Interrupt       ()
+                static int                      Interrupt       (lua_State *L) { PROFILE checkudata_alive(L)->Interrupt(); return 0; }
+                
+                /// Destroy()
+                static int      Destroy                 (lua_State *L) { PROFILE
+                        delete checkudata_alive(L);
+                        return 0;
+                }
+
+                virtual const char* GetLuaTypeName () { return "lugre.luathread"; }
+};
+
+
+
+
+
+#endif
         
 /// lua binding
@@ -120 +297 @@
 }
 
-};
+void    LuaRegisterThreading                    (lua_State*     L) {
+        cThread_NetRequest::LuaRegister(L);
+        cThread_LoadFile::LuaRegister(L);
+        #ifdef ENABLE_THREADS
+        cLuaBind<cLuaThread>::GetSingletonPtr(new cLuaThread_L())->LuaRegister(L);
+        #endif
+}
+
+
+};