rhodes 2.4.1 → 3.0.0.beta.1

data/platform/shared/logging/RhoLogConf.h

@@ -21,12 +21,16 @@ struct ILogSink{
 class LogSettings{
     LogSeverity m_nMinSeverity;
     bool        m_bLogToOutput;
+    bool        m_bLogToSocket;
 
     bool        m_bLogToFile;
     String      m_strLogFilePath;
 //    String      m_strLogConfFilePath;
     unsigned int m_nMaxLogFileSize;
 
+	String      m_strLogHost;
+    String      m_strLogPort;
+
     bool        m_bLogPrefix;
 
     String      m_strEnabledCategories, m_strDisabledCategories;
@@ -34,6 +38,7 @@ class LogSettings{
     ILogSink*   m_pFileSink;
     ILogSink*   m_pOutputSink;
     ILogSink*   m_pLogViewSink;
+    ILogSink*   m_pSocketSink;
 
     static common::CMutex m_FlushLock;
     static common::CMutex m_CatLock;
@@ -51,6 +56,9 @@ public:
     bool isLogToFile()const{ return m_bLogToFile;}
     void setLogToFile(bool bLogToFile){ m_bLogToFile = bLogToFile;}
 
+    bool isLogToSocket()const{ return m_bLogToSocket;}
+    void setLogToSocket(bool bLogToSocket){ m_bLogToSocket = bLogToSocket;}
+
     const String& getLogFilePath()const{ return m_strLogFilePath;}
     void setLogFilePath(const char* szLogFilePath);
 
@@ -63,6 +71,9 @@ public:
     bool isLogPrefix()const{ return m_bLogPrefix;}
     void setLogPrefix(bool bLogPrefix){ m_bLogPrefix = bLogPrefix;}
 
+	const String& getLogHost() const { return m_strLogHost; }
+	const String& getLogPort() const { return m_strLogPort; }
+
     void setEnabledCategories( const char* szCatList );
     void setDisabledCategories( const char* szCatList );
     const String& getEnabledCategories(){ return m_strEnabledCategories; }

data/platform/shared/logging/RhoLogSink.cpp

@@ -2,6 +2,7 @@
 
 #include "common/RhoFile.h"
 #include "common/StringConverter.h"
+#include "net/RawSocket.h"
 
 #if defined( OS_SYMBIAN )
 #include <e32debug.h>
@@ -132,4 +133,27 @@ void CLogOutputSink::writeLogMessage( String& strMsg )
     fflush(stdout);
 }
 
+CLogSocketSink::CLogSocketSink(const LogSettings& oSettings) 
+	: m_oLogConf(oSettings)
+	, m_logNetClient(0)
+{
+	m_hostName = oSettings.getLogHost();
+    m_hostPort = oSettings.getLogPort(); 
+}
+
+void CLogSocketSink::writeLogMessage( String& strMsg )
+{
+    if (!m_logNetClient)
+    {
+		m_logNetClient = new rho::net::RawSocket(m_hostName, m_hostPort);
+    }
+    
+    if (!m_logNetClient->isInit())
+    {
+         m_logNetClient->init();
+    }
+
+    m_logNetClient->send(strMsg);
+}
+        
 }

data/platform/shared/logging/RhoLogSink.h

@@ -2,6 +2,7 @@
 #define _RHOLOGSINK_H_
 
 #include "RhoLogConf.h"
+#include "net/RawSocket.h"
 
 namespace rho {
 namespace common {
@@ -33,13 +34,31 @@ class CLogOutputSink : public ILogSink{
     const LogSettings& m_oLogConf;
 
 public:
-    CLogOutputSink(const LogSettings& oSettings) : m_oLogConf(oSettings){}
+    CLogOutputSink(const LogSettings& oSettings) : m_oLogConf(oSettings){
+	}
 
     void writeLogMessage( String& strMsg );
     int getCurPos(){ return -1; }
     void clear(){}
 };
 
+
+class CLogSocketSink : public ILogSink{
+    const LogSettings& m_oLogConf;
+
+    rho::net::RawSocket *m_logNetClient;
+
+	String m_hostName;
+	String m_hostPort;
+public:
+    CLogSocketSink(const LogSettings& oSettings); 
+	virtual ~CLogSocketSink() { delete m_logNetClient; }
+
+    void writeLogMessage( String& strMsg );
+    int getCurPos(){ return -1; }
+    void clear(){}
+};
+  
 }
 
 #endif //_RHOLOGSINK_H_

data/platform/shared/net/HttpServer.cpp

@@ -83,7 +83,7 @@ static bool isfile(String const &path)
         const char *s;
         size_t len;
     } index_files[] = {
-        {"index_erb.iseq", 14},
+        {"index"RHO_ERB_EXT, strlen("index"RHO_ERB_EXT)},
         {"index.html", 10},
         {"index.htm", 9},
         {"index.php", 9},
@@ -376,7 +376,7 @@ bool CHttpServer::run()
         FD_ZERO(&readfds);
         FD_SET(m_listener, &readfds);
 
-        timeval tv = {0};
+        timeval tv = {0,0};
         unsigned long nTimeout = RHODESAPP().getTimer().getNextTimeout();
         tv.tv_sec = nTimeout/1000;
         tv.tv_usec = (nTimeout - tv.tv_sec*1000)*1000;
@@ -647,7 +647,9 @@ bool CHttpServer::process(SOCKET sock)
         send_response(create_response("500 Internal Error"));
         return false;
     }
-    
+
+    RAWLOG_INFO1("Process URI: '%s'", uri.c_str());
+
     return decide(method, uri, query, headers, body);
 }
 
@@ -863,8 +865,8 @@ bool CHttpServer::dispatch(String const &uri, Route &route)
     //check if there is controller.rb to run
 	struct stat st;
 
-    String newfilename = m_root + "/" + route.application + "/" + route.model + "/" + controllerName + "_controller.iseq";
-    String filename = m_root + "/" + route.application + "/" + route.model + "/controller.iseq";
+    String newfilename = m_root + "/" + route.application + "/" + route.model + "/" + controllerName + "_controller"RHO_RB_EXT;
+    String filename = m_root + "/" + route.application + "/" + route.model + "/controller"RHO_RB_EXT;
 
     //look for controller.rb or model_name_controller.rb
     if ((stat(filename.c_str(), &st) != 0 || !S_ISREG(st.st_mode)) && (stat(newfilename.c_str(), &st) != 0 || !S_ISREG(st.st_mode)))
@@ -1074,7 +1076,7 @@ bool CHttpServer::decide(String const &method, String const &uri, String const &
         String q = query.empty() ? "" : "?" + query;
         
         HeaderList headers;
-        headers.push_back(Header("Location", CFilePath::join( uri, "index_erb.iseq") + q));
+        headers.push_back(Header("Location", CFilePath::join( uri, "index"RHO_ERB_EXT) + q));
         
         send_response(create_response("301 Moved Permanently", headers));
         return false;

data/platform/shared/net/RawSocket.cpp

@@ -0,0 +1,130 @@
+#include "net/RawSocket.h"
+#include "common/RhodesApp.h"
+
+#include <algorithm>
+
+#if !defined(OS_WINDOWS) && !defined(OS_WINCE)
+#include <arpa/inet.h>
+#endif
+
+#if !defined(OS_WINCE)
+#include <common/stat.h>
+
+#ifdef EAGAIN
+#undef EAGAIN
+#endif
+#define EAGAIN EWOULDBLOCK
+
+#else
+
+#include "CompatWince.h"
+
+#if defined(OS_WINDOWS) || defined(OS_WINCE)
+typedef unsigned __int16 uint16_t;
+
+#  ifndef S_ISDIR
+#    define S_ISDIR(m) ((_S_IFDIR & m) == _S_IFDIR)
+#  endif
+
+#  ifndef S_ISREG
+#    define S_ISREG(m) ((_S_IFREG & m) == _S_IFREG)
+#  endif
+
+#  ifndef EAGAIN
+#    define EAGAIN WSAEWOULDBLOCK
+#  endif
+#endif
+
+#undef DEFAULT_LOGCATEGORY
+#define DEFAULT_LOGCATEGORY "RawSocket"
+
+namespace rho
+{
+namespace net
+{
+
+bool RawSocket::init()
+{
+    RAWTRACE("Init raw socket");
+    m_isInit = create();
+    return m_isInit;
+}
+
+bool RawSocket::create()
+{
+    RAWTRACE("Start create raw socket");
+    cleanup();
+
+    int iResult;
+    addrinfo *addrInfo = NULL, hints;
+
+    memset( &hints, 0, sizeof(hints) );
+    hints.ai_family   = AF_UNSPEC;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_protocol = IPPROTO_TCP;
+
+    RAWTRACE("Get host adress");
+
+    // Resolve the server address and port
+    iResult = getaddrinfo(m_hostName.c_str(), m_hostPort.c_str(), &hints, &addrInfo);
+
+    if (iResult != 0) {
+        RAWTRACE2("Unable to get addres info for host %s, port %s", m_hostName.c_str(), m_hostPort.c_str());
+        return false;
+    }
+
+    RAWTRACE("Create socket");
+    // Create a SOCKET for connecting to server
+    m_clientSocket = socket(addrInfo->ai_family, addrInfo->ai_socktype, addrInfo->ai_protocol);
+
+    if (m_clientSocket == INVALID_SOCKET) {
+        RAWTRACE2("Socket can`t create for host %s, port %s", m_hostName.c_str(), m_hostPort.c_str());
+        freeaddrinfo(addrInfo);
+        return false;
+    }
+
+    // Connect to server.
+    RAWTRACE("Connect to server");
+    iResult = connect(m_clientSocket, addrInfo->ai_addr, (int)addrInfo->ai_addrlen);
+
+    if (iResult == SOCKET_ERROR) {
+        RAWTRACE2("Can`t connect to host %s, port %s ", m_hostName.c_str(), m_hostPort.c_str());
+        cleanup();
+        return false;
+    }
+
+    freeaddrinfo(addrInfo);
+
+    RAWTRACE("End of socket creating");
+
+    return true;
+}
+
+bool RawSocket::send(const String& sendData)
+{
+    int iResult = 0;
+
+    // Send an initial buffer
+    iResult = ::send(m_clientSocket, sendData.c_str(), (int) sendData.size(), 0);
+
+    if (iResult == SOCKET_ERROR) 
+    {
+        RAWTRACE2("Data not send for host %s, port %s", m_hostName.c_str(), m_hostPort.c_str());
+        cleanup();
+        return false;
+    }
+
+    return true;
+}
+
+void RawSocket::cleanup()
+{
+    m_isInit = false;
+    closesocket(m_clientSocket);
+    m_clientSocket = INVALID_SOCKET;
+}
+
+} // namespace net
+} // namespace rho
+
+#endif

data/platform/shared/net/RawSocket.h

@@ -0,0 +1,74 @@
+#ifndef RHO_RAW_SOCKET_F5FFD21AD3EE463E850C5E2C789397BD
+#define RHO_RAW_SOCKET_F5FFD21AD3EE463E850C5E2C789397BD
+
+#include "common/RhoStd.h"
+#include "logging/RhoLog.h"
+
+#if !defined(OS_WINDOWS) && !defined(OS_WINCE)
+typedef int SOCKET;
+#  define INVALID_SOCKET -1
+#  define SOCKET_ERROR -1
+#  define RHO_NET_ERROR_CODE errno
+#  define closesocket close
+#else
+#  if defined(OS_WINCE)
+#    include <winsock2.h>
+#    include <ws2tcpip.h>
+#  endif
+#  define RHO_NET_ERROR_CODE ::WSAGetLastError()
+#endif
+
+namespace rho
+{
+namespace net
+{
+
+#if !defined(OS_WINCE)
+
+class RawSocket
+{
+public:
+    RawSocket(const String& host, const String& port)  {}
+    virtual ~RawSocket() {}
+
+    bool init() { return false; }
+
+    bool send(const String& sendData) { return false; }
+
+    bool isInit() const { return false; }
+};
+
+#else                 
+
+class RawSocket
+{
+private:
+    SOCKET m_clientSocket;
+
+    std::string m_hostName;
+    std::string m_hostPort;
+
+    bool m_isInit;
+public:
+    RawSocket(const String& host, const String& port) 
+         : m_hostName(host) , m_hostPort(port), m_isInit(false) {}
+    virtual ~RawSocket() { cleanup(); }
+
+    bool init();
+
+    bool send(const String& sendData);
+
+    bool isInit() const { return m_isInit; }
+
+private:
+    bool create();
+
+    void cleanup();
+};
+
+#endif
+
+} // end of net
+} // end if rho
+
+#endif

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

@@ -135,6 +135,7 @@ void rho_ruby_stop_threadidle()
 
 void RhoRubyStart()
 {
+    const char* szRoot = rho_native_rhopath();
     //VALUE moduleRhom;
 #ifdef HAVE_LOCALE_H
     setlocale(LC_CTYPE, "");
@@ -155,7 +156,26 @@ void RhoRubyStart()
 #endif
     //rb_funcall(rb_mGC, rb_intern("stress="), 1, Qtrue);
 
-    ruby_init_loadpath(rho_native_rhopath());
+    ruby_init_loadpath(szRoot);
+#ifdef RHODES_EMULATOR
+    {
+        VALUE load_path = GET_VM()->load_path;
+        char* app_path = malloc(strlen(szRoot)+100);
+
+        rb_ary_clear(load_path);
+
+        strcpy(app_path, szRoot);
+        strcat(app_path, "app");
+
+        rb_ary_push(load_path, rb_str_new2(app_path) );
+
+        strcpy(app_path, rho_rhodesapp_getrhodespath());
+        strcat(app_path, "\\lib\\framework");
+        rb_ary_push(load_path, rb_str_new2(app_path) );
+    }
+
+#endif
+
     Init_strscan();
     Init_sqlite3_api();
     Init_GeoLocation();
@@ -189,7 +209,14 @@ void RhoRubyStart()
     gettimeofday (&start, NULL);
 #endif
 
+#ifdef RHODES_EMULATOR
+    rb_const_set(rb_cObject, rb_intern("RHODES_EMULATOR"), Qtrue);
+    require_compiled(rb_str_new2("rhoframework"), &framework );
+    framework = rb_const_get(rb_cObject,rb_intern("RHO_FRAMEWORK"));
+#else
     require_compiled(rb_str_new2("rhoframework"), &framework );
+#endif //RHODES_EMULATOR
+
     if ( framework == 0 || framework == Qnil )
     {
         RAWLOG_FATAL("RHO framework creating failed. Application will exit.");
@@ -227,6 +254,15 @@ void RhoRubyStart()
 
     }
 }
+int rho_ruby_is_enabled_eval()
+{
+#ifdef RHODES_EMULATOR
+    return 1;
+#else
+    return 0;
+#endif
+}
+
 void RhoRubyInitApp()
 {
     rb_funcall(framework, initApp_mid, 0);

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

@@ -29,6 +29,13 @@ VALUE __rhoGetCurrentDir(void)
     return rb_str_new2(rho_native_rhopath());
 }
 
+#ifdef RHODES_EMULATOR
+VALUE __rhoGetRhodesDir(void)
+{
+    return rb_str_new2(rho_rhodesapp_getrhodespath());
+}
+#endif// RHODES_EMULATOR
+
 VALUE
 rb_f_eval_compiled(int argc, VALUE *argv, VALUE self)
 {
@@ -120,11 +127,6 @@ rb_require_compiled(VALUE obj, VALUE fname)
 
     return result;
 }
-
-static const char *const loadable_ext[] = {
-    ".iseq",
-    0
-};
 /*
 static char* g_curAppPath = 0;
 void RhoSetCurAppPath(char* path){
@@ -185,16 +187,38 @@ static VALUE checkRhoBundleInPath(VALUE fname)
     return rb_str_new2(slash1+1);
 }
 
+static VALUE check_extension(VALUE res, VALUE fname)
+{
+    char* szSlash = strchr(RSTRING_PTR(fname), '/');
+    if (!szSlash)
+        szSlash = strchr(RSTRING_PTR(fname), '\\');
+    if (!szSlash)
+        rb_str_append(res,fname);
+    else
+        rb_str_cat(res, RSTRING_PTR(fname), szSlash-RSTRING_PTR(fname));
+
+    rb_str_cat2(res,"\\");
+    rb_str_append(res,fname);
+    rb_str_cat2(res,RHO_RB_EXT);
+
+    return eaccess(RSTRING_PTR(res), R_OK) == 0 ? res : 0;
+}
+
 static VALUE find_file(VALUE fname)
 {
     VALUE res;
     int nOK = 0;
 
     //RAWLOG_INFO1("find_file: fname: %s", RSTRING_PTR(fname));
+#ifdef RHODES_EMULATOR
+    if ( strncmp(RSTRING_PTR(fname), rho_rhodesapp_getrhodespath(), strlen(rho_rhodesapp_getrhodespath())) == 0 )
+        res = fname;
+    else
+#endif
 
     if ( strncmp(RSTRING_PTR(fname), rho_native_rhopath(), strlen(rho_native_rhopath())) == 0 ){
         res = rb_str_dup(fname);
-        rb_str_cat(res,".iseq",5);
+        rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT));
         //RAWLOG_INFO1("find_file: res: %s", RSTRING_PTR(res));
     }else{
         int i = 0;
@@ -211,7 +235,7 @@ static VALUE find_file(VALUE fname)
                 res = rb_str_dup(dir);
                 rb_str_cat(res,"/",1);
                 rb_str_cat(res,RSTRING_PTR(fname1),RSTRING_LEN(fname1));
-                rb_str_cat(res,".iseq",5);
+                rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT));
                 //RAWLOG_INFO1("find_file: check file: %s", RSTRING_PTR(res));
 
                 if( eaccess(RSTRING_PTR(res), R_OK) == 0 ){
@@ -220,20 +244,43 @@ static VALUE find_file(VALUE fname)
                 }
             }
             if ( !nOK )
+            {
+#ifdef RHODES_EMULATOR
+                //check for extensions
+                res = rb_str_new2(rho_rhodesapp_getrhodespath() );
+                rb_str_cat2(res,"\\lib\\extensions\\");
+
+                res = check_extension(res, fname);
+                if ( !res )
+                {
+                    res = rb_str_new2(rho_native_rhopath() );
+                    rb_str_cat2(res,"\\extensions\\");
+
+                    res = check_extension(res, fname);
+                }
+
+                if( res )
+                    nOK = 1;
+                else
+                    return 0;
+#else
                 return 0;
+#endif
+                
+            }
         } /*else {
             dir = RARRAY_PTR(load_path)[RARRAY_LEN(load_path)-1];
 
             res = rb_str_dup(dir);
             rb_str_cat(res,"/",1);
             rb_str_cat(res,RSTRING_PTR(fname),RSTRING_LEN(fname));
-            rb_str_cat(res,".iseq",5);
+            rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT));
 
             if ( g_curAppPath != 0 && eaccess(RSTRING_PTR(res), R_OK) != 0 ){
                 res = rb_str_new2(g_curAppPath);
                 rb_str_cat(res,"/",1);
                 rb_str_cat(res,RSTRING_PTR(fname),RSTRING_LEN(fname));
-                rb_str_cat(res,".iseq",5);
+                rb_str_cat(res,RHO_RB_EXT,strlen(RHO_RB_EXT));
             }
         } */
     }
@@ -312,29 +359,35 @@ VALUE require_compiled(VALUE fname, VALUE* result)
     if ( isAlreadyLoaded(fname) == Qtrue )
         goto RCompExit;
 
-    //RAWLOG_INFO1("find_file: %s", RSTRING_PTR(fname));
     path = find_file(fname);
 
     if ( path != 0 )
     {
         VALUE seq;
 
-//        if ( isAlreadyLoaded(path) == Qtrue )
-//            return Qtrue;
-
         RAWLOG_INFO1("require_compiled: %s", szName1);
 
         //optimize require
         //rb_ary_push(GET_VM()->loaded_features, path);
         rb_ary_push(GET_VM()->loaded_features, fname);
 
+#ifdef RHODES_EMULATOR
+        if ( strstr( RSTRING_PTR(path), ".rb") == 0 )
+            rb_str_cat(path,".rb",3);
+
+        GET_VM()->src_encoding_index = rb_utf8_encindex();
+        rb_load(path, 0);
+
+        if ( strncmp( RSTRING_PTR(path), rho_native_rhopath(), strlen(rho_native_rhopath()) ) == 0 )
+            rb_ary_delete(GET_VM()->loaded_features, fname);
+#else
         rb_gc_disable();
         seq = loadISeqFromFile(path);
         rb_gc_enable();
 
         //*result = rb_funcall(seq, rb_intern("eval"), 0 );
         *result = rb_iseq_eval(seq);
-
+#endif
         goto RCompExit;
     }
 
@@ -386,7 +439,11 @@ rb_obj_rhom_init(VALUE obj, VALUE iv)
 void Init_RhoSupport()
 {
 	rb_define_global_function("require", rb_require_compiled, 1);
+#ifndef RHODES_EMULATOR
 	rb_define_global_function("eval_compiled_file", rb_f_eval_compiled, -1);
+#else
+    rb_define_global_function("__rhoGetRhodesDir", __rhoGetRhodesDir, 0);
+#endif
 	rb_define_global_function("__rhoGetCurrentDir", __rhoGetCurrentDir, 0);
 	rb_define_global_function("load", rb_require_compiled, 1);
 	rb_define_global_function("__rhoGetCallbackObject", __rhoGetCallbackObject, 1);
@@ -400,14 +457,10 @@ void Init_RhoSupport()
 
 static void Init_RhoBlobs()
 {
-  VALUE path = rb_str_new2(rho_rhodesapp_getblobsdirpath());
-
-  RAWLOG_INFO1("Init_RhoBlobs: %s", RSTRING_PTR(path) );
-
-  if ( rb_funcall(rb_cDir, rb_intern("exist?"), 1, path)==Qfalse )
-    rb_funcall(rb_cDir, rb_intern("mkdir"), 1, path);
+    const char* szBlobPath = rho_rhodesapp_getblobsdirpath();
+    RAWLOG_INFO1("Init_RhoBlobs: %s", szBlobPath );
 
-  RAWLOG_INFO("Init_RhoBlobs: done");
+    rho_file_recursive_createdir(szBlobPath, rho_native_rhopath());
 }
 
 void rhoRubyLogWithSeverity(int severity, VALUE category, VALUE str) {