beast::File Config::getModuleDatabasePath () const { boost::filesystem::path dbPath (legacy ("database_path")); beast::String const s (dbPath.native ().c_str ()); if (s.isNotEmpty ()) return beast::File (s); return beast::File::nonexistent (); }
QWidget* SkinLoader::loadDefaultSkin(QWidget* pParent, MixxxKeyboard* pKeyboard, PlayerManager* pPlayerManager, ControllerManager* pControllerManager, Library* pLibrary, VinylControlManager* pVCMan) { QString skinPath = getConfiguredSkinPath(); LegacySkinParser legacy(m_pConfig, pKeyboard, pPlayerManager, pControllerManager, pLibrary, pVCMan); return legacy.parseSkin(skinPath, pParent); }
QWidget* SkinLoader::loadDefaultSkin(QWidget* pParent, MixxxKeyboard* pKeyboard, PlayerManager* pPlayerManager, ControllerManager* pControllerManager, Library* pLibrary, VinylControlManager* pVCMan, EffectsManager* pEffectsManager) { QString skinPath = getSkinPath(); // If we don't have a skin path then fail. if (skinPath.isEmpty()) { return NULL; } LegacySkinParser legacy(m_pConfig, pKeyboard, pPlayerManager, pControllerManager, pLibrary, pVCMan, pEffectsManager); return legacy.parseSkin(skinPath, pParent); }
void StunMessageTestSuite::testLegacyMode() { StunMessage legacy(NULL, true) ; StunMessage nonLegacy(NULL, false) ; StunMessage responseWithLegacy(&legacy, false) ; StunMessage responseWithNonLegacy(&nonLegacy, true) ; STUN_MAGIC_ID magicId ; legacy.getMagicId(&magicId) ; CPPUNIT_ASSERT(magicId.id != STUN_MAGIC_COOKIE) ; nonLegacy.getMagicId(&magicId) ; CPPUNIT_ASSERT(magicId.id == STUN_MAGIC_COOKIE) ; responseWithLegacy.getMagicId(&magicId) ; CPPUNIT_ASSERT(magicId.id != STUN_MAGIC_COOKIE) ; responseWithNonLegacy.getMagicId(&magicId) ; CPPUNIT_ASSERT(magicId.id == STUN_MAGIC_COOKIE) ; }
std::vector<LLMute> LLMuteList::getMutes() const { std::vector<LLMute> mutes; for (mute_set_t::const_iterator it = mMutes.begin(); it != mMutes.end(); ++it) { mutes.push_back(*it); } for (string_set_t::const_iterator it = mLegacyMutes.begin(); it != mLegacyMutes.end(); ++it) { LLMute legacy(LLUUID::null, *it); mutes.push_back(legacy); } std::sort(mutes.begin(), mutes.end(), compare_by_name()); return mutes; }
void IndicationHandlerService::_handle_async_request(AsyncRequest *req) { if ( req->getType() == async_messages::CIMSERVICE_STOP ) { req->op->processing(); handle_CimServiceStop(static_cast<CimServiceStop *>(req)); } else if ( req->getType() == async_messages::ASYNC_LEGACY_OP_START ) { req->op->processing(); AutoPtr<Message> legacy(static_cast<AsyncLegacyOperationStart *>(req)->get_action()); //PEP 101 if (legacy->getType() == CIM_HANDLE_INDICATION_REQUEST_MESSAGE) { AutoPtr<Message> legacy_response(_handleIndication( (CIMHandleIndicationRequestMessage*) legacy.get())); //PEP 101 legacy.release(); AutoPtr<AsyncLegacyOperationResult> async_result(new AsyncLegacyOperationResult( req->getKey(), req->getRouting(), req->op, legacy_response.get())); //PEP 101 legacy_response.release(); async_result.release(); _complete_op_node(req->op, ASYNC_OPSTATE_COMPLETE, 0, 0); } else { Tracer::trace(TRC_DISCARDED_DATA, Tracer::LEVEL2, "IndicationHandlerService::_handle_async_request got " "unexpected legacy message type '%u'", legacy->getType()); _make_response(req, async_results::CIM_NAK); } } else { Base::_handle_async_request(req); } }
void IndicationHandlerService::_handle_async_request(AsyncRequest* req) { if (req->getType() == ASYNC_CIMSERVICE_STOP) { handle_CimServiceStop(static_cast<CimServiceStop *>(req)); } else if (req->getType() == ASYNC_ASYNC_LEGACY_OP_START) { AutoPtr<Message> legacy( static_cast<AsyncLegacyOperationStart *>(req)->get_action()); if (legacy->getType() == CIM_HANDLE_INDICATION_REQUEST_MESSAGE) { AutoPtr<Message> legacy_response(_handleIndication( (CIMHandleIndicationRequestMessage*) legacy.get())); legacy.release(); AutoPtr<AsyncLegacyOperationResult> async_result( new AsyncLegacyOperationResult( req->op, legacy_response.get())); legacy_response.release(); async_result.release(); _complete_op_node(req->op); } else { PEG_TRACE((TRC_DISCARDED_DATA, Tracer::LEVEL2, "IndicationHandlerService::_handle_async_request got " "unexpected legacy message type '%u'", legacy->getType())); _make_response(req, async_results::CIM_NAK); } } else { Base::_handle_async_request(req); } }
void Config::loadFromString (std::string const& fileContents) { IniFileSections secConfig = parseIniFile (fileContents, true); build (secConfig); if (auto s = getIniFileSection (secConfig, SECTION_VALIDATORS)) validators = *s; if (auto s = getIniFileSection (secConfig, SECTION_CLUSTER_NODES)) CLUSTER_NODES = *s; if (auto s = getIniFileSection (secConfig, SECTION_IPS)) IPS = *s; if (auto s = getIniFileSection (secConfig, SECTION_IPS_FIXED)) IPS_FIXED = *s; if (auto s = getIniFileSection (secConfig, SECTION_SNTP)) SNTP_SERVERS = *s; if (auto s = getIniFileSection (secConfig, SECTION_RPC_STARTUP)) { RPC_STARTUP = Json::arrayValue; for (auto const& strJson : *s) { Json::Reader jrReader; Json::Value jvCommand; if (!jrReader.parse (strJson, jvCommand)) throw std::runtime_error ( boost::str (boost::format ( "Couldn't parse [" SECTION_RPC_STARTUP "] command: %s") % strJson)); RPC_STARTUP.append (jvCommand); } } { std::string dbPath; if (getSingleSection (secConfig, "database_path", dbPath)) { boost::filesystem::path p(dbPath); legacy("database_path", boost::filesystem::absolute (p).string ()); } } (void) getSingleSection (secConfig, SECTION_VALIDATORS_SITE, VALIDATORS_SITE); std::string strTemp; if (getSingleSection (secConfig, SECTION_PEER_PRIVATE, strTemp)) PEER_PRIVATE = beast::lexicalCastThrow <bool> (strTemp); if (getSingleSection (secConfig, SECTION_PEERS_MAX, strTemp)) PEERS_MAX = beast::lexicalCastThrow <int> (strTemp); if (getSingleSection (secConfig, SECTION_NODE_SIZE, strTemp)) { if (strTemp == "tiny") NODE_SIZE = 0; else if (strTemp == "small") NODE_SIZE = 1; else if (strTemp == "medium") NODE_SIZE = 2; else if (strTemp == "large") NODE_SIZE = 3; else if (strTemp == "huge") NODE_SIZE = 4; else { NODE_SIZE = beast::lexicalCastThrow <int> (strTemp); if (NODE_SIZE < 0) NODE_SIZE = 0; else if (NODE_SIZE > 4) NODE_SIZE = 4; } } if (getSingleSection (secConfig, SECTION_ELB_SUPPORT, strTemp)) ELB_SUPPORT = beast::lexicalCastThrow <bool> (strTemp); if (getSingleSection (secConfig, SECTION_WEBSOCKET_PING_FREQ, strTemp)) WEBSOCKET_PING_FREQ = beast::lexicalCastThrow <int> (strTemp); getSingleSection (secConfig, SECTION_SSL_VERIFY_FILE, SSL_VERIFY_FILE); getSingleSection (secConfig, SECTION_SSL_VERIFY_DIR, SSL_VERIFY_DIR); if (getSingleSection (secConfig, SECTION_SSL_VERIFY, strTemp)) SSL_VERIFY = beast::lexicalCastThrow <bool> (strTemp); if (getSingleSection (secConfig, SECTION_VALIDATION_SEED, strTemp)) { VALIDATION_SEED.setSeedGeneric (strTemp); if (VALIDATION_SEED.isValid ()) { VALIDATION_PUB = DivvyAddress::createNodePublic (VALIDATION_SEED); VALIDATION_PRIV = DivvyAddress::createNodePrivate (VALIDATION_SEED); } } if (getSingleSection (secConfig, SECTION_NODE_SEED, strTemp)) { NODE_SEED.setSeedGeneric (strTemp); if (NODE_SEED.isValid ()) { NODE_PUB = DivvyAddress::createNodePublic (NODE_SEED); NODE_PRIV = DivvyAddress::createNodePrivate (NODE_SEED); } } if (getSingleSection (secConfig, SECTION_NETWORK_QUORUM, strTemp)) NETWORK_QUORUM = beast::lexicalCastThrow <std::size_t> (strTemp); if (getSingleSection (secConfig, SECTION_VALIDATION_QUORUM, strTemp)) VALIDATION_QUORUM = std::max (0, beast::lexicalCastThrow <int> (strTemp)); if (getSingleSection (secConfig, SECTION_FEE_ACCOUNT_RESERVE, strTemp)) FEE_ACCOUNT_RESERVE = beast::lexicalCastThrow <std::uint64_t> (strTemp); if (getSingleSection (secConfig, SECTION_FEE_OWNER_RESERVE, strTemp)) FEE_OWNER_RESERVE = beast::lexicalCastThrow <std::uint64_t> (strTemp); if (getSingleSection (secConfig, SECTION_FEE_OFFER, strTemp)) FEE_OFFER = beast::lexicalCastThrow <int> (strTemp); if (getSingleSection (secConfig, SECTION_FEE_DEFAULT, strTemp)) FEE_DEFAULT = beast::lexicalCastThrow <int> (strTemp); if (getSingleSection (secConfig, SECTION_FEE_OPERATION, strTemp)) FEE_CONTRACT_OPERATION = beast::lexicalCastThrow <int> (strTemp); if (getSingleSection (secConfig, SECTION_LEDGER_HISTORY, strTemp)) { boost::to_lower (strTemp); if (strTemp == "full") LEDGER_HISTORY = 1000000000u; else if (strTemp == "none") LEDGER_HISTORY = 0; else LEDGER_HISTORY = beast::lexicalCastThrow <std::uint32_t> (strTemp); } if (getSingleSection (secConfig, SECTION_FETCH_DEPTH, strTemp)) { boost::to_lower (strTemp); if (strTemp == "none") FETCH_DEPTH = 0; else if (strTemp == "full") FETCH_DEPTH = 1000000000u; else FETCH_DEPTH = beast::lexicalCastThrow <std::uint32_t> (strTemp); if (FETCH_DEPTH < 10) FETCH_DEPTH = 10; } if (getSingleSection (secConfig, SECTION_PATH_SEARCH_OLD, strTemp)) PATH_SEARCH_OLD = beast::lexicalCastThrow <int> (strTemp); if (getSingleSection (secConfig, SECTION_PATH_SEARCH, strTemp)) PATH_SEARCH = beast::lexicalCastThrow <int> (strTemp); if (getSingleSection (secConfig, SECTION_PATH_SEARCH_FAST, strTemp)) PATH_SEARCH_FAST = beast::lexicalCastThrow <int> (strTemp); if (getSingleSection (secConfig, SECTION_PATH_SEARCH_MAX, strTemp)) PATH_SEARCH_MAX = beast::lexicalCastThrow <int> (strTemp); if (getSingleSection (secConfig, SECTION_ACCOUNT_PROBE_MAX, strTemp)) ACCOUNT_PROBE_MAX = beast::lexicalCastThrow <int> (strTemp); if (getSingleSection (secConfig, SECTION_VALIDATORS_FILE, strTemp)) { VALIDATORS_FILE = strTemp; } if (getSingleSection (secConfig, SECTION_DEBUG_LOGFILE, strTemp)) DEBUG_LOGFILE = strTemp; }
void Config::setup (std::string const& strConf, bool bQuiet) { boost::filesystem::path dataDir; boost::system::error_code ec; std::string strDbPath, strConfFile; // // Determine the config and data directories. // If the config file is found in the current working directory, use the current working directory as the config directory and // that with "db" as the data directory. // QUIET = bQuiet; NODE_SIZE = 0; strDbPath = Helpers::getDatabaseDirName (); strConfFile = strConf.empty () ? Helpers::getConfigFileName () : strConf; VALIDATORS_BASE = Helpers::getValidatorsFileName (); VALIDATORS_URI = boost::str (boost::format ("/%s") % VALIDATORS_BASE); if (!strConf.empty ()) { // --conf=<path> : everything is relative that file. CONFIG_FILE = strConfFile; CONFIG_DIR = boost::filesystem::absolute (CONFIG_FILE); CONFIG_DIR.remove_filename (); dataDir = CONFIG_DIR / strDbPath; } else { CONFIG_DIR = boost::filesystem::current_path (); CONFIG_FILE = CONFIG_DIR / strConfFile; dataDir = CONFIG_DIR / strDbPath; // Construct XDG config and data home. // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html std::string strHome = getEnvVar ("HOME"); std::string strXdgConfigHome = getEnvVar ("XDG_CONFIG_HOME"); std::string strXdgDataHome = getEnvVar ("XDG_DATA_HOME"); if (boost::filesystem::exists (CONFIG_FILE) // Can we figure out XDG dirs? || (strHome.empty () && (strXdgConfigHome.empty () || strXdgDataHome.empty ()))) { // Current working directory is fine, put dbs in a subdir. } else { if (strXdgConfigHome.empty ()) { // $XDG_CONFIG_HOME was not set, use default based on $HOME. strXdgConfigHome = strHome + "/.config"; } if (strXdgDataHome.empty ()) { // $XDG_DATA_HOME was not set, use default based on $HOME. strXdgDataHome = strHome + "/.local/share"; } CONFIG_DIR = strXdgConfigHome + "/" + systemName (); CONFIG_FILE = CONFIG_DIR / strConfFile; dataDir = strXdgDataHome + "/" + systemName (); boost::filesystem::create_directories (CONFIG_DIR, ec); if (ec) throw std::runtime_error (boost::str (boost::format ("Can not create %s") % CONFIG_DIR)); } } HTTPClient::initializeSSLContext(); // Update default values load (); { // load() may have set a new value for the dataDir std::string const dbPath (legacy ("database_path")); if (!dbPath.empty ()) { dataDir = boost::filesystem::path (dbPath); } } boost::filesystem::create_directories (dataDir, ec); if (ec) throw std::runtime_error ( boost::str (boost::format ("Can not create %s") % dataDir)); legacy ("database_path", boost::filesystem::absolute (dataDir).string ()); }