diff options
Diffstat (limited to 'libbuild2/install/operation.cxx')
| -rw-r--r-- | libbuild2/install/operation.cxx | 324 |
1 files changed, 297 insertions, 27 deletions
diff --git a/libbuild2/install/operation.cxx b/libbuild2/install/operation.cxx index 95b4381..1b63bc0 100644 --- a/libbuild2/install/operation.cxx +++ b/libbuild2/install/operation.cxx @@ -19,10 +19,255 @@ namespace build2 { namespace install { + bool context_data:: + filter (const scope& rs, + const dir_path& base, + const path& leaf, + entry_type type) + { + assert (type != entry_type::unknown && + (type == entry_type::directory) == leaf.empty ()); + + context& ctx (rs.ctx); + + auto& d (*static_cast<context_data*> (ctx.current_inner_odata.get ())); + + if (d.filters == nullptr || d.filters->empty ()) + return true; + + tracer trace ("install::context_data::filter"); + + // Parse, resolve, and apply each filter in order. + // + // If redoing all this work for every entry proves too slow, we can + // consider some form of caching (e.g., on the per-project basis). + // + size_t limit (0); // See below. + + for (const pair<string, string>& kv: *d.filters) + { + path k; + try + { + k = path (kv.first); + + if (k.absolute ()) + k.normalize (); + } + catch (const invalid_path&) + { + fail << "invalid path '" << kv.first << "' in config.install.filter " + << "value"; + } + + bool v; + { + const string& s (kv.second); + + size_t p (s.find (',')); + + if (s.compare (0, p, "true") == 0) + v = true; + else if (s.compare (0, p, "false") == 0) + v = false; + else + fail << "expected true or false instead of '" << string (s, 0, p) + << "' in config.install.filter value"; + + if (p != string::npos) + { + if (s.compare (p + 1, string::npos, "symlink") == 0) + { + if (type != entry_type::symlink) + continue; + } + else + fail << "unknown modifier '" << string (s, p + 1) << "' in " + << "config.install.filter value"; + } + } + + // @@ TODO (see below for all the corner cases). Note that in a sense + // we already have the match file in any subdirectory support via + // simple patterns so perhaps this is not worth the trouble. Or we + // could support some limited form (e.g., `**` should be in the + // last component). But it may still be tricky to determine if + // it is a sub-filter. + // + if (path_pattern_recursive (k)) + fail << "recursive wildcard pattern '" << kv.first << "' in " + << "config.install.filter value"; + + if (k.simple () && !k.to_directory ()) + { + // Simple name/pattern matched against the leaf. + // + // @@ What if it is `**`? + // + if (path_pattern (k)) + { + if (!path_match (leaf, k)) + continue; + } + else + { + if (k != leaf) + continue; + } + } + else + { + // Split into directory and leaf. + // + // @@ What if leaf is `**`? + // + dir_path d; + if (k.to_directory ()) + { + d = path_cast<dir_path> (move (k)); + k = path (); // No leaf. + } + else + { + d = k.directory (); + k.make_leaf (); + } + + // Resolve relative directory. + // + // Note that this resolution is potentially project-specific (that + // is, different projects may have different install.* locaitons). + // + // Note that if the first component is/contains a wildcard (e.g., + // `*/`), then the resulution will fail, which feels correct (what + // does */ mean?). + // + if (d.relative ()) + { + // @@ Strictly speaking, this should be base, not root scope. + // + d = resolve_dir (rs, move (d)); + } + + // Return the number of path components in the path. + // + auto path_comp = [] (const path& p) + { + size_t n (0); + for (auto i (p.begin ()); i != p.end (); ++i) + ++n; + return n; + }; + + // We need the sub() semantics but which uses pattern match instead + // of equality for the prefix. Looks like chopping off the path and + // calling path_match() on that is the best we can do. + // + // @@ Assumes no `**` components. + // + auto path_sub = [&path_comp] (const dir_path& ent, + const dir_path& pat, + size_t n = 0) + { + if (n == 0) + n = path_comp (pat); + + dir_path p; + for (auto i (ent.begin ()); n != 0 && i != ent.end (); --n, ++i) + p.combine (*i, i.separator ()); + + return path_match (p, pat); + }; + + // The following checks should continue on no match and fall through + // to return. + // + if (k.empty ()) // Directory. + { + // Directories have special semantics. + // + // Consider this sequence of filters: + // + // include/x86_64-linux-gnu/@true + // include/x86_64-linux-gnu/details/@false + // include/@false + // + // It seems the semantics we want is that only subcomponent + // filters should apply. Maybe remember the latest matched + // directory as a current limit? But perhaps we don't need to + // remember the directory itself but the number of path + // components? + // + // I guess for patterns we will use the actual matched directory, + // not the pattern, to calculate the limit? @@ Because we + // currently don't support `**`, we for now can count components + // in the pattern. + + // Check if this is a sub-filter. + // + size_t n (path_comp (d)); + if (n <= limit) + continue; + + if (path_pattern (d)) + { + if (!path_sub (base, d, n)) + continue; + } + else + { + if (!base.sub (d)) + continue; + } + + if (v) + { + limit = n; + continue; // Continue looking for sub-filters. + } + } + else + { + if (path_pattern (d)) + { + if (!path_sub (base, d)) + continue; + } + else + { + if (!base.sub (d)) + continue; + } + + if (path_pattern (k)) + { + // @@ Does not handle `**`. + // + if (!path_match (leaf, k)) + continue; + } + else + { + if (k != leaf) + continue; + } + } + } + + l4 ([&]{trace << (base / leaf) + << (v ? " included by " : " excluded by ") + << kv.first << '@' << kv.second;}); + return v; + } + + return true; + } + #ifndef BUILD2_BOOTSTRAP - install_context_data:: - install_context_data (const path* mf) - : manifest_name (mf), + context_data:: + context_data (const install::filters* fs, const path* mf) + : filters (fs), + manifest_name (mf), manifest_os (mf != nullptr ? open_file_or_stdout (manifest_name, manifest_ofs) : manifest_ofs), @@ -38,7 +283,7 @@ namespace build2 } static path - relocatable_path (install_context_data& d, const target& t, path p) + relocatable_path (context_data& d, const target& t, path p) { // This is both inefficient (re-detecting relocatable manifest for every // path) and a bit dirty (if multiple projects are being installed with @@ -101,7 +346,7 @@ namespace build2 // symlinks belong to tragets, directories do not. // static void - manifest_flush_target (install_context_data& d, const target* tgt) + manifest_flush_target (context_data& d, const target* tgt) { if (d.manifest_target != nullptr) { @@ -163,14 +408,13 @@ namespace build2 d.manifest_target = tgt; } - void install_context_data:: + void context_data:: manifest_install_d (context& ctx, const target& tgt, const dir_path& dir, const string& mode) { - auto& d ( - *static_cast<install_context_data*> (ctx.current_inner_odata.get ())); + auto& d (*static_cast<context_data*> (ctx.current_inner_odata.get ())); if (d.manifest_name.path != nullptr) { @@ -200,15 +444,14 @@ namespace build2 } } - void install_context_data:: + void context_data:: manifest_install_f (context& ctx, const target& tgt, const dir_path& dir, const path& name, const string& mode) { - auto& d ( - *static_cast<install_context_data*> (ctx.current_inner_odata.get ())); + auto& d (*static_cast<context_data*> (ctx.current_inner_odata.get ())); if (d.manifest_name.path != nullptr) { @@ -220,15 +463,14 @@ namespace build2 } } - void install_context_data:: + void context_data:: manifest_install_l (context& ctx, const target& tgt, const path& link_target, const dir_path& dir, const path& link) { - auto& d ( - *static_cast<install_context_data*> (ctx.current_inner_odata.get ())); + auto& d (*static_cast<context_data*> (ctx.current_inner_odata.get ())); if (d.manifest_name.path != nullptr) { @@ -243,8 +485,7 @@ namespace build2 static void manifest_close (context& ctx) { - auto& d ( - *static_cast<install_context_data*> (ctx.current_inner_odata.get ())); + auto& d (*static_cast<context_data*> (ctx.current_inner_odata.get ())); if (d.manifest_name.path != nullptr) { @@ -271,12 +512,13 @@ namespace build2 } } #else - install_context_data:: - install_context_data (const path*) + context_data:: + context_data (const install::filters* fs, const path*) + : filters (fs) { } - void install_context_data:: + void context_data:: manifest_install_d (context&, const target&, const dir_path&, @@ -284,7 +526,7 @@ namespace build2 { } - void install_context_data:: + void context_data:: manifest_install_f (context&, const target&, const dir_path&, @@ -293,7 +535,7 @@ namespace build2 { } - void install_context_data:: + void context_data:: manifest_install_l (context&, const target&, const path&, @@ -341,20 +583,48 @@ namespace build2 if (inner) { - // See if we need to write the installation manifest. + // See if we need to filter and/or write the installation manifest. // // Note: go straight for the public variable pool. // - const variable& var (*ctx.var_pool.find ("config.install.manifest")); - const path* mf (cast_null<path> (ctx.global_scope[var])); + const filters* fs ( + cast_null<filters> ( + ctx.global_scope[*ctx.var_pool.find ("config.install.filter")])); + + const path* mf ( + cast_null<path> ( + ctx.global_scope[*ctx.var_pool.find ("config.install.manifest")])); // Note that we cannot calculate whether the manifest should use // relocatable (relative) paths once here since we don't know the // value of config.install.root. ctx.current_inner_odata = context::current_data_ptr ( - new install_context_data (mf), - [] (void* p) {delete static_cast<install_context_data*> (p);}); + new context_data (fs, mf), + [] (void* p) {delete static_cast<context_data*> (p);}); + } + } + + static void + uninstall_pre (context& ctx, + const values& params, + bool inner, + const location& l) + { + // Note: a subset of install_pre(). + // + if (!params.empty ()) + fail (l) << "unexpected parameters for operation uninstall"; + + if (inner) + { + const filters* fs ( + cast_null<filters> ( + ctx.global_scope[*ctx.var_pool.find ("config.install.filter")])); + + ctx.current_inner_odata = context::current_data_ptr ( + new context_data (fs, nullptr), + [] (void* p) {delete static_cast<context_data*> (p);}); } } @@ -412,7 +682,7 @@ namespace build2 0 /* concurrency */, // Run serially &pre_uninstall, nullptr, - nullptr, + &uninstall_pre, nullptr, nullptr, nullptr |