src/helper/ChildConfig.cc

   1 /*
   2  * Copyright (C) 1996-2015 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 #include "squid.h"
  10 #include "cache_cf.h"
  11 #include "ConfigParser.h"
  12 #include "Debug.h"
  13 #include "globals.h"
  14 #include "helper/ChildConfig.h"
  15 #include "Parsing.h"
  16
  17 #include <cstring>
  18
  19 Helper::ChildConfig::ChildConfig():
  20     n_max(0),
  21     n_startup(0),
  22     n_idle(1),
  23     concurrency(0),
  24     n_running(0),
  25     n_active(0),
  26     queue_size(0),
  27     defaultQueueSize(true)
  28 {}
  29
  30 Helper::ChildConfig::ChildConfig(const unsigned int m):
  31     n_max(m),
  32     n_startup(0),
  33     n_idle(1),
  34     concurrency(0),
  35     n_running(0),
  36     n_active(0),
  37     queue_size(2 * m),
  38     defaultQueueSize(true)
  39 {}
  40
  41 Helper::ChildConfig &
  42 Helper::ChildConfig::updateLimits(const Helper::ChildConfig &rhs)
  43 {
  44     // Copy the limits only.
  45     // Preserve the local state values (n_running and n_active)
  46     n_max = rhs.n_max;
  47     n_startup = rhs.n_startup;
  48     n_idle = rhs.n_idle;
  49     concurrency = rhs.concurrency;
  50     queue_size = rhs.queue_size;
  51     defaultQueueSize = rhs.defaultQueueSize;
  52     return *this;
  53 }
  54
  55 int
  56 Helper::ChildConfig::needNew() const
  57 {
  58     /* during the startup and reconfigure use our special amount... */
  59     if (starting_up || reconfiguring) return n_startup;
  60
  61     /* keep a minimum of n_idle helpers free... */
  62     if ( (n_active + n_idle) < n_max) return n_idle;
  63
  64     /* dont ever start more than n_max processes. */
  65     return (n_max - n_active);
  66 }
  67
  68 void
  69 Helper::ChildConfig::parseConfig()
  70 {
  71     char const *token = ConfigParser::NextToken();
  72
  73     if (!token)
  74         self_destruct();
  75
  76     /* starts with a bare number for the max... back-compatible */
  77     n_max = xatoui(token);
  78
  79     if (n_max < 1) {
  80         debugs(0, DBG_CRITICAL, "ERROR: The maximum number of processes cannot be less than 1.");
  81         self_destruct();
  82     }
  83
  84     /* Parse extension options */
  85     for (; (token = ConfigParser::NextToken()) ;) {
  86         if (strncmp(token, "startup=", 8) == 0) {
  87             n_startup = xatoui(token + 8);
  88         } else if (strncmp(token, "idle=", 5) == 0) {
  89             n_idle = xatoui(token + 5);
  90             if (n_idle < 1) {
  91                 debugs(0, DBG_CRITICAL, "WARNING OVERIDE: Using idle=0 for helpers causes request failures. Overiding to use idle=1 instead.");
  92                 n_idle = 1;
  93             }
  94         } else if (strncmp(token, "concurrency=", 12) == 0) {
  95             concurrency = xatoui(token + 12);
  96         } else if (strncmp(token, "queue-size=", 11) == 0) {
  97             queue_size = xatoui(token + 11);
  98             defaultQueueSize = false;
  99         } else {
 100             debugs(0, DBG_PARSE_NOTE(DBG_IMPORTANT), "ERROR: Undefined option: " << token << ".");
 101             self_destruct();
 102         }
 103     }
 104
 105     /* simple sanity. */
 106
 107     if (n_startup > n_max) {
 108         debugs(0, DBG_CRITICAL, "WARNING OVERIDE: Capping startup=" << n_startup << " to the defined maximum (" << n_max <<")");
 109         n_startup = n_max;
 110     }
 111
 112     if (n_idle > n_max) {
 113         debugs(0, DBG_CRITICAL, "WARNING OVERIDE: Capping idle=" << n_idle << " to the defined maximum (" << n_max <<")");
 114         n_idle = n_max;
 115     }
 116
 117     if (defaultQueueSize)
 118         queue_size = 2 * n_max;
 119 }
 120