--- yarns/branches-workspaces.yarn | 9 --------- 1 file changed, 9 deletions(-) diff --git a/yarns/branches-workspaces.yarn b/yarns/branches-workspaces.yarn index 3af362a..21d9e3e 100644 --- a/yarns/branches-workspaces.yarn +++ b/yarns/branches-workspaces.yarn @@ -87,15 +87,6 @@ to check for that locally. AND creating system branch bar, based on foo THEN the system branch bar is checked out -Similarly, attempting to branch a system branch should fail if the -repository does not contain any system morphologies. - - SCENARIO checking out a system branch with no systems - GIVEN a workspace - AND a git server - WHEN morph attempts to branch a repository with no systems - THEN morph failed - Query commands in workspaces ---------------------------- -- 1.7.10.4

--- yarns/branches-workspaces.yarn | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/yarns/branches-workspaces.yarn b/yarns/branches-workspaces.yarn index 21d9e3e..5273f39 100644 --- a/yarns/branches-workspaces.yarn +++ b/yarns/branches-workspaces.yarn @@ -168,7 +168,7 @@ somewhere outside a checkout, where exactly one checkout exists below. However, it fails if run outside a checkout and there's no system branches checked out. - SCENARIO morph fails to report system branch with two checked out + SCENARIO morph fails to report system branch with none checked out GIVEN a workspace AND a git server WHEN attempting to report system branch root repository in . -- 1.7.10.4

Bulk petrify handles regular petrification and branch_from_image's petrifying to another point in time. TODO: Should it be in MorphSet Should it handle not double petrifying --- morphlib/morphset.py | 24 ++++++++++++++++++++++++ morphlib/morphset_tests.py | 17 +++++++++++++++++ 2 files changed, 41 insertions(+) diff --git a/morphlib/morphset.py b/morphlib/morphset.py index 46b75a9..e1a842d 100644 --- a/morphlib/morphset.py +++ b/morphlib/morphset.py @@ -218,3 +218,27 @@ class MorphologySet(object): return known + def bulk_petrify(self, resolutions): + '''Update _every_ ref to the value resolved in resolutions. + + `resolutions` must be a {(repo, ref): resolved_ref} + + This is subtly different to change_ref, since that works on + changing a single spec including its filename, and the morphology + those specs refer to, while bulk_petrify is interested in changing + _all_ the refs. + + ''' + + def wanted_spec(spec): + ref = spec['ref'] + return (not morphlib.git.is_valid_sha1(ref) + and (spec['repo'], ref) in resolutions) + + def process_spec(spec): + tup = (spec['repo'], spec['ref']) + spec['unpetrify-ref'] = spec['ref'] + spec['ref'] = resolutions[tup] + return True + + self._traverse_specs(process_spec, wanted_spec) diff --git a/morphlib/morphset_tests.py b/morphlib/morphset_tests.py index 24f3d91..47a1d74 100644 --- a/morphlib/morphset_tests.py +++ b/morphlib/morphset_tests.py @@ -191,3 +191,20 @@ class MorphologySetTests(unittest.TestCase): self.assertEqual(sorted(self.morphs.list_refs()), [('test:foo-chunk', 'master'), ('test:morphs', 'master')]) + + def test_bulk_petrify(self): + # TODO: test petrifying a larger morphset + self.morphs.add_morphology(self.system) + self.morphs.add_morphology(self.stratum) + self.morphs.bulk_petrify({('test:foo-chunk', 'master'): '0'*40}) + self.assertEqual( + self.stratum['chunks'], + [ + { + 'repo': 'test:foo-chunk', + 'ref': '0'*40, + 'morph': 'foo-chunk', + 'unpetrify-ref': 'master', + } + ]) + -- 1.7.10.4

Tweaking all the morphology specs in a MorphologySet is a common operation. - Edit does it to rewrite refs - petrify does it to fix refs to their state at the current point in time - unpetrify does this to reverse the petrify operation - branch-from-image works similarly to petrify After the refs inside morphologies are tweaked, any morphologies in the MorphSet that are referred to by the changed ref are also updated. This was previously an operation of change_ref, but it will be useful for the other use cases. Changes other than refs are not handled, since there are currently no use cases for it. --- morphlib/morphset.py | 87 +++++++++++++++++++++++++++++++++----------- morphlib/morphset_tests.py | 3 ++ 2 files changed, 69 insertions(+), 21 deletions(-) diff --git a/morphlib/morphset.py b/morphlib/morphset.py index c256760..468bcbe 100644 --- a/morphlib/morphset.py +++ b/morphlib/morphset.py @@ -122,6 +122,66 @@ class MorphologySet(object): raise ChunkNotInStratumError(stratum_morph['name'], chunk_name) return repo_url, ref, morph + def _traverse_specs(self, cb_process, cb_filter=lambda s: True): + '''Higher-order function for processing every spec. + + This traverses every spec in all the morphologies, so all chunk, + stratum and stratum-build-depend specs are visited. + + It is to be passed one or two callbacks. `cb_process` is given + a spec, which it may alter, but if it does, it must return True. + + `cb_filter` is given the morphology, the kind of spec it is + working on in addition to the spec itself. + + `cb_filter` is expected to decide whether to run `cb_process` + on the spec. + + Arguably this could be checked in `cb_process`, but it can be less + logic over all since `cb_process` need not conditionally return. + + If any specs have been altered, at the end of iteration, any + morphologies in the MorphologySet that are referred to by an + altered spec are also changed. + + This requires a full iteration of the MorphologySet, so it is not a + cheap operation. + + A coroutine was attempted, but it required the same amount of + code at the call site as doing it by hand. + + ''' + + altered_references = {} + + def process_spec_list(m, kind): + specs = m[kind] + for spec in specs: + if cb_filter(m, kind, spec): + orig_spec = (spec['repo'], spec['ref'], spec['morph']) + dirtied = cb_process(m, kind, spec) + if dirtied: + m.dirty = True + altered_references[orig_spec] = spec + + for m in self.morphologies: + if m['kind'] == 'system': + process_spec_list(m, 'strata') + elif m['kind'] == 'stratum': + process_spec_list(m, 'build-depends') + process_spec_list(m, 'chunks') + + for m in self.morphologies: + tup = (m.repo_url, m.ref, m.filename[:-len('.morph')]) + if tup in altered_references: + spec = altered_references[tup] + if m.ref != spec['ref']: + m.ref = spec['ref'] + m.dirty = True + assert (m.filename == spec['morph'] + '.morph' + or m.repo_url == spec['repo']), \ + 'Moving morphologies is not supported.' + def change_ref(self, repo_url, orig_ref, morph_filename, new_ref): '''Change a triplet's ref to a new one in all morphologies in a ref. @@ -130,30 +190,15 @@ class MorphologySet(object): ''' - def wanted_spec(spec): + def wanted_spec(m, kind, spec): return (spec['repo'] == repo_url and spec['ref'] == orig_ref and spec['morph'] + '.morph' == morph_filename) - def change_specs(specs, m): - for spec in specs: - if wanted_spec(spec): - spec['unpetrify-ref'] = spec['ref'] - spec['ref'] = new_ref - m.dirty = True - - def change(m): - if m['kind'] == 'system': - change_specs(m['strata'], m) - elif m['kind'] == 'stratum': - change_specs(m['chunks'], m) - change_specs(m['build-depends'], m) - - for m in self.morphologies: - change(m) + def process_spec(m, kind, spec): + spec['unpetrify-ref'] = spec['ref'] + spec['ref'] = new_ref + return True - m = self._get_morphology(repo_url, orig_ref, morph_filename) - if m and m.ref != new_ref: - m.ref = new_ref - m.dirty = True + self._traverse_specs(process_spec, wanted_spec) diff --git a/morphlib/morphset_tests.py b/morphlib/morphset_tests.py index 65fe205..69a7057 100644 --- a/morphlib/morphset_tests.py +++ b/morphlib/morphset_tests.py @@ -145,6 +145,9 @@ class MorphologySetTests(unittest.TestCase): }, ] }) + other_stratum.repo_url = 'test:morphs' + other_stratum.ref = 'master' + other_stratum.filename = 'other-stratum.morph' self.morphs.add_morphology(self.system) self.morphs.add_morphology(self.stratum) -- 1.7.10.4

TODO: Should this be part of morphset Add an unpetrify method to MorphSet, since it's a good place to put it and may be needed for merge. --- morphlib/morphset.py | 14 ++++++++++++++ morphlib/morphset_tests.py | 14 ++++++++++++++ 2 files changed, 28 insertions(+) diff --git a/morphlib/morphset.py b/morphlib/morphset.py index e1a842d..a3ce446 100644 --- a/morphlib/morphset.py +++ b/morphlib/morphset.py @@ -242,3 +242,17 @@ class MorphologySet(object): return True self._traverse_specs(process_spec, wanted_spec) + + def unpetrify_all(self): + '''If a spec is petrified, unpetrify it. + + ''' + + def wanted_spec(spec): + return ('unpetrify-ref' in spec and + morphlib.git.is_valid_sha1(spec['ref'])) + def process_spec(spec): + spec['ref'] = spec.pop('unpetrify-ref') + return True + + self._traverse_specs(process_spec, wanted_spec) diff --git a/morphlib/morphset_tests.py b/morphlib/morphset_tests.py index 47a1d74..814dcba 100644 --- a/morphlib/morphset_tests.py +++ b/morphlib/morphset_tests.py @@ -208,3 +208,17 @@ class MorphologySetTests(unittest.TestCase): } ]) + def test_unpetrify_all(self): + self.morphs.add_morphology(self.system) + self.morphs.add_morphology(self.stratum) + self.morphs.bulk_petrify({('test:foo-chunk', 'master'): '0'*40}) + self.morphs.unpetrify_all() + self.assertEqual( + self.stratum['chunks'], + [ + { + 'repo': 'test:foo-chunk', + 'ref': 'master', + 'morph': 'foo-chunk', + } + ]) -- 1.7.10.4

petrify_chunks handles regular petrification and branch_from_image's petrifying to another point in time. It is given the values to petrify to, instead of doing the ref resolution itself, since now it will consistently resolve refs to the same thing, and a different resolution can be passed in to petrify to another point in time. It only petrifies chunks, since petrifying strata and systems is a more complex operation that is not currently handled anyway. --- morphlib/morphset.py | 32 +++++++++++++++++++++++++++++++- morphlib/morphset_tests.py | 17 +++++++++++++++++ 2 files changed, 48 insertions(+), 1 deletion(-) diff --git a/morphlib/morphset.py b/morphlib/morphset.py index 1058332..dad3c83 100644 --- a/morphlib/morphset.py +++ b/morphlib/morphset.py @@ -214,7 +214,7 @@ class MorphologySet(object): def wanted_spec(m, kind, spec): return (spec['repo'], spec['ref']) not in known - def process_spec(spec): + def process_spec(m, kind, spec): known.add((spec['repo'], spec['ref'])) return False @@ -222,3 +222,33 @@ class MorphologySet(object): return known + def petrify_chunks(self, resolutions): + '''Update _every_ chunk's ref to the value resolved in resolutions. + + `resolutions` must be a {(repo, ref): resolved_ref} + + This is subtly different to change_ref, since that works on + changing a single spec including its filename, and the morphology + those specs refer to, while petrify_chunks is interested in changing + _all_ the refs. + + ''' + + def wanted_chunk_spec(m, kind, spec): + # Do not attempt to petrify non-chunk specs. + # This is not handled by previous implementations, and + # the details are tricky. + if not (m['kind'] == 'stratum' and kind == 'chunks'): + return + ref = spec['ref'] + return (not morphlib.git.is_valid_sha1(ref) + and (spec['repo'], ref) in resolutions) + + def process_chunk_spec(m, kind, spec): + tup = (spec['repo'], spec['ref']) + spec['unpetrify-ref'] = spec['ref'] + spec['ref'] = resolutions[tup] + return True + + self._traverse_specs(process_chunk_spec, wanted_chunk_spec) + diff --git a/morphlib/morphset_tests.py b/morphlib/morphset_tests.py index 24f3d91..baa3e10 100644 --- a/morphlib/morphset_tests.py +++ b/morphlib/morphset_tests.py @@ -191,3 +191,20 @@ class MorphologySetTests(unittest.TestCase): self.assertEqual(sorted(self.morphs.list_refs()), [('test:foo-chunk', 'master'), ('test:morphs', 'master')]) + + def test_petrify_chunks(self): + # TODO: test petrifying a larger morphset + self.morphs.add_morphology(self.system) + self.morphs.add_morphology(self.stratum) + self.morphs.petrify_chunks({('test:foo-chunk', 'master'): '0'*40}) + self.assertEqual( + self.stratum['chunks'], + [ + { + 'repo': 'test:foo-chunk', + 'ref': '0'*40, + 'morph': 'foo-chunk', + 'unpetrify-ref': 'master', + } + ]) + -- 1.7.10.4

--- morphlib/plugins/branch_and_merge_new_plugin.py | 30 ++++++++++------------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/morphlib/plugins/branch_and_merge_new_plugin.py b/morphlib/plugins/branch_and_merge_new_plugin.py index 3bc3602..24f42c9 100644 --- a/morphlib/plugins/branch_and_merge_new_plugin.py +++ b/morphlib/plugins/branch_and_merge_new_plugin.py @@ -675,29 +675,25 @@ class SimpleBranchAndMergePlugin(cliapp.Plugin): loader = morphlib.morphloader.MorphologyLoader() lrc, rrc = morphlib.util.new_repo_caches(self.app) update_repos = not self.app.settings['no-git-update'] - done = set() morphs = self._load_all_sysbranch_morphologies(sb, loader) - # Petrify the ref to each stratum and chunk. - def petrify_specs(specs): - for spec in specs: - ref = spec['ref'] - # Do not double petrify refs - if morphlib.git.is_valid_sha1(ref): + #TODO: Stop using app.resolve_ref + def resolve_refs(morphs): + for repo, ref in morphs.list_refs(): + # TODO: Handle refs that are only in workspace in general + if (repo == sb.root_repository_url + and ref == sb.system_branch_name): continue commit_sha1, tree_sha1 = self.app.resolve_ref( - lrc, rrc, spec['repo'], ref, update=update_repos) - assert 'name' in spec or 'morph' in spec - filename = '%s.morph' % spec.get('morph', spec.get('name')) - morphs.change_ref(spec['repo'], ref, filename, commit_sha1) + lrc, rrc, repo, ref, update=update_repos) + yield ((repo, ref), commit_sha1) - for m in morphs.morphologies: - if m['kind'] == 'system': - petrify_specs(m['strata']) - elif m['kind'] == 'stratum': - petrify_specs(m['build-depends']) - petrify_specs(m['chunks']) + morphs.repoint_refs(sb.root_repository_url, + sb.get_config('branch.original-ref'), + sb.system_branch_name) + + morphs.petrify_chunks(dict(resolve_refs(morphs))) # Write morphologies back out again. self._save_dirty_morphologies(loader, sb, morphs.morphologies) -- 1.7.10.4

--- morphlib/plugins/branch_and_merge_new_plugin.py | 24 +---------------------- 1 file changed, 1 insertion(+), 23 deletions(-) diff --git a/morphlib/plugins/branch_and_merge_new_plugin.py b/morphlib/plugins/branch_and_merge_new_plugin.py index 24f42c9..5c586cb 100644 --- a/morphlib/plugins/branch_and_merge_new_plugin.py +++ b/morphlib/plugins/branch_and_merge_new_plugin.py @@ -711,33 +711,11 @@ class SimpleBranchAndMergePlugin(cliapp.Plugin): ws = morphlib.workspace.open('.') sb = morphlib.sysbranchdir.open_from_within('.') loader = morphlib.morphloader.MorphologyLoader() - lrc, rrc = morphlib.util.new_repo_caches(self.app) - update_repos = not self.app.settings['no-git-update'] - done = set() morphs = self._load_all_sysbranch_morphologies(sb, loader) # Restore the ref for each stratum and chunk - def unpetrify_specs(specs): - dirty = False - for spec in specs: - ref = spec['ref'] - # Don't attempt to unpetrify refs which aren't petrified - if not ('unpetrify-ref' in spec - and morphlib.git.is_valid_sha1(ref)): - continue - spec['ref'] = spec.pop('unpetrify-ref') - dirty = True - return dirty - - for m in morphs.morphologies: - dirty = False - if m['kind'] == 'system': - dirty = dirty or unpetrify_specs(m['strata']) - elif m['kind'] == 'stratum': - dirty = dirty or unpetrify_specs(m['build-depends']) - dirty = dirty or unpetrify_specs(m['chunks']) - m.dirty = True + morphs.unpetrify_all() # Write morphologies back out again. self._save_dirty_morphologies(loader, sb, morphs.morphologies) -- 1.7.10.4