Changeset 1759

Timestamp:

08/07/08 13:38:21 (5 months ago)

Author:

alo

Message:

--

Files:

• cherokee/trunk/ChangeLog (modified) (1 diff)
• cherokee/trunk/cherokee/fdpoll-port.c (modified) (1 diff)
• cherokee/trunk/cherokee/macros.h (modified) (1 diff)
• cherokee/trunk/cherokee/server.c (modified) (4 diffs)
• cherokee/trunk/cherokee/socket.c (modified) (4 diffs)
• cherokee/trunk/cherokee/thread.c (modified) (24 diffs)
• cherokee/trunk/cherokee/thread.h (modified) (1 diff)
• cherokee/trunk/cherokee/util.c (modified) (1 diff)
• cherokee/trunk/cherokee/util.h (modified) (1 diff)

cherokee/trunk/ChangeLog

@@ +1 @@
+2008-08-07  Alvaro Lopez Ortega  <alvaro@alobbs.com>
+
+        * cherokee/macros.h, cherokee/socket.c, cherokee/thread.c,
+        cherokee/thread.h, cherokee/util.c, cherokee/util.h,
+        cherokee/fdpoll-port.c, cherokee/server.c: This patch makes the
+        server to reply a quickly built 503 error page when it is
+        overloaded. This is a very special case because the page is not
+        sent by using the server infrastructure but by punching a
+        pre-built string into the socket and closing it right after it.
+        Additionally, the patch also do some clean-up along the way.
+
-2008-08-06  Alvaro Lopez Ortega  <alvaro@alobbs.com>
-

cherokee/trunk/cherokee/fdpoll-port.c

@@ -236 +236 @@
-_reset (cherokee_fdpoll_port_t *fdp, int fd)
-{
+        UNUSED (fdp);
+        UNUSED (fd);
+
-        return ret_ok;
-}

cherokee/trunk/cherokee/macros.h

@@ -164 +164 @@
-
-#define SHOULDNT_HAPPEN \
-n'
+ no
-                      __FILE__, __LINE__, __cherokee_func__);               \
-        } while (0)

cherokee/trunk/cherokee/server.c

@@ -763 +763 @@
-         * and thus already open connection.
-         */
-
-
-
+ 
+  
+ 
-
-        /* Set mean fds per thread.
@@ -785 +785 @@
-         */
-        if (srv->thread_num == 1) {
-
-
-
+
+
-                        return ret;
+
+                if (srv->tls_enabled) {
+                        ret = cherokee_fdpoll_add (srv->main_thread->fdpoll, S_SOCKET_FD(srv->socket_tls), 0);
+                        if (ret < ret_ok)
+                                return ret;
-                }
-        }
@@ -809 +813 @@
-                        fds_per_thread1 += 2;
-                }
-
-
-
+ 
+  
+ 
-
-                /* NOTE: mean fds per thread has already been set above.
@@ -840 +844 @@
-                srv->conns_keepalive_max = srv->conns_max - 6;
-
-        /* OK, return.
-         */
-        return ret_ok;
-}

cherokee/trunk/cherokee/socket.c

@@ -501 +501 @@
-        ret_t ret;
-
+        /* Sanity check
+         */
-        if (socket->socket < 0) {
-                return ret_error;
-        }
-
+        /* SSL/TLS shutdown
+         */
-#ifdef HAVE_TLS
-        if (socket->is_tls == TLS && socket->session != NULL) {
-if   defined (HAVE_GNUTLS)
+ ifdef HAVE_GNUTLS
-                gnutls_bye (socket->session, GNUTLS_SHUT_WR);
-                gnutls_deinit (socket->session);
-                socket->session = NULL;
-
-elif defined 
+ elif defined
-                SSL_shutdown (socket->session);
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        TRACE (ENTRIES",close", "fd=%d is_tls=%d re=%d\n", 
-               socket->socket, socket->is_tls, (int) ret);
@@ -607 +619 @@
-        switch (SOCKET_AF(socket)) {
-        case AF_INET:
- defined(HAVE_INET_PTON)
+def HAVE_INET_PTON
-                re = inet_pton (AF_INET, host->buf, &SOCKET_SIN_ADDR(socket));
-                if (re <= 0) return ret_error;
@@ -643 +655 @@
-        ret = cherokee_socket_set_sockaddr (socket, fd, &sa);
-        if (unlikely(ret < ret_ok)) {
-close_fd
+fd_close
-                SOCKET_FD(socket) = -1;
-                return ret;
@@ -692 +704 @@
-         */
-        len = sizeof (cherokee_sockaddr_t);
+
-        new_socket = accept (server_socket, &sa->sa, &len);
-        if (new_socket < 0) {

cherokee/trunk/cherokee/thread.c

@@ -156 +156 @@
-        n->reuse_list_num     = 0;
-        n->pending_conns_num  = 0;
-        n->is_accepting_conns = false;
-
-        n->fastcgi_servers    = NULL;
@@ -176 +175 @@
-        if (fd_num < conns_max) {
-                cherokee_fdpoll_free (n->fdpoll);
-
+ 
-                return ret_error;
-        }
-
-        /* Number of connections that the thread can accept.
-         */
-        n->conns_accept = (90 * conns_max / 100);
-        if (conns_max > n->conns_accept + 5)
-                n->conns_accept = conns_max - 5;
-
-        /* Bogo now stuff
@@ -1263 +1256 @@
-}
-
+static void
+thread_full_handler (cherokee_thread_t *thd, int srv_socket)
+{
+        ret_t                ret;
+        cherokee_list_t     *i;
+        cherokee_socket_t    sock;
+        size_t               read  = 0;
+        cherokee_boolean_t   done  = false;
+        cherokee_server_t   *srv   = THREAD_SRV(thd);
+        cherokee_buffer_t   *tmp   = THREAD_TMP_BUF1(thd);
+
+        /* Short path: nothing to accept
+         */
+        if (cherokee_fdpoll_check (thd->fdpoll, srv_socket, FDPOLL_MODE_READ) <= 0) {
+                return;
+        }
+
+        /* Check all the threads
+         */
+        list_for_each (i, &srv->thread_list) {
+                if (THREAD(i)->conns_num < THREAD(i)->conns_max)
+                        return;
+        }
+
+        if (srv->main_thread->conns_num < srv->main_thread->conns_max)
+                return;
+
+        /* In case there is no room in the entire server. The best
+         * thing we can do reached this point is to get rid of the
+         * connection as soon and quickly as possible.
+         */
+        ret = cherokee_socket_init (&sock);
+        if (unlikely (ret != ret_ok))
+                goto out;
+
+        /* Accept a connection
+         */
+        do {
+                ret = cherokee_socket_accept (&sock, srv_socket);
+        } while (ret == ret_deny);
+
+        if (ret != ret_ok)
+                goto out;
+        
+        /* Read the request
+         */
+#if 0
+        do {
+                ret = cherokee_socket_read (&sock, tmp->buf, tmp->size, &read);
+        } while (ret == ret_eagain);
+#endif
+        
+        /* Write the error response
+         */
+        cherokee_buffer_clean (tmp);
+        cherokee_buffer_add_str (
+                tmp,
+                "HTTP/1.0 " http_service_unavailable_string CRLF_CRLF       \
+                "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">" CRLF \
+                "<html><head><title>" http_service_unavailable_string       \
+                "</title></head><body><h1>" http_service_unavailable_string \
+                "</h1><p>Server run out of resources.</p></body></html>");
+        do {
+                read = 0;
+
+                ret = cherokee_socket_bufwrite (&sock, tmp, &read);
+                switch (ret) {
+                case ret_ok:
+                        if (read > 0) {
+                                cherokee_buffer_move_to_begin (tmp, read);
+                        }
+                default:
+                        done = true;
+                }
+                
+                if (cherokee_buffer_is_empty (tmp))
+                        done = true;
+        } while (!done);
+
+out:
+        cherokee_socket_close (&sock);
+        cherokee_socket_mrproper (&sock);
+}
-
-static int
-__accept_from_server
+accept_new_connection
-{
-        ret_t                  ret;
@@ -1272 +1348 @@
-        cherokee_connection_t *new_conn;
-
-
-
-
-
-
+
+
-        if (cherokee_fdpoll_check (thd->fdpoll, srv_socket, FDPOLL_MODE_READ) <= 0) {
-                return 0;
@@ -1295 +1368 @@
-        if (unlikely(ret < ret_ok)) {
-                PRINT_ERROR_S ("ERROR: Trying to get a new connection object\n");
-close_fd
+fd_close
-                return 0;
-        }
@@ -1341 +1414 @@
-        /* Close new socket and reset its socket fd to default value.
-         */
-close_fd
+fd_close
-        SOCKET_FD(&new_conn->socket) = -1;
-
@@ -1356 +1429 @@
-
-static int
-__should_accept_more_from_server
+should_accept_more
-{
-        const uint32_t recalculate_steps = 10;
@@ -1364 +1437 @@
-        if (unlikely (thd->conns_num >= thd->conns_max))
-                return 0;
-
-#if 0
-        if (unlikely (cherokee_fdpoll_is_full(thd->fdpoll))) {
@@ -1399 +1471 @@
-
-ret_t 
-cherokee_thread_accept_on (cherokee_thread_t *thd)
-{
-        ret_t ret;
-
-        if (thd->is_accepting_conns)
-                return ret_ok;
-
-        /* Add server sockets to polling set.
-         */
-        ret = cherokee_fdpoll_add (thd->fdpoll,
-                S_SOCKET_FD(THREAD_SRV(thd)->socket), FDPOLL_MODE_READ);
-        if (unlikely(ret < ret_ok))
-                return ret;
-
-#ifdef HAVE_TLS
-        if (THREAD_SRV(thd)->tls_enabled) {
-                ret = cherokee_fdpoll_add (thd->fdpoll,
-                        S_SOCKET_FD(THREAD_SRV(thd)->socket_tls), FDPOLL_MODE_READ);
-                if (unlikely(ret < ret_ok))
-                        return ret;
-        }
-#endif /* HAVE_TLS */
-
-        /* Set flag and return.
-         */
-        thd->is_accepting_conns = true;
-
-        return ret_ok;
-}
-
-
-ret_t 
-cherokee_thread_accept_off (cherokee_thread_t *thd)
-{
-        ret_t ret;
-
-        if (!thd->is_accepting_conns)
-                return ret_ok;
-
-        /* Remove server sockets from polling set.
-         */
-        ret = cherokee_fdpoll_del (thd->fdpoll,
-                S_SOCKET_FD(THREAD_SRV(thd)->socket));
-        if (unlikely(ret < ret_ok))
-                return ret;
-
-#ifdef HAVE_TLS
-        if (THREAD_SRV(thd)->tls_enabled) {
-                ret = cherokee_fdpoll_del (thd->fdpoll,
-                        S_SOCKET_FD(THREAD_SRV(thd)->socket_tls));
-                if (unlikely(ret < ret_ok))
-                        return ret;
-        }
-#endif /* HAVE_TLS */
-
-        /* Set flag and return.
-         */
-        thd->is_accepting_conns = false;
-
-        return ret_ok;
-}
-
-
-ret_t 
-cherokee_thread_step_SINGLE_THREAD (cherokee_thread_t *thd)
-{
-        int                re;
-ret_t              ret
+cherokee_boolean_t accepting
-        cherokee_server_t *srv           = THREAD_SRV(thd);
-        int                fdwatch_msecs = srv->fdwatch_msecs;
@@ -1475 +1483 @@
-
-        /* Reset the server socket.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-#if 0
-        if (unlikely (cherokee_fdpoll_is_full (thd->fdpoll))) {
@@ -1508 +1503 @@
-                goto out;
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-#ifdef HAVE_TLS
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-out:
@@ -1536 +1542 @@
-step_MULTI_THREAD_block (cherokee_thread_t *thd, int socket, pthread_mutex_t *mutex, int fdwatch_msecs)
-{
-
-
-
-
-
+
+
+
+
-        CHEROKEE_MUTEX_LOCK (mutex);
-        
@@ -1560 +1565 @@
-        update_bogo_now (thd);
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-        ret = cherokee_fdpoll_del (thd->fdpoll, socket);
-        if (ret != ret_ok)
-                SHOULDNT_HAPPEN;
-
-
-
+
-        return ret_ok;
-}
@@ -1577 +1590 @@
-step_MULTI_THREAD_nonblock (cherokee_thread_t *thd, int socket, pthread_mutex_t *mutex, int fdwatch_msecs)
-{
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-        if (unlocked) {
-                cherokee_fdpoll_watch (thd->fdpoll, fdwatch_msecs);
@@ -1592 +1603 @@
-        }
-
-.
+
-         */
-        ret = cherokee_fdpoll_add (thd->fdpoll, socket, FDPOLL_MODE_READ);
-        if (unlikely (ret < ret_ok)) {
-
-
-
-
-
+
+
+
+
-        cherokee_fdpoll_watch (thd->fdpoll, fdwatch_msecs);
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        ret = cherokee_fdpoll_del (thd->fdpoll, socket);
-        if (ret != ret_ok)
-                SHOULDNT_HAPPEN;
-
+        ret = ret_ok;
+
+out:
-        CHEROKEE_MUTEX_UNLOCK (mutex);
-
-
+
+
-}
-
@@ -1623 +1646 @@
-                                int socket_tls, pthread_mutex_t *mutex_tls)
-{
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-                ret = cherokee_fdpoll_add (thd->fdpoll, socket, FDPOLL_MODE_READ);
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-                ret = cherokee_fdpoll_add (thd->fdpoll, socket_tls, FDPOLL_MODE_READ);
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-         */
-        cherokee_fdpoll_watch (thd->fdpoll, fdwatch_msecs);
-                
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-                
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                CHEROKEE_MUTEX_UNLOCK (mutex);
-
-
-
-
-
-
-
-
-
-
+
-                CHEROKEE_MUTEX_UNLOCK (mutex_tls);
-
-
-
-
-
-
-
-
-
-
+
+
-}
-
@@ -1707 +1734 @@
-        cherokee_socket_type_t  type1;
-        cherokee_socket_type_t  type2;
+        cherokee_boolean_t      accepting;
-
-        if (thd->thread_pref == thread_tls_normal) {
@@ -1726 +1754 @@
-        }
-
-        /* In this case, thd->is_accepting_conns is alwasy true.
-         */
-
-        /* Lock the main mutex
-         */
@@ -1738 +1763 @@
-                return ret_error;
-        }
-
-
+
+
+
-
-        /* Try to lock the optional groups
@@ -1762 +1788 @@
-
-        /* Update the thread time values before accept new connections.
- a goo
+s an update
-         */
-        update_bogo_now (thd);
-                
-
-
-
+
+
+
+
+
+
+
+
+
+
-
-        /* Unlock the mail lock
@@ -1783 +1816 @@
-        if (!unlock2) {
-                do {
-__accept_from_server
-__should_accept_more_from_server
+accept_new_connection
+should_accept_more
-                
-                ret = cherokee_fdpoll_del (thd->fdpoll, socket2);
@@ -1806 +1839 @@
-        int                fdwatch_msecs = srv->fdwatch_msecs;
-
-
-        /* Try to update bogo_now
-         */
-        cherokee_bogotime_try_update();
-
-        /* If the thread is full of connections, it should not
-         * get new connections.
-         */
-        if (thd->conns_num >= thd->conns_max) {
-                if (thd->is_accepting_conns)
-                        thd->is_accepting_conns = false;
-        }
-        else if (thd->conns_num < thd->conns_accept) {
-                if (!thd->is_accepting_conns)
-                        thd->is_accepting_conns = true;
-        }
-
-#if 0
@@ -1841 +1861 @@
-         */
-        if (srv->tls_enabled) {
-
+
+
-                    (thd->active_list_num == 0) &&
-
+
+
-                        step_MULTI_THREAD_TLS_block (thd, fdwatch_msecs, 
-
+    
-                            S_SOCKET_FD(srv->socket_tls), &THREAD_SRV(thd)->accept_tls_mutex);
-                } else {
-                        step_MULTI_THREAD_TLS_nonblock (thd, fdwatch_msecs, 
-
+    
-                            S_SOCKET_FD(srv->socket_tls), &THREAD_SRV(thd)->accept_tls_mutex);
-                }
@@ -1859 +1881 @@
-        /* Try to get new connections from http
-         */
-
+
+
-            (thd->active_list_num == 0) && 
-
-
+
+
+
+
-        } else {
-
+
+
-        }
-        

cherokee/trunk/cherokee/thread.h

@@ -75 +75 @@
-        cherokee_boolean_t      exit;
-
-        cherokee_boolean_t      is_accepting_conns; /* true=accepts new conns */
-
-        int                     conns_num;          /* open connections */
-
-
+
-
-        int                     active_list_num;    /* active connections */

cherokee/trunk/cherokee/util.c

@@ -1242 +1242 @@
-
-ret_t 
-close_fd (cint_
+fd_close (in
-{
-        int re;
-        
-fd < 0
+unlikely (fd < 0)
-                return ret_error;
-        }

cherokee/trunk/cherokee/util.h

@@ -111 +111 @@
-ret_t cherokee_fd_set_nodelay     (int fd, cherokee_boolean_t enable);
-ret_t cherokee_fd_set_closexec    (int fd);
+ret_t cherokee_fd_close           (int fd);
-
-ret_t cherokee_sys_fdlimit_get (cuint_t *limit);
-ret_t cherokee_sys_fdlimit_set (cuint_t  limit);
-ret_t cherokee_close_fd        (cint_t fd);
-ret_t cherokee_get_shell       (const char **shell, const char **binary);
-void  cherokee_print_wrapped   (cherokee_buffer_t *buffer);