ruby-lsapi 1.13 → 2.0

data/ext/lsapi/lsapilib.h

@@ -49,6 +49,9 @@ extern "C" {
 #include <stddef.h>
 #include <lsapidef.h>
 
+#include <sys/time.h>
+#include <sys/types.h>
+
 struct LSAPI_key_value_pair
 {
     char * pKey;
@@ -64,7 +67,10 @@ typedef struct lsapi_request
 {
     int               m_fdListen;
     int               m_fd;
-    
+
+    long              m_lLastActive;
+    long              m_lReqBegin;
+
     char            * m_pReqBuf;
     int               m_reqBufSize;
     
@@ -294,6 +300,30 @@ static inline int LSAPI_SetRespStatus( int code )
 
 int LSAPI_IsRunning(void);
 
+int LSAPI_CreateListenSock( const char * pBind, int backlog );
+
+typedef int (*fn_select_t)( int, fd_set *, fd_set *, fd_set *, struct timeval * );
+
+int LSAPI_Init_Prefork_Server( int max_children, fn_select_t fp );
+
+void LSAPI_Set_Server_fd( int fd );
+
+int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq );
+
+void LSAPI_Set_Max_Reqs( int reqs );
+
+void LSAPI_Set_Max_Idle( int secs );
+
+void LSAPI_Set_Max_Children( int maxChildren );
+
+void LSAPI_Set_Max_Idle_Children( int maxIdleChld );
+
+void LSAPI_Set_Server_Max_Idle_Secs( int serverMaxIdle );
+
+void LSAPI_Set_Max_Process_Time( int secs );
+
+void LSAPI_Init_Env_Parameters( fn_select_t fp );
+
 #if defined (c_plusplus) || defined (__cplusplus)
 }
 #endif

data/ext/lsapi/lsruby.c

@@ -35,6 +35,8 @@ typedef struct lsapi_data
 {
     LSAPI_Request * req;
     VALUE           env;
+    int          (* fn_write)( LSAPI_Request *, const char * , int );
+    
 }lsapi_data;
 
 
@@ -43,14 +45,17 @@ static VALUE cLSAPI;
 static VALUE s_req = Qnil;
 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      = 1000000;
-static int  s_max_idle_secs = 60;
-static int  s_listenFd      = -1;
-static int  s_ppid          = 0;
-static int  s_max_grp_idle_secs = 0;
+static VALUE s_req_stderr = Qnil;
+static lsapi_data * s_stderr_data;
+
+//static int  s_children      = 0;
+//static int  s_cur_children  = 0;
+//static int  s_req_processed = 0;
+//static int  s_max_reqs      = 1000000;
+//static int  s_max_idle_secs = 60;
+//static int  s_listenFd      = -1;
+//static int  s_ppid          = 0;
+//static int  s_max_grp_idle_secs = 0;
 
 static void lsapi_ruby_setenv(const char *name, const char *value)
 {
@@ -161,164 +166,6 @@ static void setup_cgi_env( lsapi_data * data )
 
 
 
-static int s_stop;
-void lsapi_cleanup(int signal)
-{
-    s_stop = signal;
-}
-
-void lsapi_sigchild( int signal )
-{
-    int status, pid;
-    while( 1 )
-    {
-        pid = waitpid( -1, &status, WNOHANG|WUNTRACED );
-        if ( pid <= 0 )
-        {
-            break;
-        }
-        --s_cur_children;
-    }
-
-}
-
-static int lsapi_ruby_accept( int fdListen )
-{
-    int         fd;
-    int         nodelay = 1;
-    socklen_t   len;
-    char        achPeer[128];
-
-    len = sizeof( achPeer );
-    fd = accept( s_listenFd, (struct sockaddr *)&achPeer, &len );
-    if ( fd != -1 )
-    {
-        if (((struct sockaddr *)&achPeer)->sa_family == AF_INET )
-        {
-            setsockopt( fd, IPPROTO_TCP, TCP_NODELAY,
-                    (char *)&nodelay, sizeof(nodelay));
-        }
-    }
-    return fd;
-    
-}
-
-static int lsapi_fork_child()
-{
-    struct sigaction act, old_term, old_quit, old_int,
-                    old_usr1, old_child;
-
-    int             wait_secs = 0;                    
-    int             ret;
-    fd_set          readfds;
-    struct timeval  timeout;
-
-    setsid();
-
-    act.sa_flags = 0;
-    act.sa_handler = lsapi_sigchild;
-    if( sigaction( SIGCHLD, &act, &old_child ) )
-    {
-        perror( "Can't set signal handler for SIGCHILD" );
-        return -1;
-    }
-
-    /* Set up handler to kill children upon exit */
-    act.sa_flags = 0;
-    act.sa_handler = lsapi_cleanup;
-    if( sigaction( SIGTERM, &act, &old_term ) ||
-        sigaction( SIGINT,  &act, &old_int  ) ||
-        sigaction( SIGUSR1, &act, &old_usr1 ) ||
-        sigaction( SIGQUIT, &act, &old_quit ))
-    {
-        perror( "Can't set signals" );
-        return -1;
-    }
-    s_stop = 0;
-    while( !s_stop )
-    {
-        if ( s_cur_children >= (s_children << 1 ) )
-        {
-            usleep( 10000 );
-            continue;
-        }
-        
-        FD_ZERO( &readfds );
-        FD_SET( s_listenFd, &readfds );
-        timeout.tv_sec = 1; timeout.tv_usec = 0;
-        if ((ret = rb_thread_select(s_listenFd+1, &readfds, NULL, NULL, &timeout)) == 1 )
-        {
-            if ( s_cur_children >= 0 )
-            {
-                usleep( 10 );
-                FD_ZERO( &readfds );
-                FD_SET( s_listenFd, &readfds );
-                timeout.tv_sec = 0; timeout.tv_usec = 0;
-                if ( select(s_listenFd+1, &readfds, NULL, NULL, &timeout) == 0 )
-                    continue;
-            }
-        }
-        else if ( ret == -1 )
-            break;
-        else
-        {
-            if (s_ppid && (kill(s_ppid, 0) == -1)&&(errno == ESRCH))
-                break;
-            if (s_max_grp_idle_secs)
-            {
-                if ( s_cur_children <= 0 )
-                {
-                    ++wait_secs;
-                    if ( wait_secs > s_max_grp_idle_secs )
-                        return -1;
-                }
-                else
-                    wait_secs = 0;
-            }
-            continue;
-        }
-
-        g_req.m_fd = lsapi_ruby_accept( s_listenFd );
-        if ( g_req.m_fd != -1 )
-        {
-            int pid = fork();
-            if ( !pid )
-            {
-                s_children = 0;
-                s_ppid = getppid();
-                
-                /* don't catch our signals */
-                sigaction( SIGCHLD, &old_child, 0 );
-                sigaction( SIGTERM, &old_term, 0 );
-                sigaction( SIGQUIT, &old_quit, 0 );
-                sigaction( SIGINT,  &old_int,  0 );
-                sigaction( SIGUSR1, &old_usr1, 0 );
-                return 0;
-            }
-            else if ( pid == -1 )
-            {
-                perror( "fork() failed, please increase process limit" );
-            }
-            else
-            {
-                ++s_cur_children;
-            }
-            close( g_req.m_fd );
-            g_req.m_fd = -1;
-            
-        }
-        else
-        {
-            if (( errno == EINTR )||( errno == EAGAIN))
-                continue;
-            perror( "accept() failed" );
-            return -1;
-        }
-    }
-    kill( -getpgrp(), SIGUSR1 );
-    return -1;
-
-}
 
 static VALUE lsapi_s_accept( VALUE self )
 {
@@ -328,66 +175,14 @@ static VALUE lsapi_s_accept( VALUE self )
     fd_set          readfds;
     struct timeval  timeout;
 
-    LSAPI_Finish_r( &g_req );
-    if ( s_children > 1)
-    {
-        if ( s_listenFd != -1 )
-            if ( lsapi_fork_child() == -1 )
-                return Qnil;
-    }
-    if ( s_req_processed >= s_max_reqs )
+    if ( LSAPI_Prefork_Accept_r( &g_req ) == -1 )
         return Qnil;
-    while( 1 )
+    else
     {
-        if ( g_req.m_fd != -1 )
-        {
-            fd = g_req.m_fd;
-        }
-        else if ( s_listenFd != -1 )
-            fd = s_listenFd;
-        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;
-                if ( s_ppid &&(kill(s_ppid, 0) == -1)&&(errno == ESRCH))
-                    return Qnil;
-            }
-            else if ( fd == s_listenFd )
-            {
-                g_req.m_fd = lsapi_ruby_accept( s_listenFd );
-                if ( g_req.m_fd != -1 )
-                {
-                    break;
-                }
-            }
-            else
-                break;
-        }
-    
-        ret = LSAPI_Accept_r( &g_req );
-    
-        if ( !ret )
-        {
-            ++s_req_processed;
-            setup_cgi_env( s_req_data );
-            return s_req;
-        }
-        else if (( g_req.m_fd == -1 )&&( fd != s_listenFd ))
-            continue;
-        else
-            break;
+        setup_cgi_env( s_req_data );
+        return s_req;
     }
-    return Qnil;
+   
 }
 
 
@@ -434,9 +229,9 @@ static VALUE lsapi_process( VALUE self )
 static VALUE lsapi_putc(VALUE self, VALUE c)
 {
     char ch = NUM2CHR(c);
-//    lsapi_data *data;
-//    Data_Get_Struct(self,lsapi_data, data);
-    if ( LSAPI_Write_r( &g_req, &ch, 1 ) == 1 )
+    lsapi_data *data;
+    Data_Get_Struct(self,lsapi_data, data);
+    if ( (*data->fn_write)( data->req, &ch, 1 ) == 1 )
         return c;
     else
         return INT2NUM( EOF );
@@ -447,11 +242,11 @@ static VALUE lsapi_write( VALUE self, VALUE str )
 {
     lsapi_data *data;
     int len;
-//    Data_Get_Struct(self,lsapi_data, data);
+    Data_Get_Struct(self,lsapi_data, data);
 //    len = LSAPI_Write_r( data->req, RSTRING(str)->ptr, RSTRING(str)->len );
     if (TYPE(str) != T_STRING)
 	    str = rb_obj_as_string(str);
-    len = LSAPI_Write_r( &g_req, RSTRING(str)->ptr, RSTRING(str)->len );
+    len = (*data->fn_write)( data->req, RSTRING(str)->ptr, RSTRING(str)->len );
     return INT2NUM( len );
 }
 
@@ -702,20 +497,32 @@ static VALUE lsapi_setsync(VALUE self,VALUE sync)
 void Init_lsapi()
 {
     VALUE remove_env;
-    int n;
-    char * p = getenv( "LSAPI_CHILDREN" );
+    int n = 0;
+    VALUE orig_verbose; // constant silence hack
+    char * p;
+
+    LSAPI_Init();
+
+    LSAPI_Init_Env_Parameters( rb_thread_select );
+/*
+    p = getenv( "LSAPI_CHILDREN" );
     if ( p )
     {
-        s_children = atoi( p );
+        n = atoi( p );
         ruby_unsetenv( "LSAPI_CHILDREN" );
     }
+    if ( n > 1 )
+    {
+        LSAPI_Init_Prefork_Server( n, rb_thread_select );
+        LSAPI_Set_Server_fd( g_req.m_fdListen );
+    }
     
     p = getenv( "LSAPI_MAX_REQS" );
     if ( p )
     {
         n = atoi( p );
         if ( n > 0 )
-            s_max_reqs = n;
+            LSAPI_Set_Max_Req( n );
         ruby_unsetenv( "LSAPI_MAX_REQS" );
     }
     
@@ -723,21 +530,24 @@ void Init_lsapi()
     if ( p )
     {
         n = atoi( p );
-        s_max_idle_secs = n;
+        LSAPI_Set_Max_Idle( n );
         ruby_unsetenv( "LSAPI_MAX_IDLE" );
     }
 
     p = getenv( "LSAPI_PGRP_MAX_IDLE" );
     if ( p )
     {
-        s_max_grp_idle_secs = atoi( p );
+        LSAPI_Set_Server_Max_Idle_Secs( atoi( p ) );
         ruby_unsetenv( "LSAPI_PGRP_MAX_IDLE" );
     }
 
-    if ( !getenv( "LSAPI_PPID_NO_CHECK" ) )
-        s_ppid = getppid();
-    else
+    if ( getenv( "LSAPI_PPID_NO_CHECK" ) )
+    {
+        LSAPI_No_Check_ppid();
         ruby_unsetenv( "LSAPI_PPID_NO_CHECK" );
+    }
+*/
+
     p = getenv( "RAILS_ROOT" );
     if ( p )
     {
@@ -762,14 +572,6 @@ void Init_lsapi()
     remove_env = rb_str_new( "RAILS_ROOT", 10 );
     rb_funcall( env_copy, rb_intern( "delete" ), 1, remove_env );
     
-    lsapi_env = rb_hash_new();
-    //redefine ENV using a hash table, should be faster than char **environment
-    rb_define_global_const("ENV", lsapi_env);
-        
-    LSAPI_Init();
-
-    s_listenFd = g_req.m_fdListen;
-    g_req.m_fdListen = -1;
 
     rb_define_global_function("eval_string_wrap", lsapi_eval_string_wrap, 1);
 
@@ -801,12 +603,32 @@ void Init_lsapi()
         
     s_req = Data_Make_Struct( cLSAPI, lsapi_data, lsapi_mark, free, s_req_data );
     s_req_data->req = &g_req;
+    s_req_data->fn_write = LSAPI_Write_r;
     rb_stdin = rb_stdout = s_req;
+
 #if RUBY_VERSION_CODE < 180
     rb_defout = s_req;
 #endif
     rb_global_variable(&s_req );
 
+    s_req_stderr = Data_Make_Struct( cLSAPI, lsapi_data, lsapi_mark, free, s_stderr_data );
+    s_stderr_data->req = &g_req;
+    s_stderr_data->fn_write = LSAPI_Write_Stderr_r;
+    rb_stderr = s_req_stderr;
+    rb_global_variable(&s_req_stderr );
+
+    //constant silence hack
+    orig_verbose = (VALUE)ruby_verbose;
+    ruby_verbose = Qnil;
+
+    lsapi_env = rb_hash_new();
+    //redefine ENV using a hash table, should be faster than char **environment
+    rb_define_global_const("ENV", lsapi_env);
+    
+    rb_define_global_const("STDERR", rb_stderr);
+
+    ruby_verbose = (VALUE)orig_verbose;
+    
     return;
 }