C++ ConfigVariable类代码示例

void GameConfig::loadSettings(const INI::Section& section,
        std::vector<ConfigVariable*>& settings)
{
    try {
        std::vector<ConfigVariable*>::iterator i;
        for(i = settings.begin(); i != settings.end(); i++) {
            ConfigVariable* var = *i;

            try {
                ConfigInt* confint = dynamic_cast<ConfigInt*> (var);
                if(confint) {
                    *confint = section.getIntValue(confint->getName());
                    continue;
                }

                ConfigXY* confxy = dynamic_cast<ConfigXY*> (var);
                if(confxy) {
                    confxy->set(section.getIntValue(confxy->getName() + "_x"),
                            section.getIntValue(confxy->getName() + "_y"));
                    continue;
                }

                ConfigBool* confbool = dynamic_cast<ConfigBool*> (var);
                if(confbool) {
                    std::string str =
                        section.getValue(confbool->getName());
                    if(str == "yes" || str == "1" || str == "on")
                        *confbool = true;
                    else if(str == "no" || str == "0" || str == "off")
                        *confbool = false;
                    else
                        throw Exception("No boolean value for setting '%s'.",
                                        confbool->getName().c_str());
                    continue;
                }

                ConfigStringSpecialChars* confstringspecial = dynamic_cast<ConfigStringSpecialChars*> (var);
                if(confstringspecial) {
                    *confstringspecial = section.getValue(confstringspecial->getName());
                    continue;
                }
                
                ConfigString* confstring = dynamic_cast<ConfigString*> (var);
                if(confstring)
                    *confstring = section.getValue(confstring->getName());


                // we have a value from config file in the variable now
                //var->setNonDefaultValue();
                // now each subclass changethis if the value has been changed
            } catch(std::exception& e) {
                LOG(("Skipping config '%s': %s", var->getName().c_str(),
                            e.what()));
            }
        }
    } catch(std::exception& e) {
        LOG(("Couldn't find config section '%s', skipping...",
                    section.getName().c_str()));
    }
}

    SociSQLDatabase(ConfigNode dbeconfig, doid_t min_id, doid_t max_id) :
        OldDatabaseBackend(dbeconfig, min_id, max_id), m_min_id(min_id), m_max_id(max_id),
        m_backend(database_driver.get_rval(dbeconfig)),
        m_db_name(database_name.get_rval(dbeconfig)),
        m_sess_user(database_username.get_rval(dbeconfig)),
        m_sess_passwd(database_password.get_rval(dbeconfig))
    {
        stringstream log_name;
        log_name << "Database-" << m_backend << "(Range: [" << min_id << ", " << max_id << "])";
        m_log = new LogCategory(m_backend, log_name.str());

        string server = database_address.get_rval(dbeconfig);
        int col_index = server.find_last_of(":");
        int sqr_index = server.find_last_of("]");
        if(col_index != string::npos && col_index > sqr_index) {
            m_db_host = server.substr(0, col_index);
            m_db_port = stoi(server.substr(col_index + 1));
        } else {
            m_db_host = server;
        }

        connect();
        check_tables();
        check_classes();
        check_ids();
    }

EventLogger::EventLogger(RoleConfig roleconfig) : Role(roleconfig),
    m_log("eventlogger", "Event Logger"), m_file(nullptr)
{
    bind(bind_addr.get_rval(roleconfig));

    m_file_format = output_format.get_rval(roleconfig);
    open_log();

    LoggedEvent event("log-opened", "EventLogger");
    event.add("msg", "Log opened upon Event Logger startup.");
    process_packet(event.make_datagram(), m_local);
}

DBStateServer::DBStateServer(RoleConfig roleconfig) : StateServer(roleconfig),
    m_db_channel(database_channel.get_rval(m_roleconfig)), m_next_context(0)
{
    ConfigNode ranges = dbss_config.get_child_node(ranges_config, roleconfig);
    for(const auto& it : ranges) {
        channel_t min = range_min.get_rval(it);
        channel_t max = range_max.get_rval(it);
        subscribe_range(min, max);
    }

    std::stringstream name;
    name << "DBSS(Database: " << m_db_channel << ")";
    m_log = std::unique_ptr<LogCategory>(new LogCategory("dbss", name.str()));
    set_con_name(name.str());
}

DBStateServer::DBStateServer(RoleConfig roleconfig) : StateServer(roleconfig),
    m_db_channel(database_channel.get_rval(m_roleconfig)), m_next_context(0)
{
    ConfigNode ranges = dbss_config.get_child_node(ranges_config, roleconfig);
    for(auto it = ranges.begin(); it != ranges.end(); ++it) {
        channel_t min = range_min.get_rval(*it);
        channel_t max = range_max.get_rval(*it);
        MessageDirector::singleton.subscribe_range(this, min, max);
    }

    std::stringstream name;
    name << "DBSS(Database: " << m_db_channel << ")";
    m_log = new LogCategory("dbss", name.str());
    set_con_name(name.str());
}

		SociSQLEngine(DBEngineConfig dbeconfig, uint32_t min_id, uint32_t max_id) :
			IDatabaseEngine(dbeconfig, min_id, max_id), m_min_id(min_id), m_max_id(max_id),
			m_backend(engine_type.get_rval(dbeconfig)),
			m_db_name(database_name.get_rval(dbeconfig)),
			m_sess_user(session_user.get_rval(dbeconfig)),
			m_sess_passwd(session_passwd.get_rval(dbeconfig))
		{
			stringstream log_name;
			log_name << "Database-" << m_backend << "(Range: [" << min_id << ", " << max_id << "])";
			m_log = new LogCategory(m_backend, log_name.str());

			connect();
			check_tables();
			check_classes();
			check_ids();
		}

		DatabaseServer(RoleConfig roleconfig) : Role(roleconfig),
			m_db_engine(DBEngineFactory::singleton.instantiate(
							engine_type.get_rval(roleconfig),
							roleconfig["engine"],
							min_id.get_rval(roleconfig),
							max_id.get_rval(roleconfig))),
			m_control_channel(control_channel.get_rval(roleconfig)),
			m_min_id(min_id.get_rval(roleconfig)),
			m_max_id(max_id.get_rval(roleconfig))
		{
			// Initialize DatabaseServer log
			std::stringstream log_title;
			log_title << "Database(" << m_control_channel << ")";
			m_log = new LogCategory("db", log_title.str());

			// Check to see the engine was instantiated
			if(!m_db_engine)
			{
				m_log->fatal() << "No database engine of type '" << engine_type.get_rval(roleconfig) << "' exists." << std::endl;
				exit(1);
			}

			// Listen on control channel
			subscribe_channel(m_control_channel);
		}

ClientAgent::ClientAgent(RoleConfig roleconfig) : Role(roleconfig), m_net_acceptor(nullptr),
    m_server_version(server_version.get_rval(roleconfig))
{

    stringstream ss;
    ss << "Client Agent (" << bind_addr.get_rval(roleconfig) << ")";
    m_log = std::unique_ptr<LogCategory>(new LogCategory("clientagent", ss.str()));

    // We need to get the client type...
    ConfigNode client = clientagent_config.get_child_node(ca_client_config, roleconfig);
    m_client_type = ca_client_type.get_rval(client);

    // ... and also the channel range ...
    ConfigNode channels = clientagent_config.get_child_node(channels_config, roleconfig);
    m_ct = ChannelTracker(min_channel.get_rval(channels), max_channel.get_rval(channels));

    // ... then store a copy of the client config.
    m_clientconfig = clientagent_config.get_child_node(ca_client_config, roleconfig);

    // Calculate the DC hash
    const uint32_t config_hash = override_hash.get_rval(roleconfig);
    if(config_hash > 0x0) {
        m_hash = config_hash;
    } else {
        m_hash = dclass::legacy_hash(g_dcf);
    }

    // Load tuning parameters.
    ConfigNode tuning = clientagent_config.get_child_node(tuning_config, roleconfig);
    m_interest_timeout = interest_timeout.get_rval(tuning);

    TcpAcceptorCallback callback = std::bind(&ClientAgent::handle_tcp, this,
                                   std::placeholders::_1,
                                   std::placeholders::_2,
                                   std::placeholders::_3,
                                   std::placeholders::_4);
    AcceptorErrorCallback err_callback = std::bind(&ClientAgent::handle_error, this,
                                            std::placeholders::_1);

    m_net_acceptor = std::unique_ptr<TcpAcceptor>(new TcpAcceptor(callback, err_callback));

    m_net_acceptor->set_haproxy_mode(behind_haproxy.get_rval(m_roleconfig));

    // Begin listening for new Clients
    m_net_acceptor->bind(bind_addr.get_rval(m_roleconfig), 7198);
    m_net_acceptor->start();
}

void MessageDirector::init_network()
{
    if(!m_initialized)
    {
        // Bind to port and listen for downstream servers
        if(bind_addr.get_val() != "unspecified")
        {
            m_log.info() << "Opening listening socket..." << std::endl;

            TcpAcceptorCallback callback = std::bind(&MessageDirector::handle_connection,
                                           this, std::placeholders::_1);
            m_net_acceptor = new TcpAcceptor(io_service, callback);
            boost::system::error_code ec;
            ec = m_net_acceptor->bind(bind_addr.get_val(), 7199);
            if(ec.value() != 0)
            {
                m_log.fatal() << "Could not bind listening port: "
                              << bind_addr.get_val() << std::endl;
                m_log.fatal() << "Error code: " << ec.value()
                              << "(" << ec.category().message(ec.value()) << ")"
                              << std::endl;
                exit(1);
            }
            m_net_acceptor->start();
        }

        // Connect to upstream server and start handling received messages
        if(connect_addr.get_val() != "unspecified")
        {
            m_log.info() << "Connecting upstream..." << std::endl;

            MDNetworkUpstream *upstream = new MDNetworkUpstream(this);

            boost::system::error_code ec;
            upstream->connect(connect_addr.get_val());
            if(ec.value() != 0)
            {
                m_log.fatal() << "Could not connect to remote MD at IP: "
                              << connect_addr.get_val() << std::endl;
                m_log.fatal() << "Error code: " << ec.value()
                              << "(" << ec.category().message(ec.value()) << ")"
                              << std::endl;
                exit(1);
            }

            m_upstream = upstream;
        }

        if(threaded_mode.get_val())
        {
            m_thread = new std::thread(std::bind(&MessageDirector::routing_thread, this));
        }

        m_initialized = true;
    }
}

DatabaseServer::DatabaseServer(RoleConfig roleconfig) : Role(roleconfig),
    m_control_channel(control_channel.get_rval(roleconfig)),
    m_min_id(min_id.get_rval(roleconfig)),
    m_max_id(max_id.get_rval(roleconfig)),
    m_broadcast(broadcast_updates.get_rval(roleconfig))
{
    ConfigNode generate = dbserver_config.get_child_node(generate_config, roleconfig);
    ConfigNode backend = dbserver_config.get_child_node(db_backend_config, roleconfig);
    m_db_backend = DBBackendFactory::singleton().instantiate_backend(
                       db_backend_type.get_rval(backend), backend,
                       min_id.get_rval(generate), max_id.get_rval(generate));

    // Initialize DatabaseServer log
    stringstream log_title;
    log_title << "Database(" << m_control_channel << ")";
    m_log = new LogCategory("db", log_title.str());
    set_con_name(log_title.str());

    // Check to see the backend was instantiated
    if(!m_db_backend) {
        m_log->fatal() << "No database backend of type '"
                       << db_backend_type.get_rval(backend) << "' exists." << endl;
        astron_shutdown(1);
    }

    // Listen on control channel
    subscribe_channel(m_control_channel);
    subscribe_channel(BCHAN_DBSERVERS);
}

    MongoDatabase(ConfigNode dbeconfig, doid_t min_id, doid_t max_id) :
            DatabaseBackend(dbeconfig, min_id, max_id),
            m_shutdown(false),
            m_monotonic_exhausted(false)
    {
        stringstream log_name;
        log_name << "Database-MongoDB" << "(Range: [" << min_id << ", " << max_id << "])";
        m_log = new LogCategory("mongodb", log_name.str());

        // Init connection.
        string error;
        m_connection_string = ConnectionString::parse(db_server.get_rval(m_config), error);

        if(!m_connection_string.isValid()) {
            m_log->fatal() << "Could not parse connection string: " << error << endl;
            exit(1);
        }

        // Init the collection/database names:
        m_db = m_connection_string.getDatabase(); // NOTE: If this line won't compile, install mongo-cxx-driver's 'legacy' branch.
        m_obj_collection = m_db + ".astron.objects";
        m_global_collection = m_db + ".astron.globals";

        // Init the globals collection/document:
        DBClientBase *client = new_connection();
        BSONObj query = BSON("_id" << "GLOBALS");
        BSONObj globals = BSON("$setOnInsert" << BSON(
                                   "doid" << BSON(
                                       "monotonic" << min_id <<
                                       "free" << BSONArray())
                               ));
        client->update(m_global_collection, query, globals, true);
        delete client;

        // Spawn worker threads:
        for(int i = 0; i < num_workers.get_rval(m_config); ++i) {
            m_threads.push_back(new thread(bind(&MongoDatabase::run_thread, this)));
        }
    }

StateServer::StateServer(RoleConfig roleconfig) : Role(roleconfig)
{
    channel_t channel = control_channel.get_rval(m_roleconfig);
    if(channel != INVALID_CHANNEL) {
        MessageDirector::singleton.subscribe_channel(this, channel);
        MessageDirector::singleton.subscribe_channel(this, BCHAN_STATESERVERS);

        std::stringstream name;
        name << "StateServer(" << channel << ")";
        m_log = new LogCategory("stateserver", name.str());
        set_con_name(name.str());
    }
}

ClientAgent::ClientAgent(RoleConfig roleconfig) : Role(roleconfig), m_acceptor(NULL),
	m_server_version(server_version.get_rval(roleconfig))
{
	stringstream ss;
	ss << "Client Agent (" << bind_addr.get_rval(roleconfig) << ")";
	m_log = new LogCategory("clientagent", ss.str());

	// We need to get the client type...
	ConfigNode client = clientagent_config.get_child_node(ca_client_config, roleconfig);
	m_client_type = ca_client_type.get_rval(client);

	// ... and also the channel range ...
	ConfigNode channels = clientagent_config.get_child_node(channels_config, roleconfig);
	m_ct = ChannelTracker(min_channel.get_rval(channels), max_channel.get_rval(channels));

	// ... then store a copy of the client config.
	m_clientconfig = clientagent_config.get_child_node(ca_client_config, roleconfig);

	// Calculate the DC hash
	const uint32_t config_hash = override_hash.get_rval(roleconfig);
	if(config_hash > 0x0)
	{
		m_hash = config_hash;
	}
	else
	{
		m_hash = dclass::legacy_hash(g_dcf);
	}

	//Initialize the network
	string str_ip = bind_addr.get_rval(m_roleconfig);
	string str_port = str_ip.substr(str_ip.find(':', 0) + 1, string::npos);
	str_ip = str_ip.substr(0, str_ip.find(':', 0));
	tcp::resolver resolver(io_service);
	tcp::resolver::query query(str_ip, str_port);
	tcp::resolver::iterator it = resolver.resolve(query);
	m_acceptor = new tcp::acceptor(io_service, *it, true);

	start_accept();
}

		YAMLDatabase(ConfigNode dbeconfig, doid_t min_id, doid_t max_id) :
			DatabaseBackend(dbeconfig, min_id, max_id),
			m_next_id(min_id),
			m_free_ids(),
			m_foldername(foldername.get_rval(m_config))
		{
			stringstream log_name;
			log_name << "Database-YAML" << "(Range: [" << min_id << ", " << max_id << "])";
			m_log = new LogCategory("yamldb", log_name.str());

			// Open database info file
			ifstream infostream(m_foldername + "/info.yaml");
			YAML::Node document = YAML::Load(infostream);

			if(document.IsDefined() && !document.IsNull())
			{
				// Read next available id
				YAML::Node key_next = document["next"];
				if(key_next.IsDefined() && !key_next.IsNull())
				{
					m_next_id = document["next"].as<doid_t>();
				}

				// Read available freed ids
				YAML::Node key_free = document["free"];
				if(key_free.IsDefined() && !key_free.IsNull())
				{
					for(doid_t i = 0; i < key_free.size(); i++)
					{
						m_free_ids.push_back(key_free[i].as<doid_t>());
					}
				}
			}

			// Close database info file
			infostream.close();
		}

ClientAgent::ClientAgent(RoleConfig roleconfig) : Role(roleconfig), m_acceptor(NULL),
	m_client_type(client_type.get_rval(roleconfig)),
	m_server_version(server_version.get_rval(roleconfig)),
	m_ct(min_channel.get_rval(roleconfig), max_channel.get_rval(roleconfig))
{
	std::stringstream ss;
	ss << "Client Agent (" << bind_addr.get_rval(roleconfig) << ")";
	m_log = new LogCategory("clientagent", ss.str());

	//Initialize the network
	std::string str_ip = bind_addr.get_rval(m_roleconfig);
	std::string str_port = str_ip.substr(str_ip.find(':', 0) + 1, std::string::npos);
	str_ip = str_ip.substr(0, str_ip.find(':', 0));
	tcp::resolver resolver(io_service);
	tcp::resolver::query query(str_ip, str_port);
	tcp::resolver::iterator it = resolver.resolve(query);
	m_acceptor = new tcp::acceptor(io_service, *it, true);

	if(g_uberdogs.empty())
	{
		YAML::Node udnodes = g_config->copy_node()["uberdogs"];
		if(!udnodes.IsNull())
		{
			for(auto it = udnodes.begin(); it != udnodes.end(); ++it)
			{
				YAML::Node udnode = *it;
				Uberdog ud;
				ud.dcc = g_dcf->get_class_by_name(udnode["class"].as<std::string>());
				if(!ud.dcc)
				{
					m_log->fatal() << "DCClass " << udnode["class"].as<std::string>()
					               << "Does not exist!" << std::endl;
					exit(1);
				}
				ud.anonymous = udnode["anonymous"].as<bool>();
				g_uberdogs[udnode["id"].as<uint32_t>()] = ud;
			}
		}
	}

	start_accept();
}