std::pair<json_value, json_value>
Database::sanitize_and_get_reserved_words(const json_value &tp)
{
json_value sanitized(submap_d);
json_value special(submap_d);
for(auto i=tp.get_submap().begin(), ie=tp.get_submap().end(); i!=ie; ++i)
{
if (i->first.at(0) == '_')
special[i->first] = i->second;
else
sanitized[i->first] = i->second;
}
return std::make_pair(std::move(sanitized), std::move(special));
}
bool deps_json_t::process_runtime_targets(const json_value& json, const pal::string_t& target_name, const rid_fallback_graph_t& rid_fallback_graph, rid_specific_assets_t* p_assets)
{
rid_specific_assets_t& assets = *p_assets;
for (const auto& package : json.at(_X("targets")).at(target_name).as_object())
{
const auto& targets = package.second.as_object();
auto iter = targets.find(_X("runtimeTargets"));
if (iter == targets.end())
{
continue;
}
const auto& files = iter->second.as_object();
for (const auto& file : files)
{
const auto& type = file.second.at(_X("assetType")).as_string();
for (int i = 0; i < deps_entry_t::s_known_asset_types.size(); ++i)
{
if (pal::strcasecmp(type.c_str(), deps_entry_t::s_known_asset_types[i]) == 0)
{
const auto& rid = file.second.at(_X("rid")).as_string();
assets.libs[package.first].rid_assets[rid].by_type[i].vec.push_back(file.first);
}
}
}
}
if (!perform_rid_fallback(&assets, rid_fallback_graph))
{
return false;
}
return true;
}
bool runtime_config_t::parse_opts(const json_value& opts)
{
if (opts.is_null())
{
return true;
}
const auto& opts_obj = opts.as_object();
auto properties = opts_obj.find(_X("configProperties"));
if (properties != opts_obj.end())
{
const auto& prop_obj = properties->second.as_object();
for (const auto& property : prop_obj)
{
m_properties[property.first] = property.second.is_string()
? property.second.as_string()
: property.second.to_string();
}
}
auto framework = opts_obj.find(_X("framework"));
if (framework == opts_obj.end())
{
return true;
}
m_portable = true;
const auto& fx_obj = framework->second.as_object();
m_fx_name = fx_obj.at(_X("name")).as_string();
m_fx_ver = fx_obj.at(_X("version")).as_string();
auto value = fx_obj.find(_X("rollForward"));
if (value == fx_obj.end())
{
return true;
}
m_fx_roll_fwd = value->second.as_bool();
return true;
}
bool deps_json_t::load_standalone(const json_value& json, const pal::string_t& target_name)
{
if (!process_targets(json, target_name, &m_assets))
{
return false;
}
auto package_exists = [&](const pal::string_t& package) -> bool {
return m_assets.libs.count(package);
};
auto get_relpaths = [&](const pal::string_t& package, int type_index, bool* rid_specific) -> const std::vector<pal::string_t>& {
*rid_specific = false;
return m_assets.libs[package].by_type[type_index].vec;
};
reconcile_libraries_with_targets(json, package_exists, get_relpaths);
const auto& json_object = json.as_object();
const auto iter = json_object.find(_X("runtimes"));
if (iter != json_object.end())
{
for (const auto& rid : iter->second.as_object())
{
auto& vec = m_rid_fallback_graph[rid.first];
for (const auto& fallback : rid.second.as_array())
{
vec.push_back(fallback.as_string());
}
}
}
if (trace::is_enabled())
{
trace::verbose(_X("The rid fallback graph is: {"));
for (const auto& rid : m_rid_fallback_graph)
{
trace::verbose(_X("%s => ["), rid.first.c_str());
for (const auto& fallback : rid.second)
{
trace::verbose(_X("%s, "), fallback.c_str());
}
trace::verbose(_X("]"));
}
trace::verbose(_X("}"));
}
return true;
}
bool deps_json_t::process_targets(const json_value& json, const pal::string_t& target_name, deps_assets_t* p_assets)
{
deps_assets_t& assets = *p_assets;
for (const auto& package : json.at(_X("targets")).at(target_name).as_object())
{
const auto& asset_types = package.second.as_object();
for (int i = 0; i < deps_entry_t::s_known_asset_types.size(); ++i)
{
auto iter = asset_types.find(deps_entry_t::s_known_asset_types[i]);
if (iter != asset_types.end())
{
for (const auto& file : iter->second.as_object())
{
trace::info(_X("Adding %s asset %s from %s"), deps_entry_t::s_known_asset_types[i], file.first.c_str(), package.first.c_str());
assets.libs[package.first].by_type[i].vec.push_back(file.first);
}
}
}
}
return true;
}
void deps_json_t::reconcile_libraries_with_targets(
const json_value& json,
const std::function<bool(const pal::string_t&)>& library_exists_fn,
const std::function<const std::vector<pal::string_t>&(const pal::string_t&, int, bool*)>& get_rel_paths_by_asset_type_fn)
{
const auto& libraries = json.at(_X("libraries")).as_object();
for (const auto& library : libraries)
{
trace::info(_X("Reconciling library %s"), library.first.c_str());
if (pal::to_lower(library.second.at(_X("type")).as_string()) != _X("package"))
{
trace::info(_X("Library %s is not a package"), library.first.c_str());
continue;
}
if (!library_exists_fn(library.first))
{
trace::info(_X("Library %s does not exist"), library.first.c_str());
continue;
}
const auto& properties = library.second.as_object();
const pal::string_t& hash = properties.at(_X("sha512")).as_string();
bool serviceable = properties.at(_X("serviceable")).as_bool();
for (int i = 0; i < deps_entry_t::s_known_asset_types.size(); ++i)
{
bool rid_specific = false;
for (const auto& rel_path : get_rel_paths_by_asset_type_fn(library.first, i, &rid_specific))
{
bool ni_dll = false;
auto asset_name = get_filename_without_ext(rel_path);
if (ends_with(asset_name, _X(".ni"), false))
{
ni_dll = true;
asset_name = strip_file_ext(asset_name);
}
deps_entry_t entry;
size_t pos = library.first.find(_X("/"));
entry.library_name = library.first.substr(0, pos);
entry.library_version = library.first.substr(pos + 1);
entry.library_type = _X("package");
entry.library_hash = hash;
entry.asset_name = asset_name;
entry.asset_type = (deps_entry_t::asset_types) i;
entry.relative_path = rel_path;
entry.is_serviceable = serviceable;
entry.is_rid_specific = rid_specific;
// TODO: Deps file does not follow spec. It uses '\\', should use '/'
replace_char(&entry.relative_path, _X('\\'), _X('/'));
m_deps_entries[i].push_back(entry);
if (ni_dll)
{
m_ni_entries[entry.asset_name] = m_deps_entries
[deps_entry_t::asset_types::runtime].size() - 1;
}
trace::info(_X("Added %s %s deps entry [%d] [%s, %s, %s]"), deps_entry_t::s_known_asset_types[i], entry.asset_name.c_str(), m_deps_entries[i].size() - 1, entry.library_name.c_str(), entry.library_version.c_str(), entry.relative_path.c_str());
}
}
}
}
