TEST_F(PacksTests, test_check_platform) { auto fpack = Pack("foobar", getPackWithDiscovery()); if (kSDKPlatform == "darwin") { EXPECT_TRUE(fpack.checkPlatform()); } else { EXPECT_FALSE(fpack.checkPlatform()); } }
TEST_F(PacksTests, test_check_platform) { auto fpack = Pack("discovery_pack", getPackWithDiscovery()); // Depending on the current build platform, this check will be true or false. if (kSDKPlatform == "darwin") { EXPECT_TRUE(fpack.checkPlatform()); } else { EXPECT_FALSE(fpack.checkPlatform()); } }
//------------------------------------------------------------------------------------------------------- int main (int argc, char* argv[]) { if (!checkPlatform ()) { printf ("Platform verification failed! Please check your Compiler Settings!\n"); return -1; } const char* fileName = "again.dll"; //const char* fileName = "adelay.dll"; //const char* fileName = "surrounddelay.dll"; //const char* fileName = "vstxsynth.dll"; //const char* fileName = "drawtest.dll"; if (argc > 1) fileName = argv[1]; printf ("HOST> Load library...\n"); PluginLoader loader; if (!loader.loadLibrary (fileName)) { printf ("Failed to load VST Plugin library!\n"); return -1; } PluginEntryProc mainEntry = loader.getMainEntry (); if (!mainEntry) { printf ("VST Plugin main entry not found!\n"); return -1; } printf ("HOST> Create effect...\n"); AEffect* effect = mainEntry (HostCallback); if (!effect) { printf ("Failed to create effect instance!\n"); return -1; } printf ("HOST> Init sequence...\n"); effect->dispatcher (effect, effOpen, 0, 0, 0, 0); effect->dispatcher (effect, effSetSampleRate, 0, 0, 0, kSampleRate); effect->dispatcher (effect, effSetBlockSize, 0, kBlockSize, 0, 0); checkEffectProperties (effect); checkEffectProcessing (effect); checkEffectEditor (effect); printf ("HOST> Close effect...\n"); effect->dispatcher (effect, effClose, 0, 0, 0, 0); return 0; }
void Pack::initialize(const std::string& name, const std::string& source, const pt::ptree& tree) { name_ = name; source_ = source; discovery_queries_.clear(); if (tree.count("discovery") > 0) { for (const auto& item : tree.get_child("discovery")) { discovery_queries_.push_back(item.second.get_value<std::string>()); } } discovery_cache_ = std::make_pair<int, bool>(0, false); stats_ = {0, 0, 0}; platform_.clear(); if (tree.count("platform") > 0) { platform_ = tree.get<std::string>("platform"); } version_.clear(); if (tree.count("version") > 0) { version_ = tree.get<std::string>("version"); } schedule_.clear(); if (tree.count("queries") > 0) { for (const auto& q : tree.get_child("queries")) { if (q.second.count("platform")) { if (!checkPlatform(q.second.get<std::string>("platform"))) { continue; } } if (q.second.count("version")) { if (!checkVersion(q.second.get<std::string>("version"))) { continue; } } ScheduledQuery query; query.interval = q.second.get<int>("interval", FLAGS_schedule_default_interval); query.splayed_interval = splayValue(query.interval, FLAGS_schedule_splay_percent); query.query = q.second.get<std::string>("query"); query.options["snapshot"] = q.second.get<bool>("snapshot", false); query.options["removed"] = q.second.get<bool>("removed", true); schedule_[q.first] = query; } } }
int main(int argc, char** argv, char** envp) { if (argc == 1) { std::cerr << "This is Darling dyld for " ARCH_NAME ".\n"; std::cerr << "Copyright (C) 2012-2013 Lubos Dolezel\n" "Copyright (C) 2011 Shinichiro Hamaji\n\n"; std::cerr << "Usage: " << argv[0] << " program-path [arguments...]\n\n"; std::cerr << "Environment variables:\n" "\tDYLD_DEBUG=1 - enable debug info (lots of output)\n" "\tDYLD_MTRACE=1 - enable mtrace\n" #ifdef DEBUG "\tDYLD_IGN_MISSING_SYMS=1 - replace missing symbol references with a stub function\n" "\tDYLD_TRAMPOLINE=1 - access all bound functions via a debug trampoline\n" #endif "\tDYLD_ROOT_PATH=<path> - set the base for library path resolution (overrides autodetection)\n" "\tDYLD_BIND_AT_LAUNCH=1 - force dyld to bind all lazy references on startup\n"; return 1; } try { if (!::realpath(argv[0], g_dyld_path)) ::strcpy(g_dyld_path, argv[0]); if (argc == 2) { if (!strcmp(argv[1], "--register")) { Darling::binfmtRegister(g_dyld_path); return 0; } else if (!strcmp(argv[1], "--deregister")) { Darling::binfmtDeregister(); return 0; } } setupDyldPath(argv[0]); // sets up @executable_path setupExecutablePath(argv[1]); // setlocale(LC_CTYPE, ""); if (getenv("DYLD_MTRACE") && atoi(getenv("DYLD_MTRACE"))) mtrace(); if (getenv("DYLD_TRAMPOLINE") && atoi(getenv("DYLD_TRAMPOLINE"))) g_trampoline = true; if (getenv("DYLD_NO_WEAK")) g_noWeak = true; g_mainBinary = MachO::readFile(argv[1], ARCH_NAME); if (!g_mainBinary) throw std::runtime_error("Cannot open binary file"); checkPlatform(argv[1], g_mainBinary); // Modify the argument list so that the dyld name disappears from the process list. // The Linux kernel doesn't really support this - it remembers the byte length of the cmdline, which will now decrease. // Any app that examines this process' /proc/.../cmdline will from now on see a group of empty arguments after the real arguments. // We fix this for NSProcessInfo in libobjcdarwin. /* uintptr_t totalLen = argv[argc-1] + strlen(argv[argc-1]) + 1 - argv[0]; uintptr_t shortenedLen = totalLen - (strlen(argv[0]) + 1); memmove(argv[0], argv[1], shortenedLen); memset(argv[0]+shortenedLen, 0, totalLen - shortenedLen); // Reconstruct the argv array for (int pos = 0, index = 1; index < argc-1; pos++) { if (!argv[0][pos]) argv[index++] = &argv[0][pos+1]; } */ g_argv = argv+1; g_argc = argc-1; g_loader = new MachOLoader; autoSysrootSearch(); bool forceBind = false; if (g_trampoline || getenv("DYLD_BIND_AT_LAUNCH") != nullptr) forceBind = true; g_loader->run(*g_mainBinary, g_argc, g_argv, envp, forceBind); delete g_loader; g_loader = 0; return 2; } catch (fat_architecture_not_supported& e) { if (char* p = strstr(argv[0], "/" DYLD_FULL_NAME)) // multilib { // Try to automatically execute "the other" dyld on multilib systems // if that other dyld's platform is supported in the fat binary if (std::find(e.archs().begin(), e.archs().end(), ARCH_CROSS_NAME) != e.archs().end()) { strcpy(p+1, DYLD_CROSS_NAME); execvp(argv[0], argv); } } std::cerr << argv[1] << " is a fat binary, but doesn't support the following architecture: " << ARCH_NAME << std::endl; } catch (std::exception& e) { std::cerr << e.what() << std::endl; return 1; } }
Status ATCConfigParserPlugin::update(const std::string& source, const ParserConfig& config) { auto cv = config.find(kParserKey); if (cv == config.end()) { return Status(1, "No configuration for ATC (Auto Table Construction)"); } auto obj = data_.getObject(); data_.copyFrom(cv->second.doc(), obj); data_.add(kParserKey, obj); const auto& ac_tables = data_.doc()[kParserKey]; auto tables = RegistryFactory::get().registry("table"); auto registered = registeredATCTables(); for (const auto& ac_table : ac_tables.GetObject()) { std::string table_name{ac_table.name.GetString()}; auto params = ac_table.value.GetObject(); std::string query{params.HasMember("query") && params["query"].IsString() ? params["query"].GetString() : ""}; std::string path{params.HasMember("path") && params["path"].IsString() ? params["path"].GetString() : ""}; std::string platform{params.HasMember("platform") && params["platform"].IsString() ? params["platform"].GetString() : ""}; if (query.empty() || path.empty()) { LOG(WARNING) << "ATC Table: " << table_name << " is misconfigured"; continue; } if (!checkPlatform(platform)) { VLOG(1) << "Skipping ATC table: " << table_name << " because platform doesn't match"; continue; } TableColumns columns; std::string columns_value; columns_value.reserve(256); for (const auto& column : params["columns"].GetArray()) { columns.push_back(make_tuple( std::string(column.GetString()), TEXT_TYPE, ColumnOptions::DEFAULT)); columns_value += std::string(column.GetString()) + ","; } registered.erase(table_name); std::string table_settings{table_name + query + columns_value + path}; std::string old_setting; auto s = getDatabaseValue( kPersistentSettings, kDatabaseKeyPrefix + table_name, old_setting); // The ATC table hasn't changed so we skip ahead if (table_settings == old_setting) { continue; } // Remove the old table to replace with the new one s = removeATCTables({table_name}); if (!s.ok()) { LOG(WARNING) << "ATC table overrides core table; Refusing registration"; continue; } s = setDatabaseValue( kPersistentSettings, kDatabaseKeyPrefix + table_name, table_settings); if (!s.ok()) { LOG(WARNING) << "Could not write to database"; continue; } s = tables->add( table_name, std::make_shared<ATCPlugin>(path, columns, query), true); if (!s.ok()) { LOG(WARNING) << s.getMessage(); deleteDatabaseValue(kPersistentSettings, kDatabaseKeyPrefix + table_name); continue; } PluginResponse resp; Registry::call( "sql", "sql", {{"action", "attach"}, {"table", table_name}}, resp); LOG(INFO) << "Registered ATC table: " << table_name; } if (registered.size() > 0) { VLOG(1) << "Removing any ATC tables that were removed in this configuration " "change"; removeATCTables(registered); } return Status(); }
void Pack::initialize(const std::string& name, const std::string& source, const pt::ptree& tree) { name_ = name; source_ = source; discovery_queries_.clear(); if (tree.count("discovery") > 0) { for (const auto& item : tree.get_child("discovery")) { discovery_queries_.push_back(item.second.get_value<std::string>()); } } discovery_cache_ = std::make_pair<int, bool>(0, false); stats_ = {0, 0, 0}; platform_.clear(); if (tree.count("platform") > 0) { platform_ = tree.get<std::string>("platform", ""); } version_.clear(); if (tree.count("version") > 0) { version_ = tree.get<std::string>("version", ""); } schedule_.clear(); if (tree.count("queries") == 0) { // This pack contained no queries. return; } // If the splay percent is less than 1 reset to a sane estimate. if (FLAGS_schedule_splay_percent <= 1) { FLAGS_schedule_splay_percent = 10; } // Iterate the queries (or schedule) and check platform/version/sanity. for (const auto& q : tree.get_child("queries")) { if (q.second.count("platform")) { if (!checkPlatform(q.second.get<std::string>("platform", ""))) { continue; } } if (q.second.count("version")) { if (!checkVersion(q.second.get<std::string>("version", ""))) { continue; } } ScheduledQuery query; query.query = q.second.get<std::string>("query", ""); query.interval = q.second.get("interval", FLAGS_schedule_default_interval); if (query.interval <= 0 || query.query.empty()) { // Invalid pack query. continue; } query.splayed_interval = restoreSplayedValue(q.first, query.interval); query.options["snapshot"] = q.second.get<bool>("snapshot", false); query.options["removed"] = q.second.get<bool>("removed", true); schedule_[q.first] = query; } }
bool Pack::checkPlatform() const { return checkPlatform(platform_); }
bool Pack::shouldPackExecute() { return checkVersion() && checkPlatform() && checkDiscovery(); }
void Pack::initialize(const std::string& name, const std::string& source, const pt::ptree& tree) { name_ = name; source_ = source; // Check the shard limitation, shards falling below this value are included. if (tree.count("shard") > 0) { shard_ = tree.get<size_t>("shard", 0); } // Check for a platform restriction. platform_.clear(); if (tree.count("platform") > 0) { platform_ = tree.get<std::string>("platform", ""); } // Check for a version restriction. version_.clear(); if (tree.count("version") > 0) { version_ = tree.get<std::string>("version", ""); } // Apply the shard, platform, and version checking. // It is important to set each value such that the packs meta-table can report // each of the restrictions. if ((shard_ > 0 && shard_ < getMachineShard()) || !checkPlatform() || !checkVersion()) { return; } discovery_queries_.clear(); if (tree.count("discovery") > 0) { for (const auto& item : tree.get_child("discovery")) { discovery_queries_.push_back(item.second.get_value<std::string>()); } } // Initialize a discovery cache at time 0. discovery_cache_ = std::make_pair<size_t, bool>(0, false); valid_ = true; // If the splay percent is less than 1 reset to a sane estimate. if (FLAGS_schedule_splay_percent <= 1) { FLAGS_schedule_splay_percent = 10; } schedule_.clear(); if (tree.count("queries") == 0) { // This pack contained no queries. return; } // Iterate the queries (or schedule) and check platform/version/sanity. for (const auto& q : tree.get_child("queries")) { if (q.second.count("shard") > 0) { auto shard = q.second.get<size_t>("shard", 0); if (shard > 0 && shard < getMachineShard()) { continue; } } if (q.second.count("platform")) { if (!checkPlatform(q.second.get<std::string>("platform", ""))) { continue; } } if (q.second.count("version")) { if (!checkVersion(q.second.get<std::string>("version", ""))) { continue; } } ScheduledQuery query; query.query = q.second.get<std::string>("query", ""); query.interval = q.second.get("interval", FLAGS_schedule_default_interval); if (query.interval <= 0 || query.query.empty() || query.interval > 592200) { // Invalid pack query. VLOG(1) << "Query has invalid interval: " << q.first << ": " << query.interval; continue; } query.splayed_interval = restoreSplayedValue(q.first, query.interval); query.options["snapshot"] = q.second.get<bool>("snapshot", false); query.options["removed"] = q.second.get<bool>("removed", true); schedule_[q.first] = query; } }
void Pack::initialize(const std::string& name, const std::string& source, const rj::Value& obj) { name_ = name; source_ = source; // Check the shard limitation, shards falling below this value are included. if (obj.HasMember("shard")) { shard_ = JSON::valueToSize(obj["shard"]); } // Check for a platform restriction. platform_.clear(); if (obj.HasMember("platform") && obj["platform"].IsString()) { platform_ = obj["platform"].GetString(); } // Check for a version restriction. version_.clear(); if (obj.HasMember("version") && obj["version"].IsString()) { version_ = obj["version"].GetString(); } // Apply the shard, platform, and version checking. // It is important to set each value such that the packs meta-table can report // each of the restrictions. if ((shard_ > 0 && shard_ < getMachineShard()) || !checkPlatform() || !checkVersion()) { return; } discovery_queries_.clear(); if (obj.HasMember("discovery") && obj["discovery"].IsArray()) { for (const auto& item : obj["discovery"].GetArray()) { discovery_queries_.push_back(item.GetString()); } } // Initialize a discovery cache at time 0. discovery_cache_ = std::make_pair<size_t, bool>(0, false); valid_ = true; // If the splay percent is less than 1 reset to a sane estimate. if (FLAGS_schedule_splay_percent <= 1) { FLAGS_schedule_splay_percent = 10; } schedule_.clear(); if (!obj.HasMember("queries") || !obj["queries"].IsObject()) { // This pack contained no queries. return; } // Iterate the queries (or schedule) and check platform/version/sanity. for (const auto& q : obj["queries"].GetObject()) { if (q.value.HasMember("shard")) { auto shard = JSON::valueToSize(q.value["shard"]); if (shard > 0 && shard < getMachineShard()) { continue; } } if (q.value.HasMember("platform") && q.value["platform"].IsString()) { if (!checkPlatform(q.value["platform"].GetString())) { continue; } } if (q.value.HasMember("version") && q.value["version"].IsString()) { if (!checkVersion(q.value["version"].GetString())) { continue; } } if (!q.value.HasMember("query") || !q.value["query"].IsString()) { continue; } ScheduledQuery query; query.query = q.value["query"].GetString(); if (!q.value.HasMember("interval")) { query.interval = FLAGS_schedule_default_interval; } else { query.interval = JSON::valueToSize(q.value["interval"]); } if (query.interval <= 0 || query.query.empty() || query.interval > kMaxQueryInterval) { // Invalid pack query. LOG(WARNING) << "Query has invalid interval: " << q.name.GetString() << ": " << query.interval; continue; } query.splayed_interval = restoreSplayedValue(q.name.GetString(), query.interval); if (!q.value.HasMember("snapshot")) { query.options["snapshot"] = false; } else { query.options["snapshot"] = JSON::valueToBool(q.value["snapshot"]); } if (!q.value.HasMember("removed")) { query.options["removed"] = true; } else { query.options["removed"] = JSON::valueToBool(q.value["removed"]); } query.options["blacklist"] = (q.value.HasMember("blacklist")) ? q.value["blacklist"].GetBool() : true; schedule_.emplace(std::make_pair(q.name.GetString(), std::move(query))); } }