rhodes 2.0.0.beta7 → 2.0.0.beta8

data/platform/shared/sync/SyncEngine.cpp

@@ -361,10 +361,10 @@ void CSyncEngine::processServerSources(String strSources)
 {
     if ( strSources.length() > 0 )
     {
-        NetResponse(resp,getNet().pushData( getNet().resolveUrl("/system/loadserversources"), strSources, null ));
+        /*NetResponse(resp,getNet().pushData( getNet().resolveUrl("/system/loadserversources"), strSources, null ));
         loadAllSources();
 
-        rho_db_init_attr_manager();
+        rho_db_init_attr_manager(); */
     }
 }
 
@@ -377,6 +377,7 @@ boolean CSyncEngine::resetClientIDByNet(const String& strClientID)//throws Excep
 
     NetResponse( resp, getNet().pullData(getProtocol().getClientResetUrl(strClientID), this) );
 
+
 /*    processServerSources("{\"server_sources\":[{\"name\":\"Product\",\"partition\":\"application\",\"source_id\":\"2\",\"sync_priority\":\"0\","
         "\"schema_version\":\"7.0\",\"schema\":{"
         "\"columns\":[\'brand\',\'created_at\',\'name\',\'price\',\'quantity\',\'sku\',\'updated_at\']"*/
@@ -428,7 +429,7 @@ String CSyncEngine::requestClientIDByNet()
 
         CJSONEntry oJsonEntry(szData);
 
-        if (oJsonEntry.hasName("server_sources") )
+        if (oJsonEntry.hasName("sources") )
             processServerSources(szData);
 
         CJSONEntry oJsonObject = oJsonEntry.getEntry("client");
@@ -623,6 +624,17 @@ void CSyncEngine::syncAllSources()
 
 void CSyncEngine::login(String name, String password, String callback)
 {
+/*
+    processServerSources(
+        "{\"sources\":[{ \"name\":\"ProductEx\", "
+        "\"sync_type\":\"incremental\", \"partition\":\"application\", \"source_id\":\"7\","
+        " \"sync_priority\":\"0\", \"model_type\":\"fixed_schema\", "
+        " \"schema\":{\"property\":{\"brand\":\"string\", \"price\":\"string\", \"quantity\":\"string\", \"name\":\"string\", "
+        " \"image_url\":\"blob\", \"image_url_ex\":{\"blob\":\"1\", \"server_overwrite\":\"1\"}}, "
+        " \"index\":[{\"by_brand_price1\":[\"brand\", \"price\"]}, {\"by_quantity1\":[\"quantity\"]}], \"unique_index\":[{\"by_name1\":[\"name\"]}]}, "
+        " \"belongs_to\":{\"brand\":\"Customer\"}, "
+        " \"schema_version\":\"1.0\"}]}");
+*/
     PROF_START("Login");
 	//try {
 

data/platform/shared/sync/SyncEngine.h

@@ -69,7 +69,7 @@ public:
     ESyncState getState()const{ return m_syncState; }
     boolean isContinueSync()const{ return m_syncState != esExit && m_syncState != esStop; }
 	boolean isSyncing()const{ return m_syncState == esSyncAllSources || m_syncState == esSyncSource; }
-    void stopSync(){ if (isContinueSync()){ setState(esStop); m_NetRequest->cancel();} }
+    void stopSync(){ if (isContinueSync()){ setState(esStop); if(m_NetRequest) m_NetRequest->cancel();} }
     void stopSyncByUser(){ m_bStopByUser = true; stopSync(); }
     void exitSync(){ setState(esExit); m_NetRequest->cancel(); }
     boolean isStoppedByUser(){ return m_bStopByUser; }

data/platform/shared/sync/SyncThread.cpp

@@ -31,13 +31,12 @@ CSyncThread* CSyncThread::m_pInstance = 0;
     m_pInstance = 0;
 }
 
-CSyncThread::CSyncThread(common::IRhoClassFactory* factory) : CRhoThread(factory)
+CSyncThread::CSyncThread(common::IRhoClassFactory* factory) : CThreadQueue(factory)
 {
-    m_nPollInterval = SYNC_POLL_INTERVAL_SECONDS;
-    if( RHOCONF().isExist("sync_poll_interval") )
-        m_nPollInterval = RHOCONF().getInt("sync_poll_interval");
+    CThreadQueue::setLogCategory(getLogCategory());
 
-    m_ptrFactory = factory;
+    if( RHOCONF().isExist("sync_poll_interval") )
+        setPollInterval(RHOCONF().getInt("sync_poll_interval"));
 
     m_oSyncEngine.setFactory(factory);
 
@@ -55,36 +54,7 @@ CSyncThread::~CSyncThread(void)
     LOG(INFO) + "Sync engine thread shutdown";
 }
 
-void CSyncThread::addSyncCommand(CSyncCommand* pSyncCmd)
-{ 
-    if ( RHOCONF().getString("syncserver").length() == 0 )
-        return;
-
-   	LOG(INFO) + "addSyncCommand: " + (*pSyncCmd).m_nCmdCode;
-	{
-        synchronized(m_mxStackCommands);
-
-		boolean bExist = false;
-		for ( int i = 0; i < (int)m_stackCommands.size(); i++ )
-		{
-			if ( m_stackCommands.get(i)->equals(*pSyncCmd) )
-			{
-				bExist = true;
-				break;
-			}
-		}
-		
-		if ( !bExist )
-    		m_stackCommands.add(pSyncCmd);
-	}
-
-    if ( getSyncEngine().isNoThreadedMode() )
-        processCommands();
-    else
-	    stopWait(); 
-}
-
-int CSyncThread::getLastSyncInterval()
+int CSyncThread::getLastPollInterval()
 {
     uint64 nowTime = CLocalTime().toULong();
 	
@@ -100,63 +70,12 @@ int CSyncThread::getLastSyncInterval()
 	return latestTimeUpdated > 0 ? (int)(nowTime-latestTimeUpdated) : 0;
 }
 
-void CSyncThread::run()
-{
-	LOG(INFO) + "Starting sync engine main routine...";
-
-	int nLastSyncInterval = getLastSyncInterval();
-	while( m_oSyncEngine.getState() != CSyncEngine::esExit )
-	{
-        unsigned int nWait = m_nPollInterval > 0 ? m_nPollInterval : SYNC_POLL_INTERVAL_INFINITE;
-
-        if ( m_nPollInterval > 0 && nLastSyncInterval > 0 )
-        {
-            int nWait2 = m_nPollInterval - nLastSyncInterval;
-            if ( nWait2 <= 0 )
-                nWait = SYNC_STARTUP_INTERVAL_SECONDS;
-            else
-                nWait = nWait2;
-        }
-
-        if ( nWait >= 0 && m_oSyncEngine.getState() != CSyncEngine::esExit && 
-		     isNoCommands() )
-		{
-		    LOG(INFO) + "Sync engine blocked for " + nWait + " seconds...";
-            wait(nWait);
-        }
-        nLastSyncInterval = 0;
-
-        if ( m_oSyncEngine.getState() != CSyncEngine::esExit )
-    		processCommands();
-	}
-}
-
-boolean CSyncThread::isNoCommands()
-{
-	boolean bEmpty = false;
-	synchronized(m_mxStackCommands)
-    {		
-		bEmpty = m_stackCommands.isEmpty();
-	}
-
-	return bEmpty;
-}
-
 void CSyncThread::processCommands()//throws Exception
 {
     if ( isNoCommands() )
-        addSyncCommand(new CSyncCommand(scNone,false));
+        addQueueCommand(new CSyncCommand(scNone,false));
 
-	while(!isNoCommands())
-	{
-		common::CAutoPtr<CSyncCommand> pSyncCmd = null;
-    	{
-        	synchronized(m_mxStackCommands);
-    		pSyncCmd = (CSyncCommand*)m_stackCommands.removeFirst();
-    	}
-		
-		processCommand(*pSyncCmd);
-	}
+    CThreadQueue::processCommands();
 }
 
 void CSyncThread::checkShowStatus(CSyncCommand& oSyncCmd)
@@ -167,12 +86,13 @@ void CSyncThread::checkShowStatus(CSyncCommand& oSyncCmd)
 		//m_statusListener.createStatusPopup(RhoRuby.getMessageText("syncronizing_data"));
 }	
 
-void CSyncThread::processCommand(CSyncCommand& oSyncCmd)
+void CSyncThread::processCommand(CQueueCommand* pCmd)
 {
+    CSyncCommand& oSyncCmd = *((CSyncCommand*)pCmd);
     switch(oSyncCmd.m_nCmdCode)
     {
     case scNone:
-        if ( m_nPollInterval )
+        if ( getPollInterval() )
         {
             checkShowStatus(oSyncCmd);
             m_oSyncEngine.doSyncAllSources();
@@ -182,8 +102,6 @@ void CSyncThread::processCommand(CSyncCommand& oSyncCmd)
         checkShowStatus(oSyncCmd);
         m_oSyncEngine.doSyncAllSources();
         break;
-    case scChangePollInterval:
-        break;
     case scSyncOne:
         {
 			checkShowStatus(oSyncCmd);
@@ -211,11 +129,10 @@ void CSyncThread::processCommand(CSyncCommand& oSyncCmd)
 
 void CSyncThread::setPollInterval(int nInterval)
 { 
-    m_nPollInterval = nInterval; 
-    if ( m_nPollInterval == 0 )
+    if ( nInterval == 0 )
         m_oSyncEngine.stopSync();
 
-    addSyncCommand( new CSyncCommand(scChangePollInterval,false) );
+    CThreadQueue::setPollInterval(nInterval);
 }
 
 };
@@ -232,14 +149,14 @@ void rho_sync_destroy()
 	
 void rho_sync_doSyncAllSources(int show_status_popup)
 {
-    CSyncThread::getInstance()->addSyncCommand(new CSyncThread::CSyncCommand(CSyncThread::scSyncAll,show_status_popup!=0));
+    CSyncThread::getInstance()->addQueueCommand(new CSyncThread::CSyncCommand(CSyncThread::scSyncAll,show_status_popup!=0));
     //rho_sync_doSyncSourceByUrl("http://dev.rhosync.rhohub.com/apps/SugarCRM/sources/SugarAccounts");
 }
 
 void rho_sync_doSyncSource(unsigned long nSrcID,int show_status_popup)
 {
     CRhoRubyStringOrInt oSrcID = rho_ruby_getstringorint(nSrcID);
-    CSyncThread::getInstance()->addSyncCommand(new CSyncThread::CSyncCommand(CSyncThread::scSyncOne, oSrcID.m_szStr, (int)oSrcID.m_nInt, show_status_popup!=0 ) );
+    CSyncThread::getInstance()->addQueueCommand(new CSyncThread::CSyncCommand(CSyncThread::scSyncOne, oSrcID.m_szStr, (int)oSrcID.m_nInt, show_status_popup!=0 ) );
 }	
 
 void rho_sync_stop()
@@ -271,7 +188,7 @@ void rho_sync_doSearch(unsigned long ar_sources, const char *from, const char *p
     rho::Vector<rho::String> arSources;
     rho_ruby_enum_strary(ar_sources, source_iter, &arSources);
 
-    CSyncThread::getInstance()->addSyncCommand(new CSyncThread::CSyncSearchCommand(from,params,arSources,sync_changes,nProgressStep) );
+    CSyncThread::getInstance()->addQueueCommand(new CSyncThread::CSyncSearchCommand(from,params,arSources,sync_changes,nProgressStep) );
 }	
 
 void rho_sync_doSyncSourceByUrl(const char* szSrcUrl)
@@ -289,7 +206,7 @@ void rho_sync_doSyncSourceByUrl(const char* szSrcUrl)
         strName = szLastSlash ? szLastSlash + 1 : szSrcUrl;
 
     //TODO: save query params
-    CSyncThread::getInstance()->addSyncCommand(new CSyncThread::CSyncCommand(CSyncThread::scSyncOne, strName, (int)0, false ) );
+    CSyncThread::getInstance()->addQueueCommand(new CSyncThread::CSyncCommand(CSyncThread::scSyncOne, strName, (int)0, false ) );
 }	
 
 void rho_sync_set_pollinterval(int nInterval)
@@ -306,13 +223,13 @@ void rho_sync_set_syncserver(char* syncserver)
     if ( syncserver && *syncserver )
         CSyncThread::getInstance()->start(CSyncThread::epLow);
     else
-        CSyncThread::getInstance()->stop(SYNC_WAIT_BEFOREKILL_SECONDS);
+        CSyncThread::getInstance()->stop(CSyncThread::SYNC_WAIT_BEFOREKILL_SECONDS);
 }
 
 void rho_sync_login(const char *name, const char *password, const char* callback)
 {
     rho_sync_stop();
-    CSyncThread::getInstance()->addSyncCommand(new CSyncThread::CSyncLoginCommand(name, password, callback) );
+    CSyncThread::getInstance()->addQueueCommand(new CSyncThread::CSyncLoginCommand(name, password, callback) );
 }
 
 int rho_sync_logged_in()

data/platform/shared/sync/SyncThread.h

@@ -5,26 +5,24 @@
 #include "logging/RhoLog.h"
 #include "db/DBAdapter.h"
 #include "sync/SyncEngine.h"
-#include "common/RhoThread.h"
+#include "common/ThreadQueue.h"
 
 namespace rho {
 namespace sync {
 
-#define SYNC_POLL_INTERVAL_SECONDS 300
-#define SYNC_POLL_INTERVAL_INFINITE (unsigned int)(-1)
-#define SYNC_WAIT_BEFOREKILL_SECONDS 3
-#define SYNC_STARTUP_INTERVAL_SECONDS 10
-
-class CSyncThread : public common::CRhoThread
+class CSyncThread : public common::CThreadQueue
 {
 public:
-    enum ESyncCommands{ scNone = 0, scSyncAll, scSyncOne, scChangePollInterval, scExit, scLogin, scSearchOne};
+    enum ESyncCommands{ scNone = 0, scSyncAll, scSyncOne, scLogin, scSearchOne};
 
 private:
 
     DEFINE_LOGCLASS;
+
 public:
-    class CSyncCommand
+    static const unsigned int SYNC_WAIT_BEFOREKILL_SECONDS  = 3;
+
+    class CSyncCommand : public CQueueCommand
     {
     public:
 	    int m_nCmdCode;
@@ -59,12 +57,29 @@ public:
             m_bShowStatus = bShowStatus;
 	    }
 
-	    boolean equals(const CSyncCommand& oSyncCmd)
+	    boolean equals(const CQueueCommand& cmd)
 	    {
+            const CSyncCommand& oSyncCmd = (const CSyncCommand&)cmd;
 		    return m_nCmdCode == oSyncCmd.m_nCmdCode && m_nCmdParam == oSyncCmd.m_nCmdParam &&
 			    m_strCmdParam == oSyncCmd.m_strCmdParam;
 	    }
 
+        String toString()
+        {
+            switch(m_nCmdCode)
+            {
+            case scSyncAll:
+                return "SyncAll";
+            case scSyncOne:
+                return "SyncOne";
+            case scLogin:
+                return "Login";
+            case scSearchOne:
+                return "Search";
+            }
+            return "Unknown";
+        }
+
     };
 
     class CSyncLoginCommand : public CSyncCommand
@@ -96,10 +111,6 @@ private:
     static CSyncThread* m_pInstance;
 
     CSyncEngine     m_oSyncEngine;
-    common::CAutoPtr<common::IRhoClassFactory> m_ptrFactory;
-	int           m_nPollInterval;
-   	common::CMutex m_mxStackCommands;
-	LinkedListPtr<CSyncCommand*> m_stackCommands;
 public:
     ~CSyncThread(void);
 
@@ -108,18 +119,15 @@ public:
     static CSyncThread* getInstance(){ return m_pInstance; }
     static CSyncEngine& getSyncEngine(){ return m_pInstance->m_oSyncEngine; }
 
-    void addSyncCommand(CSyncCommand* pSyncCmd);
-
-	virtual void run();
-
 	void setPollInterval(int nInterval);
 private:
     CSyncThread(common::IRhoClassFactory* factory);
-    int getLastSyncInterval();
 
-    void processCommands();
-    void processCommand(CSyncCommand& oSyncCmd);
-    boolean isNoCommands();
+    virtual int getLastPollInterval();
+    virtual void processCommand(CQueueCommand* pCmd);
+    virtual boolean isSkipDuplicateCmd() { return true; }
+
+    virtual void processCommands();
 
     void checkShowStatus(CSyncCommand& oSyncCmd);
 };

data/platform/wm/RhoLib/RhoLib.vcproj

@@ -873,6 +873,14 @@
 				RelativePath="..\..\shared\common\StringConverter.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\shared\common\ThreadQueue.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\shared\common\ThreadQueue.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\shared\common\Tokenizer.cpp"
 				>

data/platform/wm/rhodes/Rhodes.cpp

@@ -41,6 +41,10 @@ HREGNOTIFY g_hNotify = NULL;
 
 #endif
 
+#ifdef OS_WINDOWS
+String httpProxy;
+#endif
+
 class CRhodesModule : public CAtlExeModuleT< CRhodesModule >
 {
 public :
@@ -49,13 +53,24 @@ public :
 		TCHAR szTokens[] = _T("-/");
 		LPCTSTR lpszToken = FindOneOf(lpCmdLine, szTokens);
         getRhoRootPath();
+
 		while (lpszToken != NULL)
 		{
 			if (WordCmpI(lpszToken, _T("Restarting"))==0) {
 				m_nRestarting = 10;
 			}
+
 #if defined(OS_WINDOWS)
-			else if (wcsncmp(lpszToken, _T("approot"),7)==0) {
+			if (wcsncmp(lpszToken, _T("http_proxy"),10)==0) {
+				char *token = wce_wctomb(lpszToken);
+				char *proxy =parseToken(token,strlen(token));
+
+				httpProxy = proxy;
+
+				free(proxy);
+				free(token);
+
+			} else if (wcsncmp(lpszToken, _T("approot"),7)==0) {
 				char* token = wce_wctomb(lpszToken);
 				//parseToken will allocate extra byte at the end of the returned token value
 				char* path = parseToken( token, strlen(token) );
@@ -114,6 +129,12 @@ public :
 		rho_logconf_Init(m_strRootPath.c_str());
 		LOG(INFO) + "Rhodes started";
 
+#ifdef OS_WINDOWS
+		if (httpProxy.length() > 0)
+			parseHttpProxyURI(httpProxy);
+#endif
+			
+
         ::SetThreadPriority(GetCurrentThread(),10);
 
 		//Check for bundle directory is exists.
@@ -239,6 +260,127 @@ public :
         return m_strRootPath; 
     }
 
+	void parseHttpProxyURI(const rho::String &http_proxy)
+	{
+		// http://<login>:<passwod>@<host>:<port>
+		const char *default_port = "8080";
+
+		int index = http_proxy.find("http://", 0, 7);
+		if (index == string::npos) {
+			LOG(ERROR) + "http proxy url should starts with \"http://\"";
+			return;
+		}
+		index = 7;
+
+		enum {
+			ST_START,
+			ST_LOGIN,
+			ST_PASSWORD,
+			ST_HOST,
+			ST_PORT,
+			ST_FINISH
+		};
+
+		String token, login, password, host, port;
+		char c, state = ST_START, prev_state = state;
+		int length = http_proxy.length();
+
+		for (int i = index; i < length; i++) {
+			c = http_proxy[i];
+
+			switch (state) {
+			case ST_START:
+				if (c == '@') {
+					prev_state = state; state = ST_HOST;
+				} else if (c == ':') {
+					prev_state = state; state = ST_PASSWORD;
+				} else {
+					token +=c;
+					state = ST_HOST;
+				}
+				break;
+			case ST_HOST:
+				if (c == ':') {
+					host = token; token.clear();			
+					prev_state = state; state = ST_PORT;
+				} else if (c == '@') {
+					host = token; token.clear();		
+					prev_state = state;	state = ST_LOGIN;					
+				} else {
+					token += c;
+					if (i == (length - 1)) {
+						host = token; token.clear();								
+					}
+				}
+				break;
+			case ST_PORT:
+				if (c == '@') {
+					port = token; token.clear();			
+					prev_state = state; state = ST_LOGIN;
+				} else {
+					token += c;
+					if (i == (length - 1)) {
+						port = token; token.clear();
+					}
+				}
+				break;
+			case ST_LOGIN:
+				if (prev_state == ST_PORT || prev_state == ST_HOST) {
+					login    = host; host.clear();
+					password = port; port.clear();
+					prev_state = state; state = ST_HOST;
+					token += c;
+				} else {
+					token += c;
+					if (i == (length - 1)) {
+						login = token; token.clear();								
+					}
+				}
+				break;
+			case ST_PASSWORD:
+				if (c == '@') {
+					password = token; token.clear();			
+					prev_state = state; state = ST_HOST;
+				} else {
+					token += c;
+					if (i == (length - 1)) {
+						password = token; token.clear();								
+					}
+				}
+				break;
+			default:
+				;
+			}
+		}
+
+		LOG(INFO) + "Setting up HTTP proxy:";
+		LOG(INFO) + "URI: " + http_proxy;
+		LOG(INFO) + "HTTP proxy login    = " + login;
+		LOG(INFO) + "HTTP proxy password = " + password;
+		LOG(INFO) + "HTTP proxy host     = " + host;
+		LOG(INFO) + "HTTP proxy port     = " + port;
+	
+		if (host.length()) {
+			RHOCONF().setString ("http_proxy_host", host);
+
+			if (port.length()){
+				RHOCONF().setString ("http_proxy_port", port);
+			} else {
+				LOG(WARNING) + "there is no proxy port defined";
+			}
+
+			if (login.length())
+				RHOCONF().setString ("http_proxy_login", login);
+
+			if (password.length())
+				RHOCONF().setString ("http_proxy_password", password);
+
+		} else {
+			LOG(ERROR) + "empty host name in HTTP-proxy URL";
+		}
+
+	}
+
 private:
     CMainWindow m_appWindow;
     rho::String m_strRootPath;