ruby-lsapi 3.5 → 4.0

data/ext/lsapi/extconf.rb

@@ -3,4 +3,7 @@ dir_config( 'lsapi' )
 if ( have_library( "socket" ))
     have_library( "nsl" )
 end
+if RUBY_VERSION =~ /1.9/ then
+    $CPPFLAGS += " -DRUBY_19"
+end 
 create_makefile( "lsapi" )

data/ext/lsapi/lsapilib.c

@@ -75,6 +75,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 static int g_inited = 0;
 static int g_running = 1;
 static int s_ppid;
+static int s_slow_req_msecs = 0;
 LSAPI_Request g_req = { -1, -1 };
 
 void Flush_RespBuf_r( LSAPI_Request * pReq );
@@ -532,11 +533,14 @@ static int parseRequest( LSAPI_Request * pReq, int totalLen )
     return 0;
 }
 
+//OPTIMIZATION
+static int s_accept_notify = 0;
+
 static struct lsapi_packet_header ack = {'L', 'S',
                 LSAPI_REQ_RECEIVED, LSAPI_ENDIAN, {LSAPI_PACKET_HEADER_LEN} };
-static inline int notify_req_received( LSAPI_Request * pReq )
+static inline int notify_req_received( int fd )
 {
-    if ( write( pReq->m_fd, &ack, LSAPI_PACKET_HEADER_LEN )
+    if ( write( fd, &ack, LSAPI_PACKET_HEADER_LEN )
                 < LSAPI_PACKET_HEADER_LEN )
         return -1;
     return 0;
@@ -587,7 +591,11 @@ static int readReq( LSAPI_Request * pReq )
     pReq->m_bufProcessed = packetLen;
     pReq->m_reqState = LSAPI_ST_REQ_BODY | LSAPI_ST_RESP_HEADER;
 
-    return notify_req_received( pReq );
+    //OPTIMIZATION
+    if ( !s_accept_notify )
+        return notify_req_received( pReq->m_fd );
+    else
+        return 0;
 }
 
 
@@ -699,6 +707,9 @@ int LSAPI_Accept_r( LSAPI_Request * pReq )
                         setsockopt(pReq->m_fd, IPPROTO_TCP, TCP_NODELAY,
                                    (char *)&nodelay, sizeof(nodelay));
                     }
+                    //OPTIMIZATION
+                    if ( s_accept_notify )
+                        return notify_req_received( pReq->m_fd );
                 }
             }
             else
@@ -927,24 +938,36 @@ int LSAPI_Write_r( LSAPI_Request * pReq, const char * pBuf, int len )
     int bufLen;
     int toWrite;
     int packetLen;
+    int skip = 0;
     
     if ( !pReq || !pBuf || (pReq->m_fd == -1) )
         return -1;
-    if ( len < pReq->m_pRespBufEnd - pReq->m_pRespBufPos )
-    {
-        memmove( pReq->m_pRespBufPos, pBuf, len );
-        pReq->m_pRespBufPos += len;
-        return len;
-    }
-    
     if ( pReq->m_reqState & LSAPI_ST_RESP_HEADER )
     {
         LSAPI_FinalizeRespHeaders_r( pReq );
+/*
+        if ( *pBuf == '\r' )
+        {
+            ++skip;
+        }
+        if ( *pBuf == '\n' )
+        {
+            ++skip;
+        }
+*/
     }
     pReq->m_reqState |= LSAPI_ST_RESP_BODY;
+
+    if ( (len - skip) < pReq->m_pRespBufEnd - pReq->m_pRespBufPos )
+    {
+        memmove( pReq->m_pRespBufPos, pBuf + skip, len - skip );
+        pReq->m_pRespBufPos += len - skip;
+        return len;
+    }
+    
     
     pHeader = pReq->m_respPktHeader;
-    p       = pBuf;
+    p       = pBuf + skip;
     pEnd    = pBuf + len;
     bufLen  = pReq->m_pRespBufPos - pReq->m_pRespBuf;
     
@@ -1384,6 +1407,16 @@ int LSAPI_AppendRespHeader_r( LSAPI_Request * pReq, char * pBuf, int len )
         return -1;
     if ( pReq->m_respHeader.m_respInfo.m_cntHeaders >= LSAPI_MAX_RESP_HEADERS )
         return -1;
+    while( len > 0 )
+    {
+        char ch = *(pBuf + len - 1 );
+        if (( ch == '\n' )||( ch == '\r' ))
+            --len;
+        else
+            break;
+    }
+    if ( len <= 0 )
+        return 0;
     if ( pReq->m_pRespHeaderBufPos + len + 1 > pReq->m_pRespHeaderBufEnd )
     {
         int newlen = pReq->m_pRespHeaderBufPos + len + 4096 - pReq->m_pRespHeaderBuf;
@@ -1646,6 +1679,9 @@ static int lsapi_accept( int fdListen )
             setsockopt( fd, IPPROTO_TCP, TCP_NODELAY,
                     (char *)&nodelay, sizeof(nodelay));
         }
+        //OPTIMIZATION
+        if ( s_accept_notify )
+            notify_req_received( fd );
     }
     return fd;
 
@@ -1955,6 +1991,11 @@ static int lsapi_prefork_server_accept( lsapi_prefork_server * pServer, LSAPI_Re
 
 }
 
+void lsapi_error( char * pMessage, int err_no )
+{
+    fprintf( stderr, "%d: %s, errno: %d (%s)\n", getpid(), pMessage, err_no, strerror( err_no ) );
+}
+
 int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
 {
     int             fd;
@@ -1989,7 +2030,10 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
         else if ( pReq->m_fdListen != -1 )
             fd = pReq->m_fdListen;
         else
+        {
+            lsapi_error( "no available fd", 0 );
             return -1;
+        }
         wait_secs = 0;
         while( 1 )
         {
@@ -2037,6 +2081,7 @@ int LSAPI_Prefork_Accept_r( LSAPI_Request * pReq )
                     {
                         if (( errno == EINTR )||( errno == EAGAIN))
                             continue;
+                        lsapi_error( "lsapi_accept() error", errno );
                         return -1;
                     }
                 }
@@ -2100,6 +2145,16 @@ void LSAPI_Set_Server_Max_Idle_Secs( int serverMaxIdle )
         g_prefork_server->m_iServerMaxIdle = serverMaxIdle;
 }
 
+void LSAPI_Set_Slow_Req_Msecs( int msecs )
+{
+    s_slow_req_msecs = msecs;
+}
+
+int  LSAPI_Get_Slow_Req_Msecs()
+{
+    return s_slow_req_msecs;
+}
+
 
 void LSAPI_No_Check_ppid()
 {
@@ -2154,6 +2209,19 @@ void LSAPI_Init_Env_Parameters( fn_select_t fp )
         avoidFork = atoi( p );
     }    
 
+    p = getenv( "LSAPI_ACCEPT_NOTIFY" );
+    if ( p )
+    {
+        s_accept_notify = atoi( p );
+    }
+
+    p = getenv( "LSAPI_SLOW_REQ_MSECS" );
+    if ( p ) 
+    {
+        n = atoi( p );
+        LSAPI_Set_Slow_Req_Msecs( n );
+    }
+
 #if defined( RLIMIT_CORE )
     p = getenv( "LSAPI_ALLOW_CORE_DUMP" );
     if ( !p )

data/ext/lsapi/lsapilib.h

@@ -331,6 +331,10 @@ void LSAPI_Set_Max_Process_Time( int secs );
 
 void LSAPI_Init_Env_Parameters( fn_select_t fp );
 
+void LSAPI_Set_Slow_Req_Msecs( int msecs );
+
+int  LSAPI_Get_Slow_Req_Msecs( );
+
 #if defined (c_plusplus) || defined (__cplusplus)
 }
 #endif

data/ext/lsapi/lsruby.c

@@ -1,6 +1,11 @@
 
 #include "ruby.h"
+
+#ifdef RUBY_19
+#include <ruby/util.h>
+#else
 #include "util.h"
+#endif
 
 #include "lsapilib.h"
 #include <errno.h>
@@ -251,10 +256,10 @@ static VALUE lsapi_write( VALUE self, VALUE str )
     lsapi_data *data;
     int len;
     Data_Get_Struct(self,lsapi_data, data);
-/*    len = LSAPI_Write_r( data->req, RSTRING(str)->ptr, RSTRING(str)->len ); */
+/*    len = LSAPI_Write_r( data->req, RSTRING_PTR(str), RSTRING_LEN(str) ); */
     if (TYPE(str) != T_STRING)
 	    str = rb_obj_as_string(str);
-    len = (*data->fn_write)( data->req, RSTRING(str)->ptr, RSTRING(str)->len );
+    len = (*data->fn_write)( data->req, RSTRING_PTR(str), RSTRING_LEN(str) );
     return INT2NUM( len );
 }
 
@@ -302,14 +307,35 @@ static VALUE lsapi_printf(int argc, VALUE *argv, VALUE out)
 
 static VALUE lsapi_puts _((int, VALUE*, VALUE));
 
+#ifdef RUBY_19
+static VALUE lsapi_puts_ary(VALUE ary, VALUE out, int recur )
+{
+    VALUE tmp;
+    long i;
+
+    if (recur) 
+    {
+        tmp = rb_str_new2("[...]");
+        rb_io_puts(1, &tmp, out);
+        return Qnil;
+    }
+    for (i=0; i<RARRAY_LEN(ary); i++) 
+    {
+        tmp = RARRAY_PTR(ary)[i];
+        rb_io_puts(1, &tmp, out);
+    }
+    return Qnil;
+
+}
+#else
 static VALUE lsapi_puts_ary(VALUE ary, VALUE out)
 {
     VALUE tmp;
     int i;
 
-    for (i=0; i<RARRAY(ary)->len; i++)
+    for (i=0; i<RARRAY_LEN(ary); i++)
     {
-        tmp = RARRAY(ary)->ptr[i];
+        tmp = RARRAY_PTR(ary)[i];
 	    if (rb_inspecting_p(tmp))
         {
 	        tmp = rb_str_new2("[...]");
@@ -318,6 +344,7 @@ static VALUE lsapi_puts_ary(VALUE ary, VALUE out)
     }
     return Qnil;
 }
+#endif
 
 static VALUE lsapi_puts(int argc, VALUE *argv, VALUE out)
 {
@@ -338,7 +365,11 @@ static VALUE lsapi_puts(int argc, VALUE *argv, VALUE out)
             line = rb_str_new2("nil");
             break;
         case T_ARRAY:
+#ifdef RUBY_19
+            rb_exec_recursive(lsapi_puts_ary, argv[i], out);
+#else
             rb_protect_inspect(lsapi_puts_ary, argv[i], out);
+#endif
             continue;
         default:
             line = argv[i];
@@ -346,7 +377,7 @@ static VALUE lsapi_puts(int argc, VALUE *argv, VALUE out)
         }
         line = rb_obj_as_string(line);
         lsapi_write(out, line);
-        if (RSTRING(line)->ptr[RSTRING(line)->len-1] != '\n')
+        if (*( RSTRING_PTR(line) + RSTRING_LEN(line) - 1 ) != '\n')
         {
             lsapi_write(out, rb_default_rs);
         }
@@ -410,7 +441,7 @@ static VALUE lsapi_gets( VALUE self )
             rb_str_buf_cat( str, buff, len );
         
     }
-    if (RSTRING(str)->len == 0)
+    if (RSTRING_LEN(str) == 0)
         return Qnil;
     return str;
 }
@@ -455,7 +486,7 @@ static VALUE lsapi_read(int argc, VALUE *argv, VALUE self)
             break;
         }
     }
-    if (RSTRING(str)->len == 0)
+    if (RSTRING_LEN(str) == 0)
         return Qnil;
     return str;
 }
@@ -619,6 +650,7 @@ void Init_lsapi()
     ruby_verbose = Qnil;
 
     lsapi_env = rb_hash_new();
+    clear_env();
     /* redefine ENV using a hash table, should be faster than char **environment */
     rb_define_global_const("ENV", lsapi_env);
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-lsapi
 version: !ruby/object:Gem::Version 
-  version: "3.5"
+  version: "4.0"
 platform: ruby
 authors: 
 - LiteSpeed Technologies Inc.
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-14 00:00:00 -04:00
+date: 2010-02-10 00:00:00 -05:00
 default_executable: 
 dependencies: []