# File lib_ctrl/rucy/control.rb, line 41
    def server_setup(server)
      @lib_loader.load_lib
      if (@doc_factory.has_filter? 'BasicAuth') then
        @doc_factory.set_filter_option('BasicAuth', :pw_enc, @pw_enc)
      end

      server_params = self.server_params
      case (server_params['server_type'])
      when 'multithread'
        @restart_signal = MultiThreadRestartSignal.new
        server.restart_signal = @restart_signal
        server.messenger_factory = MultiThreadMessenger
      when 'multiprocess'
        @restart_signal = MultiProcessRestartSignal.new
        server.restart_signal = @restart_signal
        server.messenger_factory = MultiProcessMessenger
      else
        raise "unknown server type: #{server_params['server_type'].inspect}"
      end
      server.port = server_params['port']
      server.timeout = server_params['timeout']
      server.keep_alive = server_params['keep_alive']
      server.max_requests = server_params['max_requests']
      server.queue_length = server_params['queue_length']
      server.messengers = server_params['messengers']
      server.messenger_threads = server_params['messenger_threads']
      server.messenger_queue_length = server_params['messenger_queue_length']
      server.subprocess_user = server_params['subprocess_user']
      server.subprocess_group = server_params['subprocess_group']

      logging_params = self.logging_params
      unless ($RUCY_DAEMON) then
        stdout_logger = Logger.new(STDOUT)
        stdout_logger.log_emerg = logging_params['stdout_emerg']
        stdout_logger.log_alert = logging_params['stdout_alert']
        stdout_logger.log_crit = logging_params['stdout_crit']
        stdout_logger.log_err = logging_params['stdout_err']
        stdout_logger.log_warning = logging_params['stdout_warning']
        stdout_logger.log_notice = logging_params['stdout_notice']
        stdout_logger.log_info = logging_params['stdout_info']
        stdout_logger.log_debug = logging_params['stdout_debug']
        server.add_logger(stdout_logger)
      end
      for logfile in logging_params['logfiles']
        begin
          output = File.open(logfile['path'], 'a')
          @logfiles_output.push(output)
          file_logger = Logger.new(output)
          file_logger.log_emerg = logfile['log_emerg']
          file_logger.log_alert = logfile['log_alert']
          file_logger.log_crit = logfile['log_crit']
          file_logger.log_err = logfile['log_err']
          file_logger.log_warning = logfile['log_warning']
          file_logger.log_notice = logfile['log_notice']
          file_logger.log_info = logfile['log_info']
          file_logger.log_debug = logfile['log_debug']
          server.add_logger(file_logger)
        rescue StandardError, ScriptError
          @logging_errors.push({ :logfile => logfile['path'],
                                 :exception => $!
                               })
        end
      end

      alias_list = self.aliases
      for alias_info in alias_list
        alias_path = alias_info['alias_path']
        orig_path = alias_info['orig_path']
        host = alias_info['virtual_host']
        begin
          if (host) then
            host += ':' + server_params['port'].to_s
            server.set_virtual_alias(host, alias_path, orig_path)
          else
            server.set_alias(alias_path, orig_path)
          end
        rescue
          @alias_errors.push({ :alias_path => alias_path,
                               :orig_path => orig_path,
                               :virtual_host => host,
                               :exception => $!
                             })
        end
      end

      document_list = self.documents
      for mount_info in document_list
        name = mount_info['document']
        args = mount_info['arguments']
        path = mount_info['mount_path']
        mask = mount_info['mount_mask']
        host = mount_info['virtual_host']
        begin
          document = @doc_factory.doc_build(name, args)
          if (host) then
            host += ':' + server_params['port'].to_s
            server.virtual_mount(host, document, path, mask)
          else
            server.mount(document, path, mask)
          end
        rescue StandardError, ScriptError
          @doc_errors.push({ :document => name,
                             :arguments => args,
                             :mount_path => path,
                             :mount_mask => mask,
                             :virtual_host => host,
                             :exception => $!
                           })
        end
      end

      filter_list = self.filters
      for filter_info in filter_list
        name = filter_info['filter']
        args = filter_info['arguments']
        path = filter_info['attach_path']
        mask = filter_info['attach_mask']
        host = filter_info['virtual_host']
        begin
          filter = @doc_factory.filter_build(name, args)
          if (host) then
            host += ':' + server_params['port'].to_s
            server.virtual_attach(host, filter, path, mask)
          else
            server.attach(filter, path, mask)
          end
        rescue StandardError, ScriptError
          @filter_errors.push({ :filter => name,
                                :arguments => args,
                                :attach_path => path,
                                :attach_mask => mask,
                                :virtual_host => host,
                                :exception => $!
                              })
        end
      end

      admin_params = self.admin_params
      page_maker = WebPageMakerDocument.new(WPM::XMLAssistByREXML, @page_path, 'ControlPanel')
      page_maker.debug = true
      page_maker.set_page_option(:control, self)
      page_maker.set_page_option(:factory, @doc_factory)
      page_maker.set_page_option(:pw_enc, @pw_enc)
      if (admin_params['japanese_handling']) then
        require 'rucy/jconv'
        page_maker.set_input_filter{ |data| Jconv.jconv(data) }
        page_maker.set_output_filter{ |data| Uconv.u8toeuc(data) }
        page_maker.charset = 'euc-jp'
      end
      server.mount(page_maker, '/control')
      if (admin_params['localhost_only']) then
        access = Rucy::RemoteAddressAllowAccessFilter.new
        access.add_allow_address('127.0.0.1')
        server.attach(access, '/control')
      end
      if (admin_params['admin_user'] && ! admin_params['admin_user'].empty? &&
          admin_params['admin_password'] && ! admin_params['admin_password'].empty?)
      then
        passwd = PasswordVerifier.new
        passwd.add_encrypted_user(admin_params['admin_user'], admin_params['admin_password'])
        auth = BasicAuth.new(passwd, "Administrator's password")
        server.attach(auth, '/control')
      end

      server.close_hook{ |s|
        logfiles_close
      }

      nil
    end