rhodes 2.1.0 → 2.2.0.beta.1

data/platform/shared/logging/RhoLogConf.cpp

@@ -32,16 +32,28 @@ LogSettings::~LogSettings(){
     delete m_pOutputSink;
 }
 
-void LogSettings::getLogTextW(StringW& strTextW){
+void LogSettings::getLogTextW(StringW& strTextW)
+{
+    boolean bOldSaveToFile = isLogToFile();
+    setLogToFile(false);
+
     common::CRhoFile oFile;
     if ( oFile.open( getLogFilePath().c_str(), common::CRhoFile::OpenReadOnly) )
         oFile.readStringW(strTextW);
+
+    setLogToFile(bOldSaveToFile);
 }
 
-void LogSettings::getLogText(String& strText){
+void LogSettings::getLogText(String& strText)
+{
+    boolean bOldSaveToFile = isLogToFile();
+    setLogToFile(false);
+
     common::CRhoFile oFile;
     if ( oFile.open( getLogFilePath().c_str(), common::CRhoFile::OpenReadOnly) )
         oFile.readString(strText);
+
+    setLogToFile(bOldSaveToFile);
 }
 
 int LogSettings::getLogTextPos()
@@ -209,7 +221,7 @@ void rho_logconf_setDisabledCategories(const char* categories) {
 	LOGCONF().setDisabledCategories(categories);
 }
 
-void rho_logconf_setSeveity(int nLevel) {
+void rho_logconf_setSeverity(int nLevel) {
 	LOGCONF().setMinSeverity(nLevel);
 }
 
@@ -230,6 +242,11 @@ void rho_conf_set_property_by_name(char* name, char* value)
     LOGCONF().loadFromConf(RHOCONF());
 }
 
+void rho_conf_clean_log()
+{
+    LOGCONF().clearLog();
+}
+
 #ifndef RHO_NO_RUBY
 VALUE rho_conf_get_property_by_name(char* name)
 {
@@ -237,6 +254,44 @@ VALUE rho_conf_get_property_by_name(char* name)
 
     return rho_ruby_create_string(szValue);
 }
+
+VALUE rho_conf_read_log(int limit)
+{
+    VALUE res = rho_ruby_create_string("");
+    bool bOldSaveToFile = LOGCONF().isLogToFile();
+    LOGCONF().setLogToFile(false);
+
+    rho::common::CRhoFile oFile;
+    if ( oFile.open( LOGCONF().getLogFilePath().c_str(), rho::common::CRhoFile::OpenReadOnly) )
+    {
+        int nFileSize = oFile.size();
+        int nPos = LOGCONF().getLogTextPos();
+        int nMaxSize = nFileSize > nPos ? nFileSize : nPos;
+        if ( limit <= 0 || limit > nMaxSize)
+            limit = nMaxSize;
+
+        res = rho_ruby_create_string_withlen(limit);
+        char* szStr = getStringFromValue(res);
+
+        if ( limit <= nPos )
+        {
+            oFile.setPosTo(nPos-limit);
+            oFile.readData(szStr,0,limit);
+        }else
+        {
+            oFile.setPosTo(nFileSize-(limit-nPos));
+            int nRead = oFile.readData(szStr,0,limit);
+
+            oFile.setPosTo(0);
+            oFile.readData(szStr,nRead,limit-nRead);
+        }
+
+    }
+
+    LOGCONF().setLogToFile(bOldSaveToFile);
+
+    return res;
+}
 #endif //RHO_NO_RUBY
 
 }

data/platform/shared/logging/RhoLogConf.h

@@ -111,11 +111,13 @@ int   rho_logconf_getSeverity();
 
 void rho_logconf_setEnabledCategories(const char* categories);
 void rho_logconf_setDisabledCategories(const char* categories);
-void rho_logconf_setSeveity(int nLevel);
+void rho_logconf_setSeverity(int nLevel);
 	
 void rho_logconf_saveSettings();
 void rho_logconf_freeString(char* str);
 
+void rho_conf_clean_log();
+
 #ifdef __cplusplus
 }
 #endif //__cplusplus

data/platform/shared/net/CURLNetRequest.cpp

@@ -53,7 +53,7 @@ public:
 
     virtual boolean isOK()
     {
-        return m_nRespCode == 200;
+        return m_nRespCode == 200 || m_nRespCode == 206;
     }
     
     virtual boolean isUnathorized()
@@ -183,7 +183,11 @@ INetResponse* CURLNetRequest::doPull(const char* method, const String& strUrl,
         long statusCode = 0;
         if (curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &statusCode) != 0)
             statusCode = 500;
-        if (statusCode == 206) {
+		
+		if (statusCode == 416 )
+		{
+			//Do nothing, file is already loaded
+		}else if (statusCode == 206) {
             if (oFile)
                 oFile->write(strRespChunk.c_str(), strRespChunk.size());
             else
@@ -222,7 +226,7 @@ INetResponse* CURLNetRequest::pullFile(const String& strUrl, const String& strFi
     RAWLOG_INFO2("Pull file. Url: %s; File: %s", strUrl.c_str(), strFilePath.c_str());
     
     common::CRhoFile oFile;
-    if ( !oFile.open(strFilePath.c_str(),common::CRhoFile::OpenForWrite) ) 
+    if ( !oFile.open(strFilePath.c_str(),common::CRhoFile::OpenForAppend) ) 
     {
         RAWLOG_ERROR1("pullFile: cannot create file: %s", strFilePath.c_str());
         return new CURLNetResponseImpl("", nRespCode);
@@ -356,14 +360,18 @@ INetResponse* CURLNetRequest::pushFile(const String& strUrl, const String& strFi
 
 int CURLNetRequest::getResponseCode(CURLcode err, const String& strRespBody, IRhoSession* oSession )	
 {    
-    if (err != CURLE_OK)
-        return -1;
+    //if (err != CURLE_OK)
+    //    return -1;
 	
     long statusCode = 0;
     CURL *curl = m_curl.curl();
     if (curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &statusCode) != 0)
         statusCode = 500;
     
+	if (statusCode == 416) {
+		statusCode = 206;
+	}
+	
     if (statusCode >= 400) {
         RAWLOG_ERROR2("Request failed. HTTP Code: %d returned. HTTP Response: %s",
                       (int)statusCode, strRespBody.c_str());
@@ -484,6 +492,9 @@ curl_slist *CURLNetRequest::CURLHolder::set_options(const char *method, const St
         curl_easy_setopt(m_curl, CURLOPT_HTTPGET, 1);
     else if (strcasecmp(method, "POST") == 0)
         curl_easy_setopt(m_curl, CURLOPT_POST, 1);
+	else
+        curl_easy_setopt(m_curl, CURLOPT_CUSTOMREQUEST, method);
+
     curl_easy_setopt(m_curl, CURLOPT_URL, strUrl.c_str());
     
     // Just to enable cookie parser
@@ -655,7 +666,7 @@ CURLcode CURLNetRequest::CURLHolder::perform()
             result = msg->data.result;
         if (result == CURLE_OK && noactivity >= timeout)
             result = CURLE_OPERATION_TIMEDOUT;
-        if (result == CURLE_OK)
+        if (result == CURLE_OK || result == CURLE_PARTIAL_FILE)
             RAWTRACE("Operation completed successfully");
         else
             RAWLOG_ERROR2("Operation finished with error %d: %s", (int)result, curl_easy_strerror(result));

data/platform/shared/net/HttpServer.cpp

@@ -16,6 +16,8 @@
 #endif
 #define EAGAIN EWOULDBLOCK
 
+char *strerror(int errnum ){return "";}
+
 #endif
 
 #if defined(OS_WINDOWS) || defined(OS_WINCE)
@@ -48,8 +50,12 @@ using namespace rho::common;
 
 IMPLEMENT_LOGCLASS(CHttpServer, "HttpServer");
 
-static size_t const FILE_BUF_SIZE = 65536;
-    
+#if defined(OS_WINDOWS) || defined(OS_WINCE)
+static size_t const FILE_BUF_SIZE = 64*1024;
+#else
+static size_t const FILE_BUF_SIZE = 256*1024;
+#endif
+
 static bool isid(String const &s)
 {
     return s.size() > 2 && s[0] == '{' && s[s.size() - 1] == '}';
@@ -154,6 +160,7 @@ static String get_mime_type(String const &path)
         {".torrent",	8,	"application/x-bittorrent"      },
         {".wav",		4,	"audio/x-wav"                   },
         {".mp3",		4,	"audio/x-mp3"                   },
+        {".mp4",        4,  "video/mp4"                     },
         {".mid",		4,	"audio/mid"                     },
         {".m3u",		4,	"audio/x-mpegurl"               },
         {".ram",		4,	"audio/x-pn-realaudio"          },
@@ -232,22 +239,28 @@ static VALUE create_request_hash(String const &application, String const &model,
 }
 
 CHttpServer::CHttpServer(int port, String const &root)
-    :m_port(port), verbose(true)
+    :m_active(false), m_port(port), verbose(true)
 {
     m_root = CFilePath::normalizePath(root);
     m_strRhoRoot = m_root.substr(0, m_root.length()-5);
-	m_exit = true;
 }
 
 CHttpServer::~CHttpServer()
 {
 }
 
+void CHttpServer::close_listener()
+{
+    SOCKET l = m_listener;
+    m_listener = INVALID_SOCKET;
+    closesocket(l);
+}
+
 void CHttpServer::stop()
 {
-	m_exit = true;
-	RAWTRACE("Close listening socket");
-	closesocket(m_listener);
+    m_active = false;
+    RAWTRACE("Close listening socket");
+    close_listener();
 }
 
 void CHttpServer::register_uri(String const &uri, CHttpServer::callback_t const &callback)
@@ -279,8 +292,7 @@ bool CHttpServer::init()
 {
     RAWTRACE("Open listening socket...");
     
-    if (m_listener != INVALID_SOCKET)
-        closesocket(m_listener);
+    close_listener();
     m_listener = socket(AF_INET, SOCK_STREAM, 0);
     if (m_listener == INVALID_SOCKET) {
         RAWLOG_ERROR1("Can not create listener: %d", RHO_NET_ERROR_CODE);
@@ -290,6 +302,7 @@ bool CHttpServer::init()
     int enable = 1;
     if (setsockopt(m_listener, SOL_SOCKET, SO_REUSEADDR, (const char *)&enable, sizeof(enable)) == SOCKET_ERROR) {
         RAWLOG_ERROR1("Can not set socket option (SO_REUSEADDR): %d", RHO_NET_ERROR_CODE);
+        close_listener();
         return false;
     }
     
@@ -300,11 +313,13 @@ bool CHttpServer::init()
     sa.sin_addr.s_addr = INADDR_ANY;
     if (bind(m_listener, (const sockaddr *)&sa, sizeof(sa)) == SOCKET_ERROR) {
         RAWLOG_ERROR2("Can not bind to port %d: %d", m_port, RHO_NET_ERROR_CODE);
+        close_listener();
         return false;
     }
     
     if (listen(m_listener, 128) == SOCKET_ERROR) {
         RAWLOG_ERROR1("Can not listen on socket: %d", RHO_NET_ERROR_CODE);
+        close_listener();
         return false;
     }
     
@@ -318,17 +333,17 @@ bool CHttpServer::run()
     if (!init())
         return false;
     
-    m_exit = false;
+    m_active = true;
     
     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;
-		}
+        if (!m_active) {
+            RAWTRACE("Stop HTTP server");
+            return true;
+        }
         if (conn == INVALID_SOCKET) {
 #if !defined(OS_WINDOWS) && !defined(OS_WINCE)
             if (RHO_NET_ERROR_CODE == EINTR)
@@ -366,7 +381,7 @@ bool receive_request_test(ByteVector &request, int attempt)
 			data += "Host";
 			break;
 		case 3:
-			data += ": localhost\r\n";
+			data += ": 127.0.0.1\r\n";
 			data += "Content-Length: 4\r\n";
 			break;
 		case 4:
@@ -519,7 +534,7 @@ String CHttpServer::create_response(String const &reason, HeaderList const &hdrs
     snprintf(buf, sizeof(buf), "%d", m_port);
     
     HeaderList headers;
-    headers.push_back(Header("Host", String("localhost:") + buf));
+    headers.push_back(Header("Host", String("127.0.0.1:") + buf));
     headers.push_back(Header("Connection", "close"));
     std::copy(hdrs.begin(), hdrs.end(), std::back_inserter(headers));
     
@@ -798,7 +813,41 @@ bool CHttpServer::dispatch(String const &uri, Route &route)
     return true;
 }
 
-bool CHttpServer::send_file(String const &path)
+static bool parse_range(HttpHeaderList const &hdrs, size_t *pbegin, size_t *pend)
+{
+    for (HttpHeaderList::const_iterator it = hdrs.begin(), lim = hdrs.end(); it != lim; ++it) {
+        if (strcasecmp(it->name.c_str(), "range") != 0)
+            continue;
+        
+        const char *s = strstr(it->value.c_str(), "bytes=");
+        if (!s)
+            continue;
+        
+        s += 6; // size of "bytes=" string
+        
+        char *e;
+        
+        size_t begin = strtoul(s, &e, 10);
+        if (s == e)
+            begin = 0;
+        
+        if (*e != '-') // error
+            continue;
+        
+        s = e+1;
+        size_t end = strtoul(s, &e, 10);
+        if (s == e)
+            end = (size_t)-1;
+        
+        *pbegin = begin;
+        *pend = end;
+        return true;
+    }
+    
+    return false;
+}
+
+bool CHttpServer::send_file(String const &path, HeaderList const &hdrs)
 {
     String fullPath = CFilePath::normalizePath(path);
     if (String_startsWith(fullPath,"/app/db/db-files") )
@@ -834,20 +883,68 @@ bool CHttpServer::send_file(String const &path)
     // Content length
     char buf[FILE_BUF_SIZE];
     
-    size_t fileSize = st.st_size;
-    snprintf(buf, sizeof(buf), "%lu", (unsigned long)fileSize);
+    String start_line;
+    
+    size_t file_size = st.st_size;
+    size_t range_begin = 0, range_end = file_size - 1;
+    size_t content_size = file_size;
+    if (parse_range(hdrs, &range_begin, &range_end))
+    {
+        if (range_end >= file_size)
+            range_end = file_size - 1;
+        if (range_begin >= range_end)
+            range_begin = range_end - 1;
+        content_size = range_end - range_begin + 1;
+        
+        snprintf(buf, sizeof(buf), "bytes %lu-%lu/%lu", (unsigned long)range_begin,
+                 (unsigned long)range_end, (unsigned long)file_size);
+        headers.push_back(Header("Content-Range", buf));
+        
+        if (fseek(fp, range_begin, SEEK_SET) == -1) {
+            RAWLOG_ERROR1("Can not seek to specified range start: %lu", (unsigned long)range_begin);
+            fclose(fp);
+            return false;
+        }
+        
+        start_line = "206 Partial Content";
+    }
+    else {
+        start_line = "200 OK";
+    }
+
+    
+    snprintf(buf, sizeof(buf), "%lu", (unsigned long)content_size);
     headers.push_back(Header("Content-Length", buf));
     
     // Send headers
-    if (!send_response(create_response("200 OK", headers))) {
+    if (!send_response(create_response(start_line, headers))) {
         RAWLOG_ERROR1("Can not send headers while sending file %s", path.c_str());
         fclose(fp);
         return false;
     }
     
     // Send body
-    while (!feof(fp)) {
-        size_t n = fread(buf, 1, sizeof(buf), fp);
+    for (size_t start = range_begin; start < range_end + 1;) {
+        size_t need_to_read = range_end - start + 1;
+        if (need_to_read == 0)
+            break;
+        
+        if (need_to_read > sizeof(buf))
+            need_to_read = sizeof(buf);
+        size_t n = fread(buf, 1, need_to_read, fp);
+        if (n < 0) {
+            RAWLOG_ERROR2("Can not read part of file (at position %lu): %s", (unsigned long)start, strerror(errno));
+            fclose(fp);
+            return false;
+        }
+        if (n == 0) {
+            RAWLOG_ERROR1("End of file reached, but we expect data (%lu bytes)", (unsigned long)need_to_read);
+            fclose(fp);
+            return false;
+        }
+        
+        start += n;
+        
         if (!send_response_body(String(buf, n))) {
             RAWLOG_ERROR1("Can not send part of data while sending file %s", path.c_str());
             fclose(fp);
@@ -915,8 +1012,11 @@ bool CHttpServer::decide(String const &method, String const &uri, String const &
         }
         
         RAWTRACE1("Uri %s is index file, call serveIndex", uri.c_str());
-        
-        VALUE data = callServeIndex((char *)fullPath.c_str());
+
+        VALUE req = create_request_hash(route.application, route.model, route.action, route.id,
+                                        method, uri, query, headers, body);
+
+        VALUE data = callServeIndex((char *)fullPath.c_str(), req);
         String reply(getStringFromValue(data), getStringLenFromValue(data));
         rho_ruby_releaseValue(data);
 
@@ -932,7 +1032,7 @@ bool CHttpServer::decide(String const &method, String const &uri, String const &
     
     // Try to send requested file
     RAWTRACE1("Uri %s should be regular file, trying to send it", uri.c_str());
-    return send_file(uri);
+    return send_file(uri, headers);
 }
 
 } // namespace net