rhodes 1.5.4 → 1.5.5

data/platform/shared/db/DBAdapter.h

@@ -5,6 +5,22 @@
 #include "logging/RhoLog.h"
 
 namespace rho{
+namespace common{
+class CRubyMutex
+{
+    int m_nLockCount;
+    unsigned long m_valThread, m_valMutex;
+
+public:
+    CRubyMutex();
+    ~CRubyMutex();
+
+    boolean isMainRubyThread();
+    void Lock();
+    void Unlock();
+};
+}
+
 namespace db{
 
 class CDBAdapter
@@ -12,10 +28,10 @@ class CDBAdapter
     sqlite3* m_dbHandle;
     String   m_strDbPath, m_strDbVer, m_strDbVerPath;
     Hashtable<String,sqlite3_stmt*> m_mapStatements;
+    common::CRubyMutex m_mxRuby;
     common::CMutex m_mxDB;
-    common::CMutex m_mxTransDB;
-    boolean m_bUnlockDB;
-    boolean m_bInsideTransaction;
+    boolean m_bUIWaitDB;
+    int     m_nTransactionCounter;
     CDBAttrManager m_attrMgr;
 
     struct CDBVersion
@@ -34,7 +50,7 @@ class CDBAdapter
 public:
     DEFINE_LOGCLASS;
 
-    CDBAdapter(void) : m_dbHandle(0), m_strDbPath(""), m_bUnlockDB(false), m_bInsideTransaction(false){}
+    CDBAdapter(void) : m_dbHandle(0), m_strDbPath(""), m_bUIWaitDB(false), m_nTransactionCounter(0){}
     ~CDBAdapter(void){}
 
     void open (String strDbPath, String strVer, boolean bTemp);
@@ -42,11 +58,10 @@ public:
     sqlite3* getDbHandle(){ return m_dbHandle; }
     CDBAttrManager& getAttrMgr(){ return m_attrMgr; }
 
-    boolean isUnlockDB()const{ return m_bUnlockDB; }
-    void setUnlockDB(boolean b){ m_bUnlockDB = b; }
-    void Lock(){ m_mxDB.Lock(); }
-    void Unlock(){ setUnlockDB(false); m_mxDB.Unlock(); }
-    boolean isInsideTransaction(){ return m_bInsideTransaction; }
+    boolean isUIWaitDB()const{ return m_bUIWaitDB; }
+    void Lock();
+    void Unlock();
+    boolean isInsideTransaction(){ return m_nTransactionCounter > 0; }
     const String& getDBPath(){ return m_strDbPath; }
 
     void bind(sqlite3_stmt* st, int nPos, int val)

data/platform/shared/db/DBResult.cpp

@@ -1,11 +1,30 @@
 #include "DBResult.h"
+#include "DBAdapter.h"
 
 namespace rho{
 namespace db{
 
+CDBResult::CDBResult(sqlite3_stmt* st,CDBAdapter* pDB) : m_pDB(pDB), m_dbStatement(st)
+{
+    m_bReportNonUnique=false;
+    m_nErrorCode=0;
+
+    if ( m_pDB )
+        m_pDB->Lock();
+}
+
+CDBResult::CDBResult() : m_pDB(null), m_dbStatement(null)
+{
+    m_bReportNonUnique=false;
+    m_nErrorCode=0;
+}
+
 CDBResult::~CDBResult(void)
 {
     setStatement(null);
+
+    if ( m_pDB )
+        m_pDB->Unlock();
 }
 
 void CDBResult::setStatement(sqlite3_stmt* st)

data/platform/shared/db/DBResult.h

@@ -8,16 +8,18 @@
 namespace rho{
 namespace db{
 
+class CDBAdapter;
+
 class CDBResult
 {
-    common::CMutexLock m_lockDB;
+    //common::CMutexLock m_lockDB;
+    CDBAdapter* m_pDB;
     sqlite3_stmt* m_dbStatement;
     boolean m_bReportNonUnique;
     int     m_nErrorCode;
 public:
-    CDBResult(sqlite3_stmt* st,common::CMutex& mx) : m_lockDB(mx), m_dbStatement(st){m_bReportNonUnique=false;m_nErrorCode=0;}
-    CDBResult(common::CMutex& mx) : m_lockDB(mx), m_dbStatement(null){m_bReportNonUnique=false;m_nErrorCode=0;}
-
+    CDBResult(sqlite3_stmt* st,CDBAdapter* pDB);
+    CDBResult();
     ~CDBResult(void);
 
     void setStatement(sqlite3_stmt* st);
@@ -52,7 +54,7 @@ public:
         return sqlite3_column_int64(m_dbStatement, nCol);
     }
 //private:
-    CDBResult() : m_lockDB(*new common::CMutex() ){} //TEST ONLY
+    //CDBResult() : m_lockDB(*new common::CMutex() ){} //TEST ONLY
 
 };
 

data/platform/shared/net/HttpServer.cpp

@@ -340,7 +340,9 @@ bool CHttpServer::run()
     
     for(;;) {
         RAWTRACE("Waiting for connections...");
+        rho_ruby_start_threadidle();
         SOCKET conn = accept(m_listener, NULL, NULL);
+        rho_ruby_stop_threadidle();
 		if (m_exit) {
 			RAWTRACE("Stop HTTP server");
 			return true;

data/platform/shared/ruby/ext/rho/rhoruby.c

@@ -99,6 +99,27 @@ void RhoRubyThreadStop()
     //native_mutex_destroy(&th->interrupt_lock);
 } */
 
+extern int native_mutex_lock(rb_thread_lock_t *);
+extern int native_mutex_unlock(rb_thread_lock_t *);
+
+rb_thread_t * g_th_stored = 0;
+void rho_ruby_start_threadidle()
+{
+    g_th_stored = GET_THREAD();
+    rb_gc_save_machine_context(g_th_stored);
+    native_mutex_unlock(&g_th_stored->vm->global_vm_lock);
+}
+
+void rho_ruby_stop_threadidle()
+{                                              
+    if ( g_th_stored )
+    {
+        native_mutex_lock(&g_th_stored->vm->global_vm_lock);
+        rb_thread_set_current(g_th_stored);
+        g_th_stored = 0;
+    }
+}
+
 void RhoRubyStart()
 {
     //VALUE moduleRhom;
@@ -390,6 +411,40 @@ void rho_ruby_releaseValue(VALUE val)
         rb_ary_delete_at(ary,i);
 }
 
+extern VALUE rb_cMutex;
+VALUE rho_ruby_create_mutex()
+{
+    VALUE val = rb_funcall(rb_cMutex, rb_intern("new"), 0 );
+    rho_ruby_holdValue(val);
+
+    return val;
+}
+
+void rho_ruby_destroy_mutex(VALUE val)
+{
+    rho_ruby_releaseValue(val);
+}
+
+void rho_ruby_lock_mutex(VALUE val)
+{
+    rb_mutex_lock(val);
+}
+
+void rho_ruby_unlock_mutex(VALUE val)
+{
+    rb_mutex_unlock(val);
+}
+
+VALUE rho_ruby_main_thread()
+{
+    return rb_thread_main();
+}
+
+VALUE rho_ruby_current_thread()
+{
+    return rb_thread_current();
+}
+
 VALUE callFramework(VALUE hashReq) {
     VALUE callres = rb_funcall(framework, framework_mid, 1, hashReq);
     

data/platform/shared/ruby/ext/rho/rhoruby.h

@@ -36,6 +36,8 @@ void RhoRubyInitApp();
 //void RhoRubyThreadStart();
 //void RhoRubyThreadStop();
 void rho_ruby_activateApp();
+void rho_ruby_start_threadidle();
+void rho_ruby_stop_threadidle();
 
 VALUE createHash();
 VALUE addTimeToHash(VALUE hash, const char* key, time_t val);	
@@ -84,6 +86,13 @@ const char* rho_ruby_getMessageText(const char* szName);
 const char* rho_ruby_getErrorText(int nError);
 const char* rho_ruby_internal_getErrorText(int nError);
 
+VALUE rho_ruby_create_mutex();
+void rho_ruby_destroy_mutex(VALUE val);
+VALUE rho_ruby_main_thread();
+VALUE rho_ruby_current_thread();
+void rho_ruby_lock_mutex(VALUE val);
+void rho_ruby_unlock_mutex(VALUE val);
+
 #if defined(__cplusplus)
 }
 #endif

data/platform/shared/ruby/ext/rho/rhosupport.c

@@ -11,6 +11,7 @@
 #endif
 
 #include "common/RhodesApp.h"
+#include "common/RhoMutexLock.h"
 #include "logging/RhoLog.h"
 #undef DEFAULT_LOGCATEGORY
 #define DEFAULT_LOGCATEGORY "RhoRuby"
@@ -266,11 +267,15 @@ VALUE isAlreadyLoaded(VALUE path)
     return Qfalse;
 }
 
+RHO_INIT_LOCK(require_lock);
+
 VALUE require_compiled(VALUE fname, VALUE* result)
 {
     VALUE path;
     char* szName1 = 0;
+    VALUE retval = Qtrue;
 
+    RHO_LOCK(require_lock);
     rb_funcall(fname, rb_intern("sub!"), 2, rb_str_new2(".rb"), rb_str_new2("") );
 
     szName1 = RSTRING_PTR(fname);
@@ -279,10 +284,10 @@ VALUE require_compiled(VALUE fname, VALUE* result)
         strcmp("digest.so",szName1)==0 ||
         strcmp("fcntl",szName1)==0 || strcmp("digest/md5",szName1)==0 ||
         strcmp("digest/sha1",szName1)==0 )
-        return Qtrue;
+        goto RCompExit;
 
     if ( isAlreadyLoaded(fname) == Qtrue )
-        return Qtrue;
+        goto RCompExit;
 
     //RAWLOG_INFO1("find_file: %s", RSTRING_PTR(fname));
     path = find_file(fname);
@@ -307,11 +312,15 @@ VALUE require_compiled(VALUE fname, VALUE* result)
         //*result = rb_funcall(seq, rb_intern("eval"), 0 );
         *result = rb_iseq_eval(seq);
 
-        return Qtrue;
+        goto RCompExit;
     }
 
     RAWLOG_ERROR1("require_compiled: error: can not find %s", RSTRING_PTR(fname));
-    return Qnil;
+    retval = Qnil;
+
+RCompExit:
+    RHO_UNLOCK(require_lock);
+    return retval;
 }
 
 #ifndef CharNext		/* defined as CharNext[AW] on Windows. */

data/platform/shared/ruby/ext/sqlite3_api/sqlite3_api_wrap.c

@@ -14,6 +14,7 @@ extern int rho_db_startUITransaction();
 extern int rho_db_commitUITransaction();
 extern int rho_db_rollbackUITransaction();
 extern int rho_db_destroy_table(const char* szTableName);
+extern int rho_db_is_ui_waitfordb();
 extern void* rho_db_get_handle();
 
 static VALUE db_allocate(VALUE klass)
@@ -134,6 +135,21 @@ static VALUE db_destroy_table(int argc, VALUE *argv, VALUE self)
     return INT2NUM(rc);
 }
 
+static VALUE db_is_ui_waitfordb(int argc, VALUE *argv, VALUE self)
+{
+	sqlite3 **ppDB = NULL;		
+    int rc = 0;
+
+	if (argc > 0)
+		rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
+
+	Data_Get_Struct(self, sqlite3 *, ppDB);
+
+    rc = rho_db_is_ui_waitfordb();
+
+    return rc == 0 ? Qfalse : Qtrue;
+}
+
 static VALUE db_execute(int argc, VALUE *argv, VALUE self)
 {
 	sqlite3 * db = NULL;
@@ -194,6 +210,8 @@ static VALUE db_execute(int argc, VALUE *argv, VALUE self)
         }
     }
 
+    rho_sync_lock();
+
 	while( (nRes=sqlite3_step(statement)) == SQLITE_ROW) {
 		int nCount = sqlite3_data_count(statement);
 		int nCol = 0;
@@ -242,6 +260,8 @@ static VALUE db_execute(int argc, VALUE *argv, VALUE self)
     if ( colNames )
         free(colNames);
 
+    rho_sync_unlock();
+
 	return arRes;
 }
 
@@ -258,6 +278,7 @@ void Init_sqlite3_api(void)
 	rb_define_method(mDatabase, "commit", db_commit, -1);	
     rb_define_method(mDatabase, "rollback", db_rollback, -1);	
     rb_define_method(mDatabase, "destroy_table", db_destroy_table, -1);	
+    rb_define_method(mDatabase, "is_ui_waitfordb", db_is_ui_waitfordb, -1);	
 }
 
 #if 0

data/platform/shared/ruby/thread_pthread.c

@@ -17,8 +17,8 @@
 #include <sys/resource.h>
 #endif
 
-static void native_mutex_lock(pthread_mutex_t *lock);
-static void native_mutex_unlock(pthread_mutex_t *lock);
+void native_mutex_lock(pthread_mutex_t *lock);
+void native_mutex_unlock(pthread_mutex_t *lock);
 static int native_mutex_trylock(pthread_mutex_t *lock);
 void native_mutex_initialize(pthread_mutex_t *lock);
 void native_mutex_destroy(pthread_mutex_t *lock);
@@ -29,7 +29,7 @@ static void native_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
 static void native_cond_initialize(pthread_cond_t *cond);
 static void native_cond_destroy(pthread_cond_t *cond);
 
-static void
+void
 native_mutex_lock(pthread_mutex_t *lock)
 {
     int r;
@@ -38,7 +38,7 @@ native_mutex_lock(pthread_mutex_t *lock)
     }
 }
 
-static void
+void
 native_mutex_unlock(pthread_mutex_t *lock)
 {
     int r;

data/platform/shared/ruby/thread_win32.c

@@ -22,8 +22,8 @@
 
 static volatile DWORD ruby_native_thread_key = TLS_OUT_OF_INDEXES;
 
-static int native_mutex_lock(rb_thread_lock_t *);
-static int native_mutex_unlock(rb_thread_lock_t *);
+int native_mutex_lock(rb_thread_lock_t *);
+int native_mutex_unlock(rb_thread_lock_t *);
 static int native_mutex_trylock(rb_thread_lock_t *);
 void native_mutex_initialize(rb_thread_lock_t *);
 
@@ -251,7 +251,7 @@ native_sleep(rb_thread_t *th, struct timeval *tv)
     GVL_UNLOCK_END();
 }
 
-static int
+int
 native_mutex_lock(rb_thread_lock_t *lock)
 {
 #if USE_WIN32_MUTEX
@@ -287,7 +287,7 @@ native_mutex_lock(rb_thread_lock_t *lock)
 #endif
 }
 
-static int
+int
 native_mutex_unlock(rb_thread_lock_t *lock)
 {
 #if USE_WIN32_MUTEX

data/platform/shared/rubyJVM/src/com/rho/RhodesApp.java

@@ -1,5 +1,6 @@
 package com.rho;
 
+import com.rho.net.*;
 import com.xruby.runtime.lang.RubyValue;
 import java.util.Vector;
 
@@ -13,6 +14,8 @@ public class RhodesApp
 	private String m_strRhoRootPath;
     Vector/*<unsigned long>*/ m_arCallbackObjects = new Vector();
     private SplashScreen m_oSplashScreen = new SplashScreen();
+
+    NetRequest getNet() { return RhoClassFactory.createNetRequest();}
     
     public static RhodesApp Create(String strRootPath)
     {
@@ -68,5 +71,20 @@ public class RhodesApp
         m_arCallbackObjects.setElementAt(null,nIndex);        
         return res;
     }
-    
+
+    String canonicalizeRhoUrl(String strUrl)throws Exception 
+    {
+    	return getNet().resolveUrl(strUrl);    	
+    }
+ 
+    public void callPopupCallback(String strCallbackUrl, String id, String title)throws Exception
+    {
+        if ( strCallbackUrl == null || strCallbackUrl.length() == 0 )
+            return;
+    	
+        strCallbackUrl = canonicalizeRhoUrl(strCallbackUrl);
+        String strBody = "button_id=" + id + "&button_title=" + title;
+        strBody += "&rho_callback=1";
+        getNet().pushData( strCallbackUrl, strBody, null );
+    }    
 }

data/platform/shared/rubyJVM/src/com/rho/db/DBAdapter.java

@@ -18,8 +18,8 @@ public class DBAdapter extends RubyBasic {
 	private DBAttrManager m_attrMgr = new DBAttrManager();
 	
     Mutex m_mxDB = new Mutex();
-    boolean m_bInsideTransaction=false;
-    boolean m_bUnlockDB = false;
+    int m_nTransactionCounter=0;
+    boolean m_bUIWaitDB = false;
 	
 	DBAdapter(RubyClass c) {
 		super(c);
@@ -110,11 +110,11 @@ public class DBAdapter extends RubyBasic {
 		return executeSQL(strStatement,values);
 	}
 
-	public boolean isUnlockDB(){ return m_bUnlockDB; }
-	public void setUnlockDB(boolean b){ m_bUnlockDB = b; }
+	public boolean isUIWaitDB(){ return m_bUIWaitDB; }
+	public void setUIWaitDB(boolean b){ m_bUIWaitDB = b; }
 	public void Lock(){ m_mxDB.Lock(); }
-	public void Unlock(){ setUnlockDB(false); m_mxDB.Unlock(); }
-    public boolean isInsideTransaction(){ return m_bInsideTransaction; }
+	public void Unlock(){ m_mxDB.Unlock(); }
+    public boolean isInsideTransaction(){ return m_nTransactionCounter>0; }
 	
 	public static IDBResult createResult(){
 		return getInstance().m_dbStorage.createResult();
@@ -173,15 +173,22 @@ public class DBAdapter extends RubyBasic {
     public void startTransaction()throws DBException
     {
     	Lock();
-    	m_bInsideTransaction=true;    	
-    	m_dbStorage.startTransaction();
+    	m_nTransactionCounter++;
+    	
+    	if (m_nTransactionCounter == 1)
+    		m_dbStorage.startTransaction();
     }
     
     public void commit()throws DBException
     {
-    	getAttrMgr().save(this);
-    	m_dbStorage.commit();
-    	m_bInsideTransaction=false;
+    	m_nTransactionCounter--;
+    	
+    	if (m_nTransactionCounter == 0)
+    	{
+	    	getAttrMgr().save(this);
+	    	m_dbStorage.commit();
+    	}
+    	
     	Unlock();
     }
     public void endTransaction()throws DBException
@@ -534,8 +541,10 @@ public class DBAdapter extends RubyBasic {
     
     public void rollback()throws DBException
     {
-    	m_dbStorage.rollback();
-    	m_bInsideTransaction=false;
+    	m_nTransactionCounter--;
+
+    	if (m_nTransactionCounter == 0)    	
+    		m_dbStorage.rollback();
     	
     	Unlock();
     }
@@ -682,17 +691,28 @@ public class DBAdapter extends RubyBasic {
 	    		}
     		}
     		
-    		IDBResult rows = executeSQL(v.toStr(), values);
-    		RubyString[] colNames = getColNames(rows);
+		    setUIWaitDB(true);
+		    Lock();
+    		
+    		try{
+    			IDBResult rows = executeSQL(v.toStr(), values);
+    		
+	    		RubyString[] colNames = getColNames(rows);
+	    		
+	    		for( ; !rows.isEnd(); rows.next() )
+	    		{
+	    			RubyHash row = ObjectFactory.createHash();
+	    			for ( int nCol = 0; nCol < rows.getColCount(); nCol ++ )
+	    				row.add( colNames[nCol], rows.getRubyValueByIdx(nCol) );
+	    			
+	    			res.add( row );
+	    		}
+			}finally
+			{
+				setUIWaitDB(false);
+				Unlock();
+			}
     		
-    		for( ; !rows.isEnd(); rows.next() )
-    		{
-    			RubyHash row = ObjectFactory.createHash();
-    			for ( int nCol = 0; nCol < rows.getColCount(); nCol ++ )
-    				row.add( colNames[nCol], rows.getRubyValueByIdx(nCol) );
-    			
-    			res.add( row );
-    		}
 		}catch(Exception e)
 		{
     		LOG.ERROR("execute failed.", e);
@@ -722,7 +742,7 @@ public class DBAdapter extends RubyBasic {
     
     private RubyValue rb_start_transaction() {
     	try{
-    		setUnlockDB(true);
+    		setUIWaitDB(true);
     		startTransaction();
     	}catch( Exception e ){
     		LOG.ERROR("start_transaction failed.", e);
@@ -808,6 +828,19 @@ public class DBAdapter extends RubyBasic {
 			protected RubyValue run(RubyValue receiver, RubyValue arg, RubyBlock block ){
 				return ((DBAdapter)receiver).rb_destroy_table(arg);}
 		});
+		klass.defineMethod( "is_ui_waitfordb", new RubyNoArgMethod(){ 
+			protected RubyValue run(RubyValue receiver, RubyBlock block )
+			{
+				try{
+					boolean bRes = ((DBAdapter)receiver).isUIWaitDB();
+					
+					return ObjectFactory.createBoolean(bRes);
+		    	}catch( Exception e ){
+		    		LOG.ERROR("is_ui_waitfordb failed.", e);
+		    		throw (e instanceof RubyException ? (RubyException)e : new RubyException(e.getMessage()));
+		    	}
+			}
+		});
 		
 	}