Loads the server configuration.

 @raise [UnknownServer]

 @since 0.3.0
341222
def load_server!
      if @server_name
        unless SERVERS.has_key?(@server_name)
          raise(UnknownServer,"Unknown server name #{@server_name}",caller)
        end

        extend SERVERS[@server_name]

        initialize_server if respond_to?(:initialize_server)
      end
    end
48589
def setup
      return Squire::Settings.new unless @source

      parser = Squire::Parser.of(@type)

      hash = parser.parse(source).with_indifferent_access

      if base_namespace
        hash.except(base_namespace).each do |key, values|
          # favours value from namespace over value from defaults
          hash[key] = hash[base_namespace].deep_merge(values) { |_, default, value| value.nil? ? default : value }
        end
      end

      Squire::Settings.from_hash(hash)
    end
711567
def load_json
      json_config_file = Utils.lookup_file @filenames[:json]

      config = Utils.load_json json_config_file
      config.empty? ? @default_config : @default_config.merge(config)
    end
592377
def load_yaml_configuration
      yaml_config = YAML.load_file("#{@rails_root_dir}/config/chronuscop.yml")
      @redis_db_number = yaml_config[@rails_environment]['redis_db_number']
      @redis_server_port = yaml_config[@rails_environment]['redis_server_port']
      @project_number = yaml_config[@rails_environment]['project_number']
      @api_token = yaml_config[@rails_environment]['api_token']
      @chronuscop_server_address = yaml_config[@rails_environment]['chronuscop_server_address']
      @sync_time_interval = yaml_config[@rails_environment]['sync_time_interval']
    end
1059190
def load
      resp = @client.describe_tags(filters: [
        {
          name: "key",
          values: [@key]
        },
        {
          name: "value",
          values: [@value]
        }
      ])
      @data = resp.tags[0]
      self
    end
548795
private Server setUpServer() {
        Server server = new Server(port);
        ResourceHandler handler = new ResourceHandler();
        handler.setDirectoriesListed(true);
        handler.setWelcomeFiles(new String[]{"index.html"});
        handler.setResourceBase(getReportDirectoryPath().toAbsolutePath().toString());
        HandlerList handlers = new HandlerList();
        handlers.setHandlers(new Handler[]{handler, new DefaultHandler()});
        server.setStopAtShutdown(true);
        server.setHandler(handlers);
        return server;
    }
693023
private function Load()
	{
		$sql = "show tables";
		$rs = $this->Server->Connection->Select($sql);
		
		// first pass load all the tables.  this will initialize each object.  we have to
		// do this first so that we can correctly determine and store "Set" information
		while ($row = $this->Server->Connection->Next($rs))
		{
			$this->Tables[$row["Tables_in_" . $this->Name]] = new DBTable($this,$row);
		}
		
		// now load all the keys and constraints for each table
		foreach ($this->Tables as $table)
		{
			$table->LoadKeys();
		}

		$this->Server->Connection->Release($rs);
		
		$sql = "show table status from `" . $this->Name . "`";
		$rs2 = $this->Server->Connection->Select($sql);
		
		// load the extra data
		while ($row = $this->Server->Connection->Next($rs2))
		{
			$this->Tables[$row["Name"]]->Engine = $row["Engine"]; 
			$this->Tables[$row["Name"]]->Comment = $row["Comment"];
		}
		$this->Server->Connection->Release($rs2);
	}
629108
private synchronized void load() {
    Map<String, HadoopServer> map = new TreeMap<String, HadoopServer>();
    for (File file : saveDir.listFiles()) {
      try {
        HadoopServer server = new HadoopServer(file);
        map.put(server.getLocationName(), server);

      } catch (Exception exn) {
        System.err.println(exn);
      }
    }
    this.servers = map;
  }
1340173
def load( &block )
      raise Error, "missing configuration block" unless block

      dsl = TopLevelDSL.new
      dsl.instance_eval(&block)

      pre_config dsl.__pre_config
      ::Logsly::Logging182::Logger[:root]  # ensures the log levels are defined
      appenders  dsl.__appenders
      loggers    dsl.__loggers
    end
555654
def load_backend(**orm_config):
    
    settings = {}
    settings['SECRET_KEY'] = orm_config.get('secret_key', '')

    db_config = orm_config['database']
    if db_config:
        settings['DATABASES'] = {
            'default': database_settings(db_config)
        }

    from django_peeringdb.client_adaptor.setup import configure
    # Override defaults
    configure(**settings)
    # Must import implementation module after configure
    from django_peeringdb.client_adaptor import backend

    migrate = orm_config.get("migrate")
    if migrate and not backend.Backend().is_database_migrated():
        backend.Backend().migrate_database()

    return backend
315249
def __load_configuration(self):
        
        handler_to_enable = filter(lambda h: h.keys is not None, handlers)
        for handler in handler_to_enable:
            if handler.name in self.kwargs:
                for k in handler.keys:
                    self.kwargs.update({k: True})

        self.config = self.configuration_class(self.app.config, **self.kwargs)
1034159
def load_config(file)
      unless File.exists? file
        File.open(file, 'w') do |f| 
          YAML.dump({ default_website: 'default' }, f) 
        end
      end
      YAML.load_file(file)
    end
231708
def load(username)
      options = {}
      options[:basic_auth] = @auth
      response = self.class.get("/user/#{username}", options)
      if response.success?
        self.response = response
        parse_response
        self
      else
        raise response.response
      end
    end
544523
public static ServerParams load(String[] args) throws ConfigurationException {
        if (INSTANCE != null) {
            logger.warn("Configuration is loaded already. Use ServerParams.getInstance() method. ");
            return INSTANCE;
        }

        INSTANCE = new ServerParams();
        INSTANCE.parseConfigFile(getConfigUrl());
        INSTANCE.parseCommandLineArgs(args);
        INSTANCE.parseOverrideFile();
        INSTANCE.printConfig();
        
        // TODO: Delete the next line when ServerConfig is phased out.
        copyParamsToServerConfig();
        return INSTANCE;
    }
306517
def start_server
      @connect_lock.synchronize do
        begin
          raise "Adapter already set" if @adapter
          @adapter = Lock.new(@builder.build.last)
          raise "Server already set" if @server
          @server = Server.new(@adapter, @options)
          @thread = Thread.new { @server.run }
          sleep 0.1 until @server.running?
        rescue => ex
          @adapter.close if @adapter
          @adapter = nil
          @server = nil
          @thread = nil
          warn "Moneta::Shared - Failed to start server: #{ex.message}"
        end
      end
    end
238176
private WebServer loadWebServer() {
        WebServer webServer = null;
        if (!Utils.isEmpty(getParamString("webserver_class"))) {
            try {
                Class<?> serviceClass = Class.forName(getParamString("webserver_class"));
                Method instanceMethod = serviceClass.getMethod("instance", (Class<?>[])null);
                webServer = (WebServer)instanceMethod.invoke(null, (Object[])null);
                webServer.init(RESTServlet.class.getName());
            } catch (Exception e) {
                throw new RuntimeException("Error initializing WebServer: " + getParamString("webserver_class"), e);
            }
        }
        return webServer;
    }
1405
def load_config
      (symbolise = lambda do |h|
        h.is_a?(Hash) ? Hash[h.map { |k, v| [k.intern, symbolise[v]] }] : h
      end)[YAML.load_file CONFIG] if File.readable? CONFIG
    rescue => e
      warn "Failed to load #{ CONFIG }: #{ e }"
    end