Changeset 1770

Show
Ignore:
Timestamp:
08/07/08 21:18:40 (4 months ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r1769 r1770  
    112008-08-07  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    22 
    3         * cherokee/socket.c: Reimplemented using the TCP layer nondelay 
     3        * cherokee/main.c, cherokee/main_guardian.c, 
     4        cherokee/server-protected.h, cherokee/server.c, cherokee/server.h: 
     5        Implement gratefully restart (aka: from now on, you can upgrade 
     6        your Cherokee binary without killing the existing connections). 
     7 
     8        * cherokee/socket.c: Reimplemented using the TCP layer nodelay 
    49        property instead of the file descriptor level. 
    510 

  • cherokee/trunk/cherokee/main.c

    r1738 r1770  
    2424 
    2525#include "common-internal.h" 
     26 
    2627#include <signal.h> 
     28#include <unistd.h> 
     29 
    2730#include "init.h" 
    2831#include "server.h" 
    2932#include "info.h" 
     33#include "server-protected.h" 
     34#include "util.h" 
    3035 
    3136#ifdef HAVE_GETOPT_LONG 
    …… 
    95100 
    96101static void 
    97 restart_server_cb (cherokee_server_t *new_srv) 
    98 { 
    99         ret_t ret; 
    100  
    101         srv = new_srv; 
    102         ret = common_server_initialization (srv); 
    103         if (ret != ret_ok) exit(3); 
    104 } 
    105  
    106 static void 
    107102restart_server (int code) 
    108103{        
    109104        UNUSED(code); 
    110105        printf ("Handling HUP signal..\n"); 
    111         cherokee_server_handle_HUP (srv, restart_server_cb); 
     106        cherokee_server_handle_HUP (srv); 
    112107} 
    113108 
    …… 
    123118test_configuration_file (void) 
    124119{ 
    125         ret_t  ret; 
    126         char  *config; 
     120        ret_t  ret; 
     121        char  *config; 
    127122 
    128123        config = (config_file) ? config_file : DEFAULT_CONFIG_FILE; 
    …… 
    132127        return ret; 
    133128} 
     129 
    134130 
    135131static ret_t 
    …… 
    307303                ret = cherokee_server_step (srv); 
    308304        } while (ret == ret_eagain); 
    309          
     305 
    310306        cherokee_server_stop (srv); 
    311307        cherokee_server_free (srv); 

  • cherokee/trunk/cherokee/main_guardian.c

    r1695 r1770  
    4141#define PID_FILE          CHEROKEE_VAR_RUN "/cherokee-guardian.pid" 
    4242 
    43 pid_t pid; 
    44  
     43pid_t              pid; 
     44cherokee_boolean_t grateful_restart;  
    4545 
    4646static void 
    …… 
    8484        int   exitcode = 0; 
    8585 
    86         re = waitpid (pid, &exitcode, 0); 
    87         if (re == -1)  
    88                 return ret_error; 
     86        while (true) { 
     87                re = waitpid (pid, &exitcode, 0); 
     88                if (re > 0) 
     89                        break; 
     90                else if (errno == EINTR)  
     91                        if (grateful_restart) 
     92                                break; 
     93                        else 
     94                                continue; 
     95                else  
     96                        return ret_error; 
     97        } 
    8998 
    9099        if (WIFEXITED(exitcode)) { 
    …… 
    114123        switch (sig) { 
    115124        case SIGUSR1: 
    116                 /* Restart Cherokee */ 
     125                /* Restart: the tough way */ 
    117126                kill (pid, SIGINT); 
    118127                process_wait (pid); 
    119128                break; 
    120129 
    121         case SIGCHLD: 
    122                 /* Child exited */ 
    123                 wait (&exitcode); 
     130        case SIGHUP: 
     131                /* Grateful restart */ 
     132                grateful_restart = true; 
     133                kill (pid, SIGHUP); 
    124134                break; 
    125135 
    …… 
    131141                exit(0); 
    132142 
     143        case SIGCHLD: 
     144                /* Child exited */ 
     145                wait (&exitcode); 
     146                break; 
     147                 
    133148        default: 
    134149                /* Forward the signal */ 
    …… 
    157172 
    158173        sigaction (SIGHUP,  &act, NULL); 
    159         sigaction (SIGSEGV, &act, NULL); 
    160174        sigaction (SIGTERM, &act, NULL); 
    161175        sigaction (SIGUSR1, &act, NULL); 
     176        sigaction (SIGCHLD, &act, NULL); 
    162177} 
    163178 
    …… 
    241256         
    242257        while (true) { 
     258                grateful_restart = false; 
     259 
    243260                pid = process_launch (CHEROKEE_SRV_PATH, argv); 
    244261                if (pid < 0) { 
    …… 
    247264                } 
    248265                 
    249                 ret = process_wait (pid);               
     266                ret = process_wait (pid); 
    250267                if (single_time) 
    251268                        break; 

  • cherokee/trunk/cherokee/server-protected.h

    r1763 r1770  
    6262        /* Exit related 
    6363         */ 
    64         time_t                       start_time; 
    65         cherokee_buffer_t            panic_action; 
    66         cherokee_boolean_t           wanna_exit; 
    67         cherokee_boolean_t           wanna_reinit; 
    68         cherokee_server_reinit_cb_t  reinit_callback; 
     64        time_t                     start_time; 
     65        cherokee_buffer_t          panic_action; 
     66        cherokee_boolean_t         wanna_exit; 
     67        cherokee_boolean_t         wanna_reinit; 
    6968         
    7069        /* Virtual servers 

  • cherokee/trunk/cherokee/server.c

    r1761 r1770  
    121121        n->wanna_exit      = false; 
    122122        n->wanna_reinit    = false; 
    123         n->reinit_callback = NULL; 
    124123         
    125124        /* Server config 
    …… 
    317316 
    318317#ifdef HAVE_TLS 
    319         cherokee_socket_close (&srv->socket); 
    320         cherokee_socket_mrproper (&srv->socket); 
     318        cherokee_socket_close (&srv->socket_tls); 
     319        cherokee_socket_mrproper (&srv->socket_tls); 
    321320 
    322321        CHEROKEE_MUTEX_DESTROY (&srv->accept_tls_mutex); 
    …… 
    11381137                return ret_ok; 
    11391138 
     1139        /* Stop all the threads (may be slow) 
     1140         */ 
     1141        stop_threads (srv); 
     1142 
    11401143        /* Close all connections 
    11411144         */ 
    …… 
    11451148         */ 
    11461149        flush_logs (srv); 
    1147  
    1148         return ret_ok; 
    1149 } 
    1150  
    1151  
    1152 ret_t  
    1153 cherokee_server_reinit (cherokee_server_t *srv) 
    1154 { 
    1155         ret_t                        ret; 
    1156         cherokee_server_t           *new_srv   = NULL; 
    1157         cherokee_server_reinit_cb_t  reinit_cb = NULL;  
    1158  
    1159         if (srv->chrooted) { 
    1160                 PRINT_ERROR_S ("WARNING: Chrooted cherokee cannot be reloaded. " 
    1161                                "Please, stop and restart it again.\n"); 
    1162                 return ret_ok; 
    1163         } 
    1164  
    1165 #if 0 
    1166         { 
    1167                 int tmp; 
    1168                 printf ("Handling server reinit. Press any key to continue..\n"); 
    1169                 read (0, &tmp, 1); 
    1170         } 
    1171 #endif 
    1172  
    1173         reinit_cb = srv->reinit_callback; 
    1174  
    1175         /* Stop the server. 
    1176          */ 
    1177         ret = cherokee_server_stop (srv); 
    1178         if (ret != ret_ok) 
    1179                 return ret; 
    1180  
    1181         /* Destroy the server. 
    1182          */ 
    1183         ret = cherokee_server_free (srv); 
    1184         if (ret != ret_ok) 
    1185                 return ret; 
    1186         srv = NULL; 
    1187  
    1188         /* Create a new one 
    1189          */ 
    1190         ret = cherokee_server_new (&new_srv); 
    1191         if (ret != ret_ok) 
    1192                 return ret; 
    1193  
    1194         /* Send event 
    1195          */ 
    1196         if ((reinit_cb != NULL) && (new_srv != NULL)) { 
    1197                 reinit_cb (new_srv); 
    1198         } 
    11991150 
    12001151        return ret_ok; 
    …… 
    12331184cherokee_server_step (cherokee_server_t *srv) 
    12341185{ 
    1235         ret_t ret; 
    1236  
    12371186        /* Get the server time. 
    12381187         */ 
    …… 
    12421191        /* Execute thread step. 
    12431192         */ 
    1244 #ifndef HAVE_PTHREAD 
    1245         ret = cherokee_thread_step_SINGLE_THREAD (srv->main_thread); 
    1246 #else 
    1247         if (srv->thread_num == 1) 
    1248                 ret = cherokee_thread_step_SINGLE_THREAD (srv->main_thread); 
    1249         else 
    1250                 ret = cherokee_thread_step_MULTI_THREAD (srv->main_thread, true); 
    1251 #endif 
     1193#ifdef HAVE_PTHREAD 
     1194        if (srv->thread_num > 1) { 
     1195                cherokee_thread_step_MULTI_THREAD (srv->main_thread, true); 
     1196        } else  
     1197#endif 
     1198                cherokee_thread_step_SINGLE_THREAD (srv->main_thread); 
     1199                 
    12521200        /* Logger flush  
    12531201         */ 
    …… 
    12651213         */ 
    12661214        if (unlikely (srv->wanna_reinit)) { 
    1267                 ret = cherokee_server_reinit (srv); 
    1268  
    1269                 /* NOTE: we MUST return in any case because 
    1270                  * the old srv server should have just been destroyed and 
    1271                  * a new server should have been created, 
    1272                  * in this case we cannot use the old srv ptr. 
    1273                  */ 
    1274                 return ret; 
     1215                cherokee_list_t    *i; 
     1216                cherokee_boolean_t  empty = true; 
     1217 
     1218                list_for_each (i, &srv->thread_list) { 
     1219                        if (THREAD(i)->conns_num != 0) { 
     1220                                empty = false; 
     1221                                break; 
     1222                        } 
     1223                } 
     1224                 
     1225                if (empty) 
     1226                        empty = (srv->main_thread->conns_num == 0); 
     1227 
     1228                if (empty) 
     1229                        return ret_eof; 
    12751230        } 
    12761231         
    …… 
    12781233         */ 
    12791234        if (unlikely (srv->wanna_exit)) { 
    1280                 stop_threads (srv); 
    1281                 flush_logs (srv); 
    1282                 return ret_ok; 
     1235                return ret_eof; 
    12831236        } 
    12841237 
    …… 
    18181771 
    18191772ret_t  
    1820 cherokee_server_handle_HUP (cherokee_server_t *srv, cherokee_server_reinit_cb_t callback) 
    1821 { 
    1822         srv->reinit_callback = callback; 
     1773cherokee_server_handle_HUP (cherokee_server_t *srv) 
     1774{ 
    18231775        srv->wanna_reinit    = true; 
     1776        srv->keepalive       = false; 
     1777        srv->keepalive_max   = 0; 
     1778 
     1779        cherokee_socket_close (&srv->socket); 
     1780        cherokee_socket_close (&srv->socket_tls); 
    18241781 
    18251782        return ret_ok; 

  • cherokee/trunk/cherokee/server.h

    r1567 r1770  
    3434#include <stddef.h> 
    3535 
    36  
    3736CHEROKEE_BEGIN_DECLS 
    3837 
     38 
    3939typedef struct cherokee_server cherokee_server_t; 
    40 typedef void (* cherokee_server_reinit_cb_t) (cherokee_server_t *new_srv); 
    41  
    4240#define SRV(x) ((cherokee_server_t *)(x)) 
    4341 
    …… 
    4947ret_t cherokee_server_step               (cherokee_server_t *srv); 
    5048ret_t cherokee_server_stop               (cherokee_server_t *srv); 
    51 ret_t cherokee_server_reinit             (cherokee_server_t *srv); 
    5249 
    5350void  cherokee_server_set_min_latency    (cherokee_server_t *srv, int msecs); 
    …… 
    7168/* System signal callback 
    7269 */ 
    73 ret_t cherokee_server_handle_HUP   (cherokee_server_t *srv, cherokee_server_reinit_cb_t callback); 
     70ret_t cherokee_server_handle_HUP   (cherokee_server_t *srv); 
    7471ret_t cherokee_server_handle_TERM  (cherokee_server_t *srv); 
    7572ret_t cherokee_server_handle_panic (cherokee_server_t *srv);