ruby-lsapi 1.3 → 1.4

data/README

@@ -2,7 +2,7 @@
 lsapi - LSAPI extension for Ruby
 ================================
 
-Version 0.1.0
+Version 1.4
 
 INSTALL
 -------
@@ -16,8 +16,8 @@ USAGE
 
 General CGI scripts
 ```````````````````
-The most efficient way to use LSAPI interface is to modify your CGI script, 
-you need to add the following to your CGI script
+The most efficient way to use LSAPI interface is to modify your CGI scripts. 
+You need to add the following code to your CGI scripts:
 
   require 'lsapi'
   
@@ -28,10 +28,10 @@ you need to add the following to your CGI script
 
   end
 
-There is no need to change the way how CGI environment variables being 
-accessed in your script.
+There is no need to change the way that how CGI environment variables 
+are being accessed in your scripts.
 
-There are examples under examples/ folder.
+You can find some examples under examples/ folder.
 
 
 Rails dispatcher
@@ -44,10 +44,10 @@ in public/.htaccess from
 to
     RewriteRule ^(.*)$ dispatch.lsapi [QSA,L]
 
-It is very expensive to start a fresh Rails application process, while on
+It is very expensive to start a fresh Rails application process, and on
 the other hand, server hardware resources can be used more efficiently with
-dynamic spawning. In order to solve this conflict, instead of spawning a
-fresh Rails process, LSAPI dispatcher can dynamically fork children processes
+dynamic spawning. In order to solve this problem, instead of spawning a
+fresh Rails process, LSAPI dispatcher will dynamically fork children processes
 off an initialized Rails process.
 
 When you configure dispatch.lsapi as a LSAPI application, you should add
@@ -57,12 +57,28 @@ an extra environment variable
 
 n should match the "Max Conns" configuration entry of the LSAPI application. 
 
+Two new environment variables has been introduced since Ruby LSAPI 1.4:
+
+    LSAPI_MAX_REQS=n
+
+n is the maximum number of requests that a child process can serve. 
+Default value is 1000. Once that number is reached, the child process will 
+exit automatically. This will help in case of any memory leaks in Rails. 
+
+    LSAPI_MAX_IDLE=n
+
+n is the maximum idle time in seconds that a child process will be waiting 
+for a new request. Once it is reached, the child process will quit. 
+Default value is 60. When n <= 0, the child process will wait indefinitely. 
+This option helps getting rid of idle children processes.
+
 
 Ruby Script Runner
 ``````````````````
-If you don't want to change your Ruby CGI code, you can use our Ruby script
-runner under scripts/ folder. You need to configure lsruby_runner.rb as a
-LSAPI application, then add a script handler for "rb" suffix.
+If you don't want to change your existing Ruby CGI code, you can use our 
+Ruby script runner under scripts/ folder. You need to configure 
+lsruby_runner.rb as a LSAPI application, then add a script handler 
+for "rb" suffix.
 
 
 License
@@ -79,6 +95,6 @@ LSAPI ruby extension code is under Ruby license
 Copyright
 ---------
 
-Copyright (C) 2006 Lite Speed Technologes Inc.
+Copyright (C) 2006 Lite Speed Technologies Inc.
 
 

data/ext/lsapi/lsapilib.c

@@ -207,8 +207,18 @@ static int lsapi_writev( int fd, struct iovec ** pVec, int count, int totalLen )
                 }
             }
         }
-        else if (( ret == -1 )&&( errno != EINTR ))
-            return ret;
+        else if ( ret == -1 )
+        {
+            if ( errno == EAGAIN )
+            {
+                if ( totalLen - left > 0 )
+                    return totalLen - left;
+                else
+                    return -1;
+            }
+            else if ( errno != EINTR )
+                return ret;
+        }
     }
     return totalLen - left;
 }
@@ -539,11 +549,16 @@ int LSAPI_Init(void)
     return 0;
 }
 
-void LSAPI_stop(void)
+void LSAPI_Stop(void)
 {
     g_running = 0;
 }
 
+int LSAPI_IsRunning(void)
+{
+    return g_running;
+}
+
 int LSAPI_InitRequest( LSAPI_Request * pReq, int fd )
 {
     if ( !pReq )
@@ -740,7 +755,7 @@ int LSAPI_ReadReqBody_r( LSAPI_Request * pReq, char * pBuf, int bufLen )
             bufLen -= len;
         }
         else if ( len < 0 )
-            return -1;
+            return (total)?total:-1;
     }
     pReq->m_reqBodyRead += total;
     return total;

data/ext/lsapi/lsapilib.h

@@ -121,7 +121,7 @@ typedef int (*LSAPI_CB_EnvHandler )( const char * pKey, int keyLen,
 
 int LSAPI_Init(void);
 
-void LSAPI_stop(void);
+void LSAPI_Stop(void);
 
 int LSAPI_Is_Listen_r( LSAPI_Request * pReq);
 
@@ -280,6 +280,7 @@ static inline int LSAPI_AppendRespHeader( char * pBuf, int len )
 static inline int LSAPI_SetRespStatus( int code )
 {   return LSAPI_SetRespStatus_r( &g_req, code );           }
 
+int LSAPI_IsRunning(void);
 
 #if defined (c_plusplus) || defined (__cplusplus)
 }

data/ext/lsapi/lsruby.c

@@ -42,6 +42,9 @@ static lsapi_data * s_req_data;
 
 static int  s_children = 0;
 static int  s_cur_children = 0;
+static int  s_req_processed = 0;
+static int  s_max_reqs = 1000;
+static int  s_max_idle_secs = 60;
 
 static void lsapi_ruby_setenv(const char *name, const char *value)
 {
@@ -108,7 +111,7 @@ void lsapi_sigchild( int signal )
         {
             break;
         }
-
+        --s_cur_children; 
     }
 
 }
@@ -120,6 +123,9 @@ static int lsapi_fork_child()
     char        achPeer[128];
     socklen_t   len;
     int         nodelay = 1;
+    fd_set      readfds;
+    struct timeval timeout;
+    int         ret;
 
     setsid();
 
@@ -145,6 +151,31 @@ static int lsapi_fork_child()
     s_stop = 0;
     while( !s_stop )
     {
+        if ( s_cur_children >= (s_children << 1 ) )
+        {
+            usleep( 10000 );
+            continue;
+        }
+        
+        FD_ZERO( &readfds );
+        FD_SET( g_req.m_fdListen, &readfds );
+        timeout.tv_sec = 0; timeout.tv_usec = 100000;
+        if ((ret = rb_thread_select(g_req.m_fdListen+1, &readfds, NULL, NULL, &timeout)) == 1 )
+        {
+            if ( s_cur_children >= s_children )
+            {
+                usleep( 10 );
+                FD_ZERO( &readfds );
+                FD_SET( g_req.m_fdListen, &readfds );
+                timeout.tv_sec = 0; timeout.tv_usec = 0;
+                if ( select(g_req.m_fdListen+1, &readfds, NULL, NULL, &timeout) == 0 )
+                    continue;
+            }
+        }
+        else if ( ret == -1 )
+            break;
+        else
+            continue;
         len = sizeof( achPeer );
         g_req.m_fd = accept( g_req.m_fdListen,
                     (struct sockaddr *)&achPeer, &len );
@@ -158,9 +189,10 @@ static int lsapi_fork_child()
             int pid = fork();
             if ( !pid )
             {
-                close( g_req.m_fdListen );
-                g_req.m_fdListen = -1;
-
+                //close( g_req.m_fdListen );
+                //g_req.m_fdListen = -1;
+                s_children = 0;
+                
                 /* don't catch our signals */
 		sigaction( SIGCHLD, &old_child, 0 );
                 sigaction( SIGTERM, &old_term, 0 );
@@ -172,10 +204,11 @@ static int lsapi_fork_child()
             else if ( pid == -1 )
             {
                 perror( "fork() failed" );
-                return -1;
+                break;
             }
             else
             {
+                ++s_cur_children;
                 close( g_req.m_fd );
                 g_req.m_fd = -1;
             }
@@ -200,6 +233,8 @@ static VALUE lsapi_s_accept( VALUE self )
     fd_set  readfds;
     int     fd;
     int     ret;
+    int     wait_secs;
+    struct timeval timeout;
 
     LSAPI_Finish_r( &g_req );
     if ( s_children )
@@ -208,36 +243,48 @@ static VALUE lsapi_s_accept( VALUE self )
             if ( lsapi_fork_child() == -1 )
                 return Qnil;
     }
-    if ( g_req.m_fd != -1 )
+    if ( s_req_processed < s_max_reqs )
     {
-        fd = g_req.m_fd;
-    }
-    else if ( g_req.m_fdListen != -1 )
-        fd = g_req.m_fdListen;
-    else
-        return Qnil;
-
-    FD_ZERO( &readfds );
-    FD_SET( fd, &readfds );
-
-    if (rb_thread_select(fd+1, &readfds, NULL, NULL, NULL) < 1)
-    {
-        return Qnil;
-    }
-
-    ret = LSAPI_Accept_r( &g_req );
-
-    if ( !ret )
-    {
-//        req = Data_Make_Struct( self, lsapi_data, lsapi_mark, free, req_data );
-//        s_req = req;
-//        req_data->req = &g_req;
-//        rb_stdin = rb_stdout = req;
-//#if RUBY_VERSION_CODE < 180
-//        rb_defout = req;
-//#endif
-        setup_cgi_env( s_req_data );
-        return s_req;
+        if ( g_req.m_fd != -1 )
+        {
+            fd = g_req.m_fd;
+        }
+        else if ( g_req.m_fdListen != -1 )
+            fd = g_req.m_fdListen;
+        else
+            return Qnil;
+        wait_secs = 0;
+        while( LSAPI_IsRunning() )
+        {
+            FD_ZERO( &readfds );
+            FD_SET( fd, &readfds );
+            timeout.tv_sec = 1;
+            timeout.tv_usec = 0;
+            if (rb_thread_select(fd+1, &readfds, NULL, NULL, &timeout) < 1)
+            {
+                ++wait_secs;
+                if (( s_max_idle_secs > 0 )&&(wait_secs >= s_max_idle_secs ))
+                    return Qnil;
+            }
+            else
+                break;
+        }
+    
+        ret = LSAPI_Accept_r( &g_req );
+    
+        if ( !ret )
+        {
+    //        req = Data_Make_Struct( self, lsapi_data, lsapi_mark, free, req_data );
+    //        s_req = req;
+    //        req_data->req = &g_req;
+    //        rb_stdin = rb_stdout = req;
+    //#if RUBY_VERSION_CODE < 180
+    //        rb_defout = req;
+    //#endif
+            ++s_req_processed;
+            setup_cgi_env( s_req_data );
+            return s_req;
+        }
     }
     return Qnil;
 }
@@ -435,6 +482,8 @@ static VALUE lsapi_read(int argc, VALUE *argv, VALUE self)
     lsapi_data *data;
     int n;
     int remain;
+    fd_set  readfds;
+    int     fd;
     char buff[8192];
 
     if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
@@ -455,8 +504,16 @@ static VALUE lsapi_read(int argc, VALUE *argv, VALUE self)
     }
     str = rb_str_buf_new( remain );
     OBJ_TAINT(str);
+    fd = data->req->m_fd;
     while( remain > 0 )
     {
+        FD_ZERO( &readfds );
+        FD_SET( fd, &readfds );
+    
+        if (rb_thread_select(fd+1, &readfds, NULL, NULL, NULL) < 1)
+        {
+            return Qnil;
+        }
         n = LSAPI_ReadReqBody_r(data->req, buff,
                         (remain > 8192)?8192:remain );
         if ( n > 0 )
@@ -519,12 +576,28 @@ static VALUE lsapi_setsync(VALUE self,VALUE sync)
 
 void Init_lsapi()
 {
+    int n;
     char * p = getenv( "LSAPI_CHILDREN" );
     if ( p )
     {
         s_children = atoi( p );
     }
 
+    p = getenv( "LSAPI_MAX_REQS" );
+    if ( p )
+    {
+        n = atoi( p );
+        if ( n > 0 )
+            s_max_reqs = n;
+    }
+    
+    p = getenv( "LSAPI_MAX_IDLE" );
+    if ( p )
+    {
+        n = atoi( p );
+        s_max_idle_secs = n;
+    }
+
     orig_stdin = rb_stdin;
     orig_stdout = rb_stdout;
 #if RUBY_VERSION_CODE < 180

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ruby-lsapi
 version: !ruby/object:Gem::Version 
-  version: "1.3"
+  version: "1.4"
 date: 2006-07-20 00:00:00 -04:00
 summary: A ruby extension for fast communication with LiteSpeed Web Server.
 require_paths: