docs: def _manage_http_servers(self):
          """
          Compares the running services with the current settings configuration
          and adjusts the running services to match it if different.
  
          The services are identified only by their postion in the server list,
          so a change than only involves a position move will cause a shuffle
          in multiple services.  They don't change often so this isn't much
          of a problem.
  
          The method attempts to create all services.  If any service
          creation fails, the slot is set to None, the error is logged and
          a self._http_retry is set to when another attempt should be made.
          The method should be called whenever self._http_retry has expired.
          The presumption is that the error was transient (already in use, etc)
          and a retry might bring the service up.
      """
          log = self._params.get('log', self._discard)
  
          if not self._config_running:
              raise Exception('Attempt to create HTTP services before config loaded')
          conf = self._config_running
          need = self._get_http_services(conf['settings']['http']
                          if 'settings' in conf and 'http' in conf['settings'] else [])
  
          #  If the service count has changed, close all servers and rebuild from scratch.
          #
          if len(self._http_servers) != len(need):
              log.info("HTTP services count changed from %d to %d, reconfiguring all services",
                          len(self._http_servers), len(need))
              pos = 0
              for server in self._http_servers:
                  if server:
                      if self._pset:
                          try: self._pset.unregister(server)
                          except: pass
                      try: server.close()
                      except: pass
                      log.debug("Slot %d service closed", pos)
                  pos += 1
              self._http_servers = []
  
          self._http_retry = None
          for pos in range(len(need)):
              if len(self._http_servers) > pos:
                  if self._http_servers[pos]:
                      if need[pos].cmp(self._http_servers[pos]._http_service):
                          log.debug("No change in service slot %d: %s", pos, need[pos])
                          continue
                      else:
                          log.debug("Slot %d service changing from %s", pos, self._http_servers[pos]._http_service)
                          if self._pset:
                              try: self._pset.unregister(self._http_servers[pos])
                              except: pass
                          try: self._http_servers[pos].close()
                          except: pass
                          self._http_servers[pos] = None
                  else:
                      log.debug("No existing service in slot %d", pos)
              else:
                  log.debug("Increasing services list for slot %d", pos)
                  self._http_servers.append(None)
  
              #  At this point the service slot exists and is empty.  We'll attempt to fill it.
              try:
                  server = httpd.server(need[pos], log=log)
  
                  #  Add our own attribute to retain the service information
                  #
                  server._http_service = need[pos]
  
                  manage.http(self, server, log=log)
                  status.http(self, server, log=log)
                  if self._pset:
                      self._pset.register(server, poll.POLLIN)
                  self._http_servers[pos] = server
                  log.info("Slot %d service is now %s", pos, server._http_service)
              except Exception as e:
                  log.error("Failed to create server slot %d on %s -- %s", pos, need[pos], e)
                  if not self._http_retry:
                      self._http_retry = time.time() + service_retry_limit