aboutsummaryrefslogtreecommitdiff
path: root/bpkg/cfg-link.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'bpkg/cfg-link.cxx')
-rw-r--r--bpkg/cfg-link.cxx321
1 files changed, 321 insertions, 0 deletions
diff --git a/bpkg/cfg-link.cxx b/bpkg/cfg-link.cxx
new file mode 100644
index 0000000..2b3f52c
--- /dev/null
+++ b/bpkg/cfg-link.cxx
@@ -0,0 +1,321 @@
+// file : bpkg/cfg-link.cxx -*- C++ -*-
+// license : MIT; see accompanying LICENSE file
+
+#include <bpkg/cfg-link.hxx>
+
+#include <bpkg/package.hxx>
+#include <bpkg/package-odb.hxx>
+#include <bpkg/database.hxx>
+#include <bpkg/diagnostics.hxx>
+
+using namespace std;
+
+namespace bpkg
+{
+ shared_ptr<configuration>
+ cfg_link (database& db,
+ const dir_path& ld,
+ bool rel,
+ optional<string> name,
+ bool sys_rep)
+ {
+ tracer trace ("cfg_link");
+
+ bool name_specified (name);
+ const dir_path& cd (db.config); // Note: absolute and normalized.
+
+ // Load the self-link object from the database of the configuration being
+ // linked to obtain its name, type, and uuid.
+ //
+ database& ldb (db.attach (ld, sys_rep));
+
+ string type;
+ uuid uid;
+ {
+ shared_ptr<configuration> cf (ldb.load<configuration> (0));
+
+ type = move (cf->type);
+ uid = cf->uuid;
+
+ if (!name)
+ name = move (cf->name);
+ }
+
+ if (db.uuid == uid)
+ fail << "linking configuration " << ld << " with itself" <<
+ info << "uuid: " << uid;
+
+ if (name && name == db.name)
+ fail << "linking configuration " << ld << " using current "
+ << "configuration name '" << *name << "'" <<
+ info << "consider specifying alternative name with --name";
+
+ // Verify that the name and path of the configuration being linked do not
+ // clash with already linked configurations. Fail if configurations with
+ // this uuid is already linked unless the link is implicit, in which case
+ // make it explicit and update its name and path.
+ //
+ // Note that when we make an implicit link explicit, we start treating it
+ // as an implicit and explicit simultaneously. So, for example, for cfg1
+ // the link cfg2 is explicit and the link cfg3 is both explicit and
+ // implicit:
+ //
+ // cfg2 <- cfg1 <-> cfg3
+ //
+ // Similar, if we link cfg1 with cfg2, the explicit link cfg2 in cfg1 also
+ // becomes both explicit and implicit, not being amended directly.
+ //
+ shared_ptr<configuration> lcf;
+
+ using query = query<configuration>;
+
+ for (shared_ptr<configuration> lc:
+ pointer_result (db.query<configuration> (query::id != 0)))
+ {
+ if (uid == lc->uuid)
+ {
+ if (lc->expl)
+ fail << "configuration with uuid " << uid << " is already linked "
+ << "as " << lc->path;
+
+ // Verify the existing implicit link integrity and cache it to update
+ // later, when the name/path clash check is complete.
+ //
+ db.verify_link (*lc, ldb);
+
+ lcf = move (lc);
+ continue;
+ }
+
+ if (ld == lc->effective_path (cd))
+ fail << "configuration with path " << ld << " is already linked";
+
+ // If the name clashes, then fail if it was specified by the user and
+ // issue a warning and link the configuration as unnamed otherwise.
+ //
+ if (name && name == lc->name)
+ {
+ diag_record dr (name_specified ? error : warn);
+ dr << "configuration with name " << *name << " is already linked as "
+ << lc->path;
+
+ if (name_specified)
+ {
+ dr << info << "consider specifying alternative name with --name"
+ << endf;
+ }
+ else
+ {
+ dr << ", linking as unnamed";
+ name = nullopt;
+ }
+ }
+ }
+
+ // If requested, rebase the first path relative to the second or return it
+ // as is otherwise. Fail if the rebase is not possible (e.g., paths are on
+ // different drives on Windows).
+ //
+ auto rebase = [rel] (const dir_path& x, const dir_path& y) -> dir_path
+ {
+ try
+ {
+ return rel ? x.relative (y) : x;
+ }
+ catch (const invalid_path&)
+ {
+ fail << "unable to rebase " << x << " relative to " << y <<
+ info << "specify absolute configuration directory path to save it "
+ << "as absolute" << endf;
+ }
+ };
+
+ // If the implicit link already exists, then make it explicit and update
+ // its name and path. Otherwise, create a new link.
+ //
+ // Note that in the former case the current configuration must already be
+ // explicitly linked with the configuration being linked. We verify that
+ // and the link integrity.
+ //
+ if (lcf != nullptr)
+ {
+ // Verify the back-link integrity.
+ //
+ shared_ptr<configuration> cf (
+ ldb.query_one<configuration> (query::uuid == db.uuid.string ()));
+
+ // Note: both sides of the link cannot be implicit.
+ //
+ if (cf == nullptr || !cf->expl)
+ fail << "configuration " << ld << " is already implicitly linked but "
+ << "current configuration " << cd << " is not explicitly linked "
+ << "with it";
+
+ ldb.verify_link (*cf, db);
+
+ // Finally, turn the implicit link into explicit.
+ //
+ // Note: reuse id.
+ //
+ lcf->expl = true;
+ lcf->name = move (name);
+ lcf->path = rebase (ld, cd); // Note: can't clash (see above).
+
+ db.update (lcf);
+ }
+ else
+ {
+ // If the directory path of the configuration being linked is relative
+ // or the --relative option is specified, then rebase it relative to the
+ // current configuration directory path.
+ //
+ lcf = make_shared<configuration> (uid,
+ move (name),
+ move (type),
+ rebase (ld, cd),
+ true /* explicit */);
+
+ db.persist (lcf);
+
+ // Now implicitly link ourselves with the just linked configuration.
+ // Note that we link ourselves as unnamed.
+ //
+ shared_ptr<configuration> ccf (db.load<configuration> (0));
+
+ // What if we find the current configuration to already be implicitly
+ // linked? The potential scenario could be, that the current
+ // configuration was recreated from scratch, previously being implicitly
+ // linked with the configuration we currently link. It feels like in
+ // this case we would rather overwrite the existing dead implicit link
+ // than just fail. Let's also warn for good measure.
+ //
+ shared_ptr<configuration> cf;
+
+ for (shared_ptr<configuration> lc:
+ pointer_result (ldb.query<configuration> (query::id != 0)))
+ {
+ if (cd == lc->make_effective_path (ld))
+ {
+ if (lc->expl)
+ fail << "current configuration " << cd << " is already linked "
+ << "with " << ld;
+
+ warn << "current configuration " << cd << " is already implicitly "
+ << "linked with " << ld;
+
+ cf = move (lc);
+ continue;
+ }
+
+ if (ccf->uuid == lc->uuid)
+ fail << "current configuration " << ccf->uuid << " is already "
+ << "linked with " << ld;
+ }
+
+ // It feels natural to persist explicitly and implicitly linked
+ // configuration paths both either relative or absolute.
+ //
+ if (cf != nullptr)
+ {
+ // The dead implicit link case.
+ //
+ // Note: reuse id.
+ //
+ cf->uuid = ccf->uuid;
+ cf->type = move (ccf->type);
+ cf->path = rebase (cd, ld);
+
+ ldb.update (cf);
+ }
+ else
+ {
+ ccf = make_shared<configuration> (ccf->uuid,
+ nullopt /* name */,
+ move (ccf->type),
+ rebase (cd, ld),
+ false /* explicit */);
+
+ ldb.persist (ccf);
+ }
+ }
+
+ // If explicit links of the current database are pre-attached, then also
+ // pre-attach explicit links of the newly linked database.
+ //
+ linked_configs& lcs (db.explicit_links ());
+
+ if (!lcs.empty ())
+ {
+ lcs.push_back (linked_config {*lcf->id, lcf->name, ldb});
+ ldb.attach_explicit (sys_rep);
+ }
+
+ // If the implicit links of the linked database are already cached, then
+ // also cache the current database, unless it is already there (see above
+ // for the dead link case).
+ //
+ linked_databases& lds (ldb.implicit_links (false /* attach */));
+
+ if (!lds.empty () && find (lds.begin (), lds.end (), db) == lds.end ())
+ lds.push_back (db);
+
+ return lcf;
+ }
+
+ int
+ cfg_link (const cfg_link_options& o, cli::scanner& args)
+ try
+ {
+ tracer trace ("cfg_link");
+
+ dir_path c (o.directory ());
+ l4 ([&]{trace << "configuration: " << c;});
+
+ if (o.name_specified ())
+ validate_configuration_name (o.name (), "--name option value");
+
+ if (!args.more ())
+ fail << "configuration directory argument expected" <<
+ info << "run 'bpkg help cfg-link' for more information";
+
+ dir_path ld (args.next ());
+ if (ld.empty ())
+ throw invalid_path (ld.string ());
+
+ l4 ([&]{trace << "link configuration: " << ld;});
+
+ bool rel (ld.relative () || o.relative ());
+ normalize (ld, "specified linked configuration");
+
+ database db (c, trace, false /* pre_attach */, false /* sys_rep */, {ld});
+ transaction t (db);
+
+ shared_ptr<configuration> lc (
+ cfg_link (db,
+ ld,
+ rel,
+ o.name_specified () ? o.name () : optional<string> ()));
+
+ t.commit ();
+
+ if (verb && !o.no_result ())
+ {
+ diag_record dr (text);
+
+ dr << "linked configuration " << ld <<
+ info << "uuid: " << lc->uuid <<
+ info << "type: " << lc->type;
+
+ if (lc->name)
+ dr << info << "name: " << *lc->name;
+
+ dr << info << "id: " << *lc->id;
+ }
+
+ return 0;
+ }
+ catch (const invalid_path& e)
+ {
+ fail << "invalid path: '" << e.path << "'" << endf;
+ }
+}