global: Rename service_idle_kill to service_idle_kill_interval

Also rename related functions and macros.

This clarifies a bit what the setting does: It's the interval between
killing idle processes, not the amount of time when an idling process
is killed.

diff --git a/src/anvil/anvil-settings.c b/src/anvil/anvil-settings.c
index c945c92062f2d11fec559967a37d186816760838..a7daca74e222fc70027e002f870205fdb49b026d 100644 (file)
--- a/src/anvil/anvil-settings.c
+++ b/src/anvil/anvil-settings.c
@@ -20,7 +20,7 @@ struct service_settings anvil_service_settings = {
 
        .process_min_avail = 1,
        .process_limit = 1,
-       .idle_kill = SET_TIME_INFINITE,
+       .idle_kill_interval = SET_TIME_INFINITE,
 
        .unix_listeners = ARRAY_INIT,
        .fifo_listeners = ARRAY_INIT,

diff --git a/src/auth/auth-worker-server.c b/src/auth/auth-worker-server.c
index d0323ec4991dfb5e828beb2df1af54d42576b7b0..a3ed24a1437be33ef4fe65b531b79372380df495 100644 (file)
--- a/src/auth/auth-worker-server.c
+++ b/src/auth/auth-worker-server.c
@@ -1020,7 +1020,8 @@ auth_worker_server_create(struct auth *auth,
        server->refcount = 1;
        server->auth = auth;
        server->conn.event_parent = auth_event;
-       server->conn.input_idle_timeout_secs = master_service_get_idle_kill_secs(master_service);
+       server->conn.input_idle_timeout_secs =
+               master_service_get_idle_kill_interval_secs(master_service);
        connection_init_server(clients, &server->conn, master_conn->name,
                               master_conn->fd, master_conn->fd);
        auth_worker_server_send_handshake(&server->conn);

diff --git a/src/config/config-settings.c b/src/config/config-settings.c
index caa7cb958ddf1129f28ee5b4330f2a56c0a26dbe..1fc367e0cf3b503c3e9a4593d37685b3f8698300 100644 (file)
--- a/src/config/config-settings.c
+++ b/src/config/config-settings.c
@@ -18,7 +18,7 @@ struct service_settings config_service_settings = {
 
        .drop_priv_before_exec = FALSE,
 
-       .idle_kill = SET_TIME_INFINITE,
+       .idle_kill_interval = SET_TIME_INFINITE,
 
        .unix_listeners = ARRAY_INIT,
        .fifo_listeners = ARRAY_INIT,

diff --git a/src/lib-master/master-interface.h b/src/lib-master/master-interface.h
index 369e0930c97c154adf1919996b5dd1c5c6384800..73691fee004efd0836f09c6f4e5a9d6072d518ce 100644 (file)
--- a/src/lib-master/master-interface.h
+++ b/src/lib-master/master-interface.h
@@ -59,9 +59,9 @@ enum master_login_state {
    process can finish handling before it should kill itself. */
 #define MASTER_SERVICE_COUNT_ENV "SERVICE_COUNT"
 
-/* getenv(MASTER_SERVICE_IDLE_KILL_ENV) specifies service's idle_kill timeout
-   in seconds. */
-#define MASTER_SERVICE_IDLE_KILL_ENV "IDLE_KILL"
+/* getenv(MASTER_SERVICE_IDLE_KILL_ENV) specifies service's idle_kill_interval
+   timeout in seconds. */
+#define MASTER_SERVICE_IDLE_KILL_INTERVAL_ENV "IDLE_KILL_INTERVAL"
 
 /* getenv(MASTER_CONFIG_FILE_ENV) provides path to configuration file. */
 #define MASTER_CONFIG_FILE_ENV "CONFIG_FILE"

diff --git a/src/lib-master/master-service-private.h b/src/lib-master/master-service-private.h
index fc41b06db054f18c1b13406498963452d57230bf..4a75cf8e9fe8735359b3389bbaa69140e8d1433e 100644 (file)
--- a/src/lib-master/master-service-private.h
+++ b/src/lib-master/master-service-private.h
@@ -51,7 +51,7 @@ struct master_service {
        unsigned int total_available_count;
        unsigned int process_limit;
        unsigned int process_min_avail;
-       unsigned int idle_kill_secs;
+       unsigned int idle_kill_interval_secs;
 
        struct master_status master_status;
        unsigned int last_sent_status_avail_count;

diff --git a/src/lib-master/master-service.c b/src/lib-master/master-service.c
index 342babde9734caecc68b23af3634838c504683a8..84a6a4151ce3bdbe0d7986bc55b8703e98dfcbd7 100644 (file)
--- a/src/lib-master/master-service.c
+++ b/src/lib-master/master-service.c
@@ -627,9 +627,9 @@ master_service_init(const char *name, enum master_service_flags flags,
                        master_service_set_restart_request_count(service, count);
 
                /* set the idle kill timeout */
-               value = getenv(MASTER_SERVICE_IDLE_KILL_ENV);
+               value = getenv(MASTER_SERVICE_IDLE_KILL_INTERVAL_ENV);
                if (value != NULL && str_to_uint(value, &count) == 0)
-                       service->idle_kill_secs = count;
+                       service->idle_kill_interval_secs = count;
        } else {
                master_service_set_client_limit(service, 1);
                master_service_set_restart_request_count(service, 1);
@@ -1115,9 +1115,10 @@ unsigned int master_service_get_process_min_avail(struct master_service *service
        return service->process_min_avail;
 }
 
-unsigned int master_service_get_idle_kill_secs(struct master_service *service)
+unsigned int
+master_service_get_idle_kill_interval_secs(struct master_service *service)
 {
-       return service->idle_kill_secs;
+       return service->idle_kill_interval_secs;
 }
 
 void master_service_set_restart_request_count(struct master_service *service,

diff --git a/src/lib-master/master-service.h b/src/lib-master/master-service.h
index b023f3a77c75adc160c0d8e3b1d368a75c350b17..1dca3a6403bf0bdabf4e42801dc9294fc4b55289 100644 (file)
--- a/src/lib-master/master-service.h
+++ b/src/lib-master/master-service.h
@@ -210,10 +210,12 @@ unsigned int master_service_get_client_limit(struct master_service *service);
 unsigned int master_service_get_process_limit(struct master_service *service);
 /* Returns service { process_min_avail } */
 unsigned int master_service_get_process_min_avail(struct master_service *service);
-/* Returns the service's idle_kill timeout in seconds. Normally master handles
-   sending the kill request when the process has no clients, but some services
-   with permanent client connections may need to handle this themselves. */
-unsigned int master_service_get_idle_kill_secs(struct master_service *service);
+/* Returns the service's idle_kill_interval timeout in seconds. Normally master
+   handles sending the kill request when the process has no clients, but some
+   services with permanent client connections may need to handle this
+   themselves. */
+unsigned int
+master_service_get_idle_kill_interval_secs(struct master_service *service);
 
 /* Set maximum number of client connections we will handle before shutting
    down. */

diff --git a/src/lib-master/service-settings.h b/src/lib-master/service-settings.h
index 266b6a06f1010be35b376ec80c9cc7802f3f152a..40c0076459d92b293aff88be43ff14d583c570df 100644 (file)
--- a/src/lib-master/service-settings.h
+++ b/src/lib-master/service-settings.h
@@ -71,7 +71,7 @@ struct service_settings {
        unsigned int process_limit;
        unsigned int client_limit;
        unsigned int restart_request_count;
-       unsigned int idle_kill;
+       unsigned int idle_kill_interval;
        uoff_t vsz_limit;
 
        ARRAY_TYPE(const_string) unix_listeners;

diff --git a/src/log/log-settings.c b/src/log/log-settings.c
index 58e2b074a25eb01c1e536283f45e17c619ff4935..6ff0ab3590f0ebb1e50a4514f08e6f25ab13c2b6 100644 (file)
--- a/src/log/log-settings.c
+++ b/src/log/log-settings.c
@@ -19,7 +19,7 @@ struct service_settings log_service_settings = {
        .drop_priv_before_exec = FALSE,
 
        .process_limit = 1,
-       .idle_kill = SET_TIME_INFINITE,
+       .idle_kill_interval = SET_TIME_INFINITE,
 
        .unix_listeners = ARRAY_INIT,
        .fifo_listeners = ARRAY_INIT,

diff --git a/src/master/master-settings.c b/src/master/master-settings.c
index c9907d5e3ffc9b2d3acb67a40066ef9ae1716cc4..b6b39b64af96d59a6156238e3c24aef3e70bbb83 100644 (file)
--- a/src/master/master-settings.c
+++ b/src/master/master-settings.c
@@ -130,7 +130,7 @@ static const struct setting_define service_setting_defines[] = {
        DEF(UINT, process_limit),
        DEF(UINT, client_limit),
        DEF(UINT, restart_request_count),
-       DEF(TIME, idle_kill),
+       DEF(TIME, idle_kill_interval),
        DEF(SIZE, vsz_limit),
 
        { .type = SET_FILTER_ARRAY, .key = "unix_listener",
@@ -163,7 +163,7 @@ static const struct service_settings service_default_settings = {
        .process_limit = 100,
        .client_limit = 1000,
        .restart_request_count = SET_UINT_UNLIMITED,
-       .idle_kill = 60,
+       .idle_kill_interval = 60,
        .vsz_limit = 256*1024*1024,
 
        .unix_listeners = ARRAY_INIT,
@@ -728,9 +728,9 @@ master_settings_ext_check(struct event *event, void *_set,
                                service->name);
                        return FALSE;
                }
-               if (service->idle_kill == 0) {
+               if (service->idle_kill_interval == 0) {
                        *error_r = t_strdup_printf("service(%s): "
-                               "idle_kill must be higher than 0",
+                               "idle_kill_interval must be higher than 0",
                                service->name);
                        return FALSE;
                }

diff --git a/src/master/service-monitor.c b/src/master/service-monitor.c
index c349a83b45d3a703dd27646c1e46841e09724d7c..ee198d086fe686920e2bb34b4705d4cc70ee1cb5 100644 (file)
--- a/src/master/service-monitor.c
+++ b/src/master/service-monitor.c
@@ -91,7 +91,7 @@ static void service_kill_idle(struct service *service)
                }
                process->last_kill_sent = ioloop_time;
                process->to_idle_kill =
-                       timeout_add(service->idle_kill * 1000,
+                       timeout_add(service->idle_kill_interval * 1000,
                                    service_process_idle_kill_timeout, process);
 
                /* Move it to the end of the list, so it's not tried to be
@@ -167,11 +167,11 @@ static void service_check_idle(struct service_process *process)
 
        if (service->process_avail > service->set->process_min_avail &&
            service->to_idle == NULL &&
-           service->idle_kill != UINT_MAX) {
+           service->idle_kill_interval != UINT_MAX) {
                /* We have more processes than we really need. Start a timer
-                  to trigger idle_kill. */
+                  to trigger idle_kill_interval. */
                service->to_idle =
-                       timeout_add(service->idle_kill * 1000,
+                       timeout_add(service->idle_kill_interval * 1000,
                                    service_kill_idle, service);
        }
 }

diff --git a/src/master/service-process.c b/src/master/service-process.c
index 7bbf6f0337d9be926af6004fc06401d831d6475d..2d6b8dd9d7fd9f5251238780bdbf865f9b2c06bd 100644 (file)
--- a/src/master/service-process.c
+++ b/src/master/service-process.c
@@ -307,7 +307,8 @@ service_process_setup_environment(struct service *service, unsigned int uid,
        env_put(MASTER_PROCESS_LIMIT_ENV, dec2str(service->process_limit));
        env_put(MASTER_PROCESS_MIN_AVAIL_ENV,
                dec2str(service->set->process_min_avail));
-       env_put(MASTER_SERVICE_IDLE_KILL_ENV, dec2str(service->idle_kill));
+       env_put(MASTER_SERVICE_IDLE_KILL_INTERVAL_ENV,
+               dec2str(service->idle_kill_interval));
        if (service->set->restart_request_count != 0) {
                env_put(MASTER_SERVICE_COUNT_ENV,
                        dec2str(service->set->restart_request_count));

diff --git a/src/master/service.c b/src/master/service.c
index f8e15acb43a90bb8a3025fea37a6beea0800d3db..1e132988809e7443d74dd22d57fe960ee79cb0b3 100644 (file)
--- a/src/master/service.c
+++ b/src/master/service.c
@@ -209,7 +209,7 @@ service_create_real(pool_t pool, struct event *event,
                service->client_limit = set->restart_request_count;
 
        service->vsz_limit = set->vsz_limit;
-       service->idle_kill = set->idle_kill;
+       service->idle_kill_interval = set->idle_kill_interval;
        service->type = service->set->parsed_type;
        service->process_limit = set->process_limit;
 

diff --git a/src/master/service.h b/src/master/service.h
index 53591141132eaf592ab09d095e1ef54332057cab..fa546b9a7c960c1734c9655aa88fe55be134833b 100644 (file)
--- a/src/master/service.h
+++ b/src/master/service.h
@@ -75,7 +75,7 @@ struct service {
        /* number of processes currently idling (idle_start != 0) */
        unsigned int process_idling;
        /* Lowest number of processes that have been idling at the same time.
-          This is reset to process_idling every idle_kill seconds. */
+          This is reset to process_idling every idle_kill_interval seconds. */
        unsigned int process_idling_lowwater_since_kills;
        /* max number of processes allowed */
        unsigned int process_limit;
@@ -85,7 +85,7 @@ struct service {
        /* Maximum number of client connections a process can handle. */
        unsigned int client_limit;
        /* Kill idling processes after this many seconds. */
-       unsigned int idle_kill;
+       unsigned int idle_kill_interval;
        /* set->vsz_limit or set->master_set->default_client_limit */
        uoff_t vsz_limit;
 

diff --git a/src/stats/stats-settings.c b/src/stats/stats-settings.c
index 43a6ecfc9c85d242fe910f4a9c988c8c523e49ca..66283803f266857dac22f6fcf49631f26df7d121 100644 (file)
--- a/src/stats/stats-settings.c
+++ b/src/stats/stats-settings.c
@@ -33,7 +33,7 @@ struct service_settings stats_service_settings = {
        .drop_priv_before_exec = FALSE,
 
        .process_limit = 1,
-       .idle_kill = SET_TIME_INFINITE,
+       .idle_kill_interval = SET_TIME_INFINITE,
 
        .unix_listeners = ARRAY_INIT,
        .inet_listeners = ARRAY_INIT,