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(); }