rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/RhoRubyLib/net/AsyncHttp.cs

@@ -0,0 +1,362 @@
+using System;
+using System.Net;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Ink;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.Windows.Shapes;
+using System.IO;
+using System.Collections.Generic;
+using rho.common;
+using fastJSON;
+using IronRuby.Runtime;
+using IronRuby.Builtins;
+
+namespace rho.net
+{
+    public class CAsyncHttp : CThreadQueue 
+    {
+        private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() : 
+		    new RhoLogger("AsyncHttp");
+	    private static CRhodesApp RHODESAPP(){ return CRhodesApp.Instance; }
+	
+        static CAsyncHttp m_pInstance;
+
+        public static CAsyncHttp Create()
+        {
+	        if ( m_pInstance != null) 
+	           return m_pInstance;
+	
+	        m_pInstance = new CAsyncHttp();
+	        return m_pInstance;
+        }
+
+        static public void Destroy()
+        {
+            if (m_pInstance != null)
+            {
+                m_pInstance.stop(-1);
+                LOG.INFO("Thread shutdown");
+
+                m_pInstance = null;
+            }
+        }
+
+        public static CAsyncHttp getInstance(){ return m_pInstance; }
+    
+        public CAsyncHttp()
+        {
+            base.setLogCategory(LOG.getLogCategory());
+
+            setPollInterval(QUEUE_POLL_INTERVAL_INFINITE);
+        }
+
+        public void cancelRequest(String szCallback)
+        {
+            if (szCallback == null || szCallback.length() == 0 )
+            {
+                LOG.INFO("Cancel callback should not be empty. Use * for cancel all");
+                return;
+            }
+
+            lock(getCommandLock())
+            {
+	            HttpCommand pCmd = (HttpCommand)getCurCommand();
+	
+	            if ( pCmd != null && ( szCallback.compareTo("*") == 0 || pCmd.m_strCallback.compareTo(szCallback) == 0) )
+	                pCmd.cancel();
+	
+	            if ( szCallback.compareTo("*") == 0 )
+	                getCommands().Clear();
+	            else
+	            {
+	                for (int i = getCommands().size()-1; i >= 0; i--)
+	                {
+	                    HttpCommand pCmd1 = (HttpCommand)getCommands().get(i);
+	
+	                    if ( pCmd1 != null && pCmd1.m_strCallback.compareTo(szCallback) == 0 )
+    	                    getCommands().RemoveAt(i);
+	                }
+	
+	            }
+            }   
+        }
+
+        public MutableString addHttpCommand(IQueueCommand pCmd)
+        {
+            if (((HttpCommand)pCmd).m_strCallback.length() == 0)
+            {
+                processCommandBase(pCmd);
+                return ((HttpCommand)pCmd).getRetValue();
+            }
+            else
+            {
+                addQueueCommand(pCmd);
+                start(epLow);
+
+                return ((HttpCommand)pCmd).getRetValue();
+            }
+        }
+
+        public override void processCommand(IQueueCommand pCmd)
+        {
+            ((HttpCommand)pCmd).execute();
+        }
+
+	    public const int  hcNone = 0, hcGet = 1, hcPost=2, hcDownload=3, hcUpload =4;
+
+        public class HttpCommand : IQueueCommand
+        {
+	        int m_eCmd;
+            public String m_strCallback, m_strCallbackParams;
+            Hashtable<String, String> m_mapHeaders = new Hashtable<String, String>();
+
+            private NetRequest m_pNetRequest;
+            String m_strResBody;
+            private MutableString m_valBody;    
+        
+            RhoParams    m_params;
+
+            public HttpCommand(String strCmd, RhoParams p)
+            {
+                m_params = new RhoParams(p); 
+                m_eCmd = translateCommand(strCmd);
+                m_strCallback = m_params.getString("callback");
+                m_strCallbackParams = m_params.getString("callback_param");
+
+                m_mapHeaders = m_params.getHash("headers");
+
+                m_pNetRequest = RhoClassFactory.createNetRequest();
+                m_pNetRequest.sslVerifyPeer(m_params.getBool("ssl_verify_peer"));
+            }
+
+            int translateCommand(String strCmd)
+            {
+                if ( strCmd.compareTo("GET") == 0 )
+                    return hcGet;
+                else if ( strCmd.compareTo("POST") == 0 )
+                    return hcPost;
+                else if ( strCmd.compareTo("Download") == 0 )
+                    return hcDownload;
+                else if ( strCmd.compareTo("Upload") == 0 )
+                    return hcUpload;
+
+                return hcNone;
+            }
+
+    	    void processResponse(NetResponse resp )
+    	    {
+    	        if (resp.isOK() && m_mapHeaders != null)
+    	        {
+    	    	    String strContType = null;
+                    m_mapHeaders.TryGetValue("content-type", out strContType);
+    	    	    if ( strContType != null && strContType.indexOf("application/json") >=0 )
+    	    	    {   
+    	    		   ///// RJSONTokener json = new RJSONTokener(resp.getCharData());
+    	    		    try{
+    	    			  /////  m_valBody = json.nextRValue();
+                            fastJSON.RJSONTokener.JsonDecode(resp.getCharData());
+    	    			    return;
+    	    		    }catch(Exception exc)
+    	    		    {
+    	    			    LOG.ERROR("Incorrect json body.", exc);
+    	    		    }
+    	    	    }
+    	        }
+
+    	        m_valBody = CRhoRuby.create_string(resp.getCharData());
+    	    }
+        
+            public void execute()
+            {
+                NetResponse resp = null;
+     	        try
+     	        {
+	                switch( m_eCmd )
+	                {
+	                    case hcGet:
+	            	        ///m_pNetRequest.setIgnoreSuffixOnSim(false);
+	                        resp = m_pNetRequest.doRequest( m_params.getString("http_command", "GET"), 
+	                        m_params.getString("url"), m_params.getString("body"), null, m_mapHeaders);
+	                        break;
+	                    case hcPost:
+	            	        ///m_pNetRequest.setIgnoreSuffixOnSim(false);
+	                        resp = m_pNetRequest.doRequest(m_params.getString("http_command", "POST"), 
+	                        m_params.getString("url"), m_params.getString("body"), null, m_mapHeaders);
+	                        break;
+	
+	                    case hcDownload:
+	                        resp = m_pNetRequest.pullFile(m_params.getString("url"), m_params.getString("filename"), null, m_mapHeaders);
+	                        break;  
+	
+	            case hcUpload:
+	                {
+                        Vector<NetRequest.MultipartItem>/*Ptr<net::CMultipartItem*>*/ arMultipartItems = new Vector<NetRequest.MultipartItem>();
+	
+	                    RhoParamArray arParams = new RhoParamArray( m_params, "multipart");
+	                    if ( arParams.size() > 0 )
+	                    {
+	                        for( int i = 0; i < arParams.size(); i++)
+	                        {
+	                            RhoParams oItem = arParams.getItem(i);
+
+                                NetRequest.MultipartItem pItem = new NetRequest.MultipartItem();
+	                            String strBody = oItem.getString("body");
+	                            if ( strBody.length() > 0 )
+	                            {
+	                                pItem.m_strBody = strBody;
+	                                pItem.m_strContentType = oItem.getString("content_type", "application/x-www-form-urlencoded");
+	                            }
+	                            else
+	                            {
+	                                pItem.m_strFilePath = oItem.getString("filename");
+	                                pItem.m_strContentType = oItem.getString("content_type", "application/octet-stream");
+	                            }
+	
+	                            pItem.m_strName = oItem.getString("name");
+	                            pItem.m_strFileName = oItem.getString("filename_base");
+	                            arMultipartItems.addElement(pItem);
+	                        }
+	                    }else
+	                    {
+                            NetRequest.MultipartItem pItem = new NetRequest.MultipartItem();
+	                        pItem.m_strFilePath = m_params.getString("filename");
+	                        pItem.m_strContentType = m_params.getString("file_content_type", "application/octet-stream");
+	                        pItem.m_strName = m_params.getString("name");
+	                        pItem.m_strFileName = m_params.getString("filename_base");
+	                        arMultipartItems.addElement(pItem);
+	
+	                        String strBody = m_params.getString("body");
+	                        if ( strBody.length() > 0 )
+	                        {
+                                NetRequest.MultipartItem pItem2 = new NetRequest.MultipartItem();
+	                            pItem2.m_strBody = strBody;
+	                            pItem2.m_strContentType = (String)m_mapHeaders.get("content-type");
+	                            arMultipartItems.addElement(pItem2);
+	                        }
+	                    }
+	
+	                    resp = m_pNetRequest.pushMultipartData( m_params.getString("url"), arMultipartItems, null, m_mapHeaders );
+	                    break;
+	                }
+	            }
+	
+	            if ( !m_pNetRequest.isCancelled())
+	            {
+				    processResponse(resp);
+	                callNotify(resp,0);
+	            }
+    	    }catch(IOException exc)
+    	    {
+    	    	LOG.ERROR("command failed: " + m_eCmd + "url: " + m_params.getString("url"), exc);
+    	    	callNotify(null, RhoAppAdapter.ERR_NETWORK);
+    	    }catch(Exception exc)
+    	    {
+    	    	LOG.ERROR("command crashed: " + m_eCmd + "url: " + m_params.getString("url"), exc);
+    	    	callNotify(null, RhoAppAdapter.ERR_RUNTIME);
+    	    }
+        }
+        
+        public void cancel()
+        {
+            if (m_pNetRequest!=null )
+                m_pNetRequest.cancel();
+        }
+
+        void callNotify(NetResponse resp, int nError )
+        {
+            m_strResBody = "rho_callback=1";
+            m_strResBody += "&status=";
+            if ( nError > 0 )
+            {
+            	m_strResBody += "error&error_code=" + nError;
+            }else
+            {
+                if ( resp.isOK() )
+            	    m_strResBody += "ok";
+                else
+                {
+            	    m_strResBody += "error&error_code=";
+                    m_strResBody += RhoAppAdapter.getErrorFromResponse(resp);
+                    //if ( resp.isResponseRecieved())
+        	            m_strResBody += "&http_error=" + resp.getRespCode();
+                }
+
+                String cookies = resp.getCookies();
+                if (cookies.length()>0)
+                    m_strResBody += "&cookies=" + URI.urlEncode(cookies);
+
+                String strHeaders = makeHeadersString();
+                if (strHeaders.length() > 0 )
+                    m_strResBody += "&" + strHeaders;
+
+                m_strResBody += "&" + RHODESAPP().addCallbackObject(m_valBody, "body");
+            }
+
+            if ( m_strCallbackParams.length() > 0 )
+                m_strResBody += "&" + m_strCallbackParams;
+
+            if ( m_strCallback.length() > 0 )
+            {
+    		    try{
+	                String strFullUrl = m_pNetRequest.resolveUrl(m_strCallback);
+	                NetResponse resp1 = m_pNetRequest.pushData( strFullUrl, m_strResBody, null );
+    		        if ( !resp1.isOK() )
+    		            LOG.ERROR("AsyncHttp notification failed. Code: " + resp1.getRespCode() + "; Error body: " + resp1.getCharData() );
+    	        }catch(Exception exc)
+    	        {
+    	        	LOG.ERROR("Async http callback failed.", exc);
+    	        }
+            }
+        }
+        
+        public MutableString getRetValue()
+        {
+    	    if ( m_strCallback.length() == 0 )
+    	        return CRhoRuby.create_string(m_strResBody); 
+
+    	    return null;
+        }
+
+	    public boolean equals(IQueueCommand cmd){ return false; }
+
+        public String toString()
+        {
+            switch(m_eCmd)
+            {
+            case hcGet:
+                return "GET";
+            case hcPost:
+                return "POST";
+            case hcDownload:
+                return "Download";
+            case hcUpload:
+                return "Upload";
+            }
+            return "Unknown";
+        }
+
+        String makeHeadersString()
+        {
+    	    String strRes = "";
+
+            foreach (KeyValuePair<String, String> kvp in m_mapHeaders)
+            {
+                if (strRes.length() > 0)
+                    strRes += "&";
+
+                strRes += "headers[";
+                strRes += URI.urlEncode(kvp.Key.ToString());
+                strRes += "]=";
+                strRes += URI.urlEncode(kvp.Value.ToString());
+            }
+
+    	    return strRes;
+        }
+
+    }
+    }
+}

data/platform/wp7/RhoRubyLib/net/HttpServer.cs

@@ -0,0 +1,466 @@
+using System;
+using rho.common;
+using rho;
+using System.Collections.Generic;
+
+namespace rho.net
+{
+    public class CHttpServer : CThreadQueue
+    {
+        private static RhoLogger LOG = RhoLogger.RHO_STRIP_LOG ? new RhoEmptyLogger() :
+                    new RhoLogger("HttpServer");
+
+        String m_root;
+
+        static CRhodesApp RHODESAPP() { return CRhodesApp.Instance; }
+        private CRhoRuby RhoRuby { get { return CRhoRuby.Instance; } }
+
+        class CRoute
+        {
+            public String application = "";
+            public String model = "";
+            public String id = "";
+            public String action = "";
+
+            public static bool isid(String s)
+            {
+                return s.Length > 2 && s[0] == '{' && s[s.Length - 1] == '}';
+            }
+        };
+        /*public class CResponse
+        {
+            public String m_strUrl = "";
+            public bool m_bRedirect = true;
+
+            public CResponse(String strUrl) { m_strUrl = strUrl; m_bRedirect = true;  }
+            public CResponse(bool bRedirect) { m_bRedirect = bRedirect; }
+        };*/
+        class CServerCommand : IQueueCommand
+        {
+            String m_method, m_uri, m_query, m_body;
+            CRoute m_route;
+            CHttpServer m_Parent;
+            int m_nCommand;
+
+            public const int scDispatch = 1, scIndex = 2;
+
+            public CServerCommand(CHttpServer Parent, CRoute route, 
+                String method, String uri, String query, String body, int nCommand)
+            {
+                m_Parent = Parent;
+                m_method = method;
+                m_uri = uri;
+                m_query = query;
+                m_body = body;
+                m_route = route;
+                m_nCommand = nCommand;
+            }
+
+            public void execute()
+            {
+                String strUrl = "";
+                if (m_nCommand == scDispatch )
+                    strUrl = m_Parent.processDispatch(m_route, m_method, m_uri, m_query, m_body);
+                else if ( m_nCommand == scIndex )
+                    strUrl = m_Parent.processIndex(m_route, m_method, m_uri, m_query, m_body);
+
+                RHODESAPP().processWebNavigate(strUrl);
+            }
+
+            public boolean equals(IQueueCommand cmd) { return false; }
+            public void cancel() { }
+            public String toString() { return "uri :" + m_uri + "; cmd: " + (m_nCommand == scDispatch ? "dispatch" : "index"); }
+        };
+
+        public CHttpServer(String strFileRoot)
+        {
+            m_root = strFileRoot;
+
+            base.setLogCategory(LOG.getLogCategory());
+
+            setPollInterval(QUEUE_POLL_INTERVAL_INFINITE);
+
+            start(epNormal);
+        }
+
+        public override void run()
+        {
+            RHODESAPP().startApp();
+            base.run();
+        }
+
+        public override void processCommand(IQueueCommand pCmd)
+        {
+            (pCmd as CServerCommand).execute();
+        }
+
+        public boolean processBrowserRequest(Uri uri)
+        {
+            if (!uri.OriginalString.StartsWith(RHODESAPP().getHomeUrl())
+                           && (uri.IsAbsoluteUri || uri.OriginalString.StartsWith("res:")))
+                return false;
+
+            String query = "";
+            String url = uri.OriginalString;
+            url = url.StartsWith(RHODESAPP().getHomeUrl()) ? url.substring(RHODESAPP().getHomeUrl().length()) : url;
+
+            int nFrag = url.LastIndexOf('#');
+            if (nFrag >= 0)
+                url = url.Substring(0, nFrag);
+
+            int nQuery = url.IndexOf('?');
+            if (nQuery >= 0)
+            {
+                query = url.Substring(nQuery + 1);
+                url = url.Substring(0, nQuery);
+            }
+
+            if (url.EndsWith(".gen.html") || (isknowntype(url) && url.StartsWith(m_root)))
+                return false;
+
+            CRoute route = new CRoute();
+            if (dispatch(url, route))
+            {
+                addQueueCommand(new CServerCommand(this, route, "GET", url, query, "", CServerCommand.scDispatch));
+
+                return true;
+            }
+
+            String fullPath = url.StartsWith(m_root) ? url : CFilePath.join(m_root, url);
+
+            String strIndexFile = getIndex(fullPath);
+            if (strIndexFile.Length > 0)
+            {
+                addQueueCommand(new CServerCommand(this, route, "GET", url, query, "", CServerCommand.scIndex));
+
+                return true;
+            }
+
+            return false;
+        }
+
+        String processDispatch(CRoute route, String method, String uri, String query, String body)
+        {
+            Object rhoReq = create_request_hash(route, method, uri, query, null, body);
+            Object rhoResp = RhoRuby.callServe(rhoReq);
+
+            String strRedirectUrl = getRedirectUrl(rhoResp);
+            if (strRedirectUrl.Length > 0)
+                return strRedirectUrl;
+
+            String strFilePath = RHODESAPP().canonicalizeRhoPath(uri) + ".gen.html";
+            if (route.id.Length > 0)
+                strFilePath = CFilePath.join(m_root, route.application + "/" + route.model + "/" + route.action) + ".gen.html";
+
+            CRhoFile.recursiveCreateDir(strFilePath);
+            CRhoFile.writeDataToFile(strFilePath, getResponseBody(rhoResp));
+
+            if (method == "GET")
+                RHODESAPP().keepLastVisitedUrl(uri);
+
+            return strFilePath;
+        }
+
+        String processIndex(CRoute route, String method, String uri, String query, String body)
+        {
+            String fullPath = uri.StartsWith(m_root) ? uri : CFilePath.join(m_root, uri);
+            String strIndexFile = getIndex(fullPath);
+
+            if (!CRhoFile.isResourceFileExist(strIndexFile))
+            {
+                String error = "<html><font size=\"+4\"><h2>404 Not Found.</h2> The file " + uri + " was not found.</font></html>";
+                String strFilePath = CFilePath.join(m_root, "rhodes_error") + ".gen.html";
+                CRhoFile.recursiveCreateDir(strFilePath);
+                CRhoFile.writeStringToFile(strFilePath, error);
+                return strFilePath;
+            }
+
+            if (CFilePath.getExtension(fullPath).Length > 0)
+                return strIndexFile;
+
+            Object rhoReq = create_request_hash(route, method, uri, query, null, body);
+            Object rhoResp = RhoRuby.callServeIndex(strIndexFile, rhoReq);
+
+            String strRedirectUrl = getRedirectUrl(rhoResp);
+            if (strRedirectUrl.Length > 0)
+                return strRedirectUrl;
+
+            strIndexFile += ".gen.html";
+            CRhoFile.recursiveCreateDir(strIndexFile);
+            CRhoFile.writeDataToFile(strIndexFile, getResponseBody(rhoResp));
+
+            if (method == "GET")
+                RHODESAPP().keepLastVisitedUrl(uri);
+
+            return strIndexFile;
+        }
+/*
+        CResponse decide(String method, String uri, String query, String body)
+        {
+            //if (process_registered(uri))
+            //    return new CResponse(false);
+
+            CRoute route = new CRoute();
+            if (dispatch(uri, route))
+            {
+                Object rhoReq = create_request_hash(route, method, uri, query, null, body);
+                Object rhoResp = RhoRuby.callServe(rhoReq);
+
+                String strRedirectUrl = getRedirectUrl(rhoResp);
+                if (strRedirectUrl.Length > 0)
+                    return new CResponse(strRedirectUrl);
+
+                String strFilePath = RHODESAPP().canonicalizeRhoPath(uri) + ".gen.html";
+                if ( route.id.Length > 0 )
+                    strFilePath = CFilePath.join(m_root, route.application + "/" + route.model + "/" + route.action) + ".gen.html";
+
+                CRhoFile.recursiveCreateDir(strFilePath);
+                CRhoFile.writeDataToFile(strFilePath, getResponseBody(rhoResp));
+
+                if (method == "GET")
+                    RHODESAPP().keepLastVisitedUrl(uri);
+
+                return new CResponse(strFilePath);
+            }
+
+            String fullPath = uri.StartsWith(m_root) ? uri : CFilePath.join(m_root, uri);
+
+            String strIndexFile = getIndex(fullPath);
+            if (strIndexFile.Length > 0 )
+            {
+                if (!CRhoFile.isResourceFileExist(strIndexFile))
+                {
+                    String error = "<html><font size=\"+4\"><h2>404 Not Found.</h2> The file " + uri + " was not found.</font></html>";
+                    String strFilePath = CFilePath.join(m_root,"rhodes_error") + ".gen.html";
+                    CRhoFile.recursiveCreateDir(strFilePath);
+                    CRhoFile.writeStringToFile(strFilePath, error);
+                    return new CResponse(strFilePath);
+                }
+
+                if (CFilePath.getExtension(fullPath).Length > 0)
+                    return new CResponse(strIndexFile);
+
+                Object rhoReq = create_request_hash(route, method, uri, query, null, body);
+                Object rhoResp = RhoRuby.callServeIndex(strIndexFile, rhoReq);
+
+                String strRedirectUrl = getRedirectUrl(rhoResp);
+                if (strRedirectUrl.Length > 0)
+                    return new CResponse(strRedirectUrl);
+
+                strIndexFile += ".gen.html";
+                CRhoFile.recursiveCreateDir(strIndexFile);
+                CRhoFile.writeDataToFile(strIndexFile, getResponseBody(rhoResp));
+
+                if (method == "GET")
+                    RHODESAPP().keepLastVisitedUrl(uri);
+
+                return new CResponse(strIndexFile);
+            }
+
+            return new CResponse(false);
+        }*/
+
+        public bool call_ruby_method(String uri, String body, out String strReply)
+        {
+            CRoute route = new CRoute();
+            strReply = String.Empty;
+            if (!dispatch(uri, route))
+            {
+                if (route.application.equalsIgnoreCase("system"))
+                {
+                    if (route.model.equalsIgnoreCase("geolocation"))
+                    {
+                        //TODO: geolocation
+                        //showGeoLocation();
+                        return true;
+                    }
+                    else if (route.model.equalsIgnoreCase("loadserversources"))
+                    {
+                        RhoRuby.loadServerSources(body);
+                        return true;
+                    }
+                    else if (route.model.equalsIgnoreCase("loadallsyncsources"))
+                    {
+                        RhoRuby.loadAllSyncSources();
+                        return true;
+                    }
+                    else if (route.model.equalsIgnoreCase("resetDBOnSyncUserChanged"))
+                    {
+                        RhoRuby.resetDBOnSyncUserChanged();
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+
+            Dictionary<String, String> headers = new Dictionary<String, String>();
+            headers.Add("Content-Type","application/x-www-form-urlencoded");
+            Object rhoReq = create_request_hash(route, "POST", uri, String.Empty, headers, body);
+            Object rhoResp = RhoRuby.callServe(rhoReq);
+            strReply = getResponseBodyString(rhoResp);
+
+            return true;
+        }
+
+        byte[] getResponseBody(Object resp)
+        {
+            Object body = RhoRuby.hashGet(resp, "request-body");
+            return RhoRuby.getBytesFromString(body);
+        }
+
+        String getResponseBodyString(Object resp)
+        {
+            Object body = RhoRuby.hashGet(resp, "request-body");
+            return RhoRuby.getStringFromObject(body);
+        }
+
+        String getRedirectUrl(Object resp)
+        {
+            int nStatus = RhoRuby.hashGetInt(resp, "status");
+            if ( nStatus != 302 )
+                return String.Empty;
+
+            return RhoRuby.hashGetString(resp, "Location");
+        }
+
+        bool dispatch(String uri, CRoute route)
+        {
+            if (isknowntype(uri))
+                return false;
+
+            // Trying to parse route
+            if (!parse_route(uri, route))
+                return false;
+
+            // Convert CamelCase to underscore_case
+            String controllerName = "";
+            for (int i = 0; i < route.model.Length; i++)
+            {
+                if (Char.IsUpper(route.model[i]) && i > 0)
+                    controllerName += '_';
+
+                controllerName += route.model[i];
+            }
+            controllerName = controllerName.ToLower();
+
+            String model_name_controller = m_root + "/" + route.application + "/" + route.model + "/" + controllerName + "_controller.rb";
+            String controller = m_root + "/" + route.application + "/" + route.model + "/controller.rb";
+
+            return CRhoFile.isResourceFileExist(model_name_controller) || CRhoFile.isResourceFileExist(controller);
+        }
+
+        bool parse_route(String uri, CRoute route)
+        {
+            if (uri.StartsWith(RHODESAPP().getHomeUrl()))
+                uri = uri.Substring(RHODESAPP().getHomeUrl().Length + 1);
+
+            if (uri.StartsWith(m_root))
+                uri = uri.Substring(m_root.Length+1);
+            else if ( uri.StartsWith("/") )
+                uri = uri.Remove(0, 1 );
+
+            String[] arParts = uri.Split('/');
+            if (arParts.Length > 0 )
+                route.application = arParts[0];
+
+            if (arParts.Length < 2)
+                return false;
+
+            route.model = arParts[1];
+
+            if (arParts.Length < 3)
+                return true;
+
+            String aoi = arParts[2];
+            if (CRoute.isid(aoi))
+            {
+                route.id = aoi;
+                if (arParts.Length > 3)
+                    route.action = arParts[3];
+            }
+            else 
+            {
+                if (arParts.Length > 3)
+                    route.id = arParts[3];
+
+                route.action = aoi;
+            }
+
+            return true;
+        }
+
+        bool isknowntype(String uri)
+        {
+            String[] ignored_exts = { ".css", ".js", ".html", ".htm", ".png", ".bmp", ".jpg", ".jpeg", ".gif" };
+
+            String strExt = CFilePath.getExtension(uri).ToLower();
+            return find_in_string_array(strExt, ignored_exts);
+        }
+
+        String getIndex(String path)
+        {
+            String[] index_files = { "index_erb.rb", "index.html", "index.htm", "index.php", "index.cgi" };
+
+            if (CFilePath.getExtension(path).Length == 0)
+                return CFilePath.join(path, index_files[0]);
+
+            String strFileName = CFilePath.getBaseName(path);
+            return find_in_string_array(strFileName, index_files) ? path : "";
+        }
+
+        public bool process_registered(String uri)
+        {
+            //TODO: process_registered
+            return false;
+        }
+
+        Object create_request_hash(CRoute route, String method, String uri, String query,
+                                 Dictionary<String, String> headers, String body)
+        {
+            Object hash = RhoRuby.createHash();
+
+            if ( route != null )
+            {
+                RhoRuby.hashAdd(hash, "application", route.application);
+                RhoRuby.hashAdd(hash, "model", route.model);
+
+                if ( route.action.Length > 0 )
+                    RhoRuby.hashAdd(hash, "action", route.action);
+                if ( route.id.Length > 0 )
+                    RhoRuby.hashAdd(hash, "id", route.id);
+            }
+
+            RhoRuby.hashAdd(hash, "request-method", method);
+            RhoRuby.hashAdd(hash, "request-uri", uri);
+            RhoRuby.hashAdd(hash, "request-query", query);
+
+            Object hash_headers = RhoRuby.createHash();
+            if (headers != null)
+            {
+                Dictionary<String, String>.Enumerator hashEnum = headers.GetEnumerator();
+                while (hashEnum.MoveNext())
+                {
+                    RhoRuby.hashAdd(hash_headers, hashEnum.Current.Key, hashEnum.Current.Value);
+                }
+            }
+            RhoRuby.hashAdd(hash, "headers", hash_headers);
+	
+            if ( body.Length > 0 )
+                RhoRuby.hashAdd(hash, "request-body", body);
+    
+            return hash;
+        }
+
+        bool find_in_string_array(String str, String[] ar)
+        {
+            for (int i = 0; i < ar.Length; i++)
+            {
+                if (str.CompareTo(ar[i]) == 0)
+                    return true;
+            }
+
+            return false;
+        }
+    }
+}