chainsaw-update: taking care of initial cloning

Perhaps we should go just a bit lower level than this `instance()`,
since the main added value in our use-case is full path resolution,
that we need to do anyway for the rmtree cleanup.

hgext/chainsaw.py

@@ -1,157 +1,217 b''
 # chainsaw.py
 #
 # Copyright 2022 Georges Racinet <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 """chainsaw is a collection of single-minded and dangerous tools. (EXPERIMENTAL)
 
   "Don't use a chainsaw to cut your food!"
 
 The chainsaw extension provides commands that are so much geared towards a
 specific use case in a specific context or environment that they are totally
 inappropriate and **really dangerous** in other contexts.
 
 The help text of each command explicitly summarizes its context of application
 and the wanted end result.
 
 It is recommended to run these commands with the ``HGPLAIN`` environment
 variable (see :hg:`help scripting`).
 """
 
 import shutil
 
 from mercurial.i18n import _
 from mercurial import (
     cmdutil,
     commands,
     error,
+    localrepo,
     registrar,
 )
+from mercurial.utils import (
+    urlutil,
+)
 
 cmdtable = {}
 command = registrar.command(cmdtable)
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = b'ships-with-hg-core'
 
 
 @command(
     b'admin::chainsaw-update',
     [
         (
             b'',
             b'purge-unknown',
             True,
             _(
                 b'Remove unversioned files before update. Disabling this can '
                 b'in some cases interfere with the update.'
                 b'See also :hg:`purge`.'
             ),
         ),
         (
             b'',
             b'purge-ignored',
             True,
             _(
                 b'Remove ignored files before update. Disable this for '
                 b'instance to reuse previous compiler object files. '
                 b'See also :hg:`purge`.'
             ),
         ),
         (
             b'',
             b'rev',
             b'',
             _(b'revision to update to'),
         ),
         (
             b'',
             b'source',
             b'',
             _(b'repository to clone from'),
         ),
+        (
+            b'',
+            b'dest',
+            b'',
+            _(b'repository to update to REV (possibly cloning)'),
+        ),
+        (
+            b'',
+            b'initial-clone-minimal',
+            False,
+            _(
+                b'Pull only the prescribed revision upon initial cloning. '
+                b'This has the side effect of ignoring clone-bundles, '
+                b'which if often slower on the client side and stressful '
+                b'to the server than applying available clone bundles.'
+            ),
+        ),
     ],
-    _(b'hg admin::chainsaw-update [OPTION] --rev REV --source SOURCE...'),
+    _(
+        b'hg admin::chainsaw-update [OPTION] --rev REV --source SOURCE --dest DEST'
+    ),
     helpbasic=True,
+    norepo=True,
 )
-def update(ui, repo, **opts):
+def update(ui, **opts):
     """pull and update to a given revision, no matter what, (EXPERIMENTAL)
 
     Context of application: *some* Continuous Integration (CI) systems,
     packaging or deployment tools.
 
-    Wanted end result: clean working directory updated at the given revision.
+    Wanted end result: local repository at the given REPO_PATH, having the
+    latest changes to the given revision and with a clean working directory
+    updated at the given revision.
 
     chainsaw-update pulls from one source, then updates the working directory
     to the given revision, overcoming anything that would stand in the way.
 
     By default, it will:
 
+    - clone if the local repo does not exist yet, **removing any directory
+      at the given path** that would not be a Mercurial repository.
+      The initial clone is full by default, so that clonebundles can be
+      applied. Use the --initial-clone-minimal flag to avoid this.
     - break locks if needed, leading to possible corruption if there
       is a concurrent write access.
     - perform recovery actions if needed
     - revert any local modification.
     - purge unknown and ignored files.
     - go as far as to reclone if everything else failed (not implemented yet).
 
     DO NOT use it for anything else than performing a series
     of unattended updates, with full exclusive repository access each time
     and without any other local work than running build scripts.
     In case the local repository is a share (see :hg:`help share`), exclusive
     write access to the share source is also mandatory.
 
     It is recommended to run these commands with the ``HGPLAIN`` environment
     variable (see :hg:`scripting`).
 
     Motivation: in Continuous Integration and Delivery systems (CI/CD), the
     occasional remnant or bogus lock are common sources of waste of time (both
     working time and calendar time). CI/CD scripts tend to grow with counter-
     measures, often done in urgency. Also, whilst it is neat to keep
     repositories from one job to the next (especially with large
     repositories), an exceptional recloning is better than missing a release
     deadline.
     """
     rev = opts['rev']
     source = opts['source']
+    repo_path = opts['dest']
     if not rev:
         raise error.InputError(_(b'specify a target revision with --rev'))
     if not source:
         raise error.InputError(_(b'specify a pull path with --source'))
+    if not repo_path:
+        raise error.InputError(_(b'specify a repo path with --dest'))
+    repo_path = urlutil.urllocalpath(repo_path)
+
+    try:
+        repo = localrepo.instance(ui, repo_path, create=False)
+        repo_created = False
+        ui.status(_(b'loaded repository at "%s"\n' % repo_path))
+    except error.RepoError:
+        try:
+            shutil.rmtree(repo_path)
+        except FileNotFoundError:
+            ui.status(_(b'no such directory: "%s"\n' % repo_path))
+        else:
+            ui.status(
+                _(
+                    b'removed non-repository file or directory '
+                    b'at "%s"' % repo_path
+                )
+            )
+
+        ui.status(_(b'creating repository at "%s"\n' % repo_path))
+        repo = localrepo.instance(ui, repo_path, create=True)
+        repo_created = True
+
     if repo.svfs.tryunlink(b'lock'):
         ui.status(_(b'had to break store lock\n'))
     if repo.vfs.tryunlink(b'wlock'):
         ui.status(_(b'had to break working copy lock\n'))
 
     ui.status(_(b'recovering after interrupted transaction, if any\n'))
     repo.recover()
 
     ui.status(_(b'pulling from %s\n') % source)
+    if repo_created and not opts.get('initial_clone_minimal'):
+        pull_revs = []
+    else:
+        pull_revs = [rev]
     overrides = {(b'ui', b'quiet'): True}
-    with ui.configoverride(overrides, b'chainsaw-update'):
+    with repo.ui.configoverride(overrides, b'chainsaw-update'):
         pull = cmdutil.findcmd(b'pull', commands.table)[1][0]
-        pull(ui, repo, source, rev=[rev], remote_hidden=False)
+        pull(repo.ui, repo, source, rev=pull_revs, remote_hidden=False)
 
     purge = cmdutil.findcmd(b'purge', commands.table)[1][0]
     purge(
         ui,
         repo,
         dirs=True,
         all=opts.get('purge_ignored'),
         files=opts.get('purge_unknown'),
         confirm=False,
     )
 
     ui.status(_(b'updating to revision \'%s\'\n') % rev)
     update = cmdutil.findcmd(b'update', commands.table)[1][0]
     update(ui, repo, rev=rev, clean=True)
 
     ui.status(
         _(
             b'chainsaw-update to revision \'%s\' '
             b'for repository at \'%s\' done\n'
         )
         % (rev, repo.root)
     )

tests/test-chainsaw-update.t

@@ -1,169 +1,255 b''
 ============================================
 Tests for the admin::chainsaw-update command
 ============================================
 
 setup
 =====
 
   $ cat >> $HGRCPATH << EOF
   > [extensions]
   > chainsaw=
   > EOF
 
   $ hg init src
   $ cd src
   $ echo 1 > root
   $ hg add root
   $ hg ci -Am R_0
   $ hg branch A
   marked working directory as branch A
   (branches are permanent and global, did you want a bookmark?)
   $ echo 42 > bar
   $ hg add bar
   $ hg ci -Am A_0
   $ echo 1337 > bar
   $ hg ci -Am A_1
   $ hg update 'desc(R_0)'
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 1 > foo
   $ hg add foo
   $ hg ci -Am B_0
   $ hg log -G
   @  changeset:   3:bfcb8e629987
   |  tag:         tip
   |  parent:      0:06f48e4098b8
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     B_0
   |
   | o  changeset:   2:7fd8de258aa4
   | |  branch:      A
   | |  user:        test
   | |  date:        Thu Jan 01 00:00:00 1970 +0000
   | |  summary:     A_1
   | |
   | o  changeset:   1:ae1692b8aadb
   |/   branch:      A
   |    user:        test
   |    date:        Thu Jan 01 00:00:00 1970 +0000
   |    summary:     A_0
   |
   o  changeset:   0:06f48e4098b8
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     R_0
   
   $ cd ..
 
 Actual tests
 ============
 
-Simple invocation
------------------
+Initial cloning if needed
+-------------------------
 
-  $ hg init repo
-  $ cd repo
-  $ hg admin::chainsaw-update --rev default --source ../src
+  $ hg admin::chainsaw-update --dest repo --rev default --source ./src
+  no such directory: "repo"
+  creating repository at "repo"
   recovering after interrupted transaction, if any
   no interrupted transaction available
-  pulling from ../src
+  pulling from ./src
   updating to revision 'default'
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   chainsaw-update to revision 'default' for repository at '$TESTTMP/repo' done
 
+  $ cd repo
   $ hg log -G
-  @  changeset:   1:bfcb8e629987
+  @  changeset:   3:bfcb8e629987
   |  tag:         tip
+  |  parent:      0:06f48e4098b8
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  summary:     B_0
   |
+  | o  changeset:   2:7fd8de258aa4
+  | |  branch:      A
+  | |  user:        test
+  | |  date:        Thu Jan 01 00:00:00 1970 +0000
+  | |  summary:     A_1
+  | |
+  | o  changeset:   1:ae1692b8aadb
+  |/   branch:      A
+  |    user:        test
+  |    date:        Thu Jan 01 00:00:00 1970 +0000
+  |    summary:     A_0
+  |
   o  changeset:   0:06f48e4098b8
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     R_0
   
   $ hg status -A
   C foo
   C root
   $ cat foo
   1
 
 Test lock breacking capabilities
 --------------------------------
 
 Demonstrate lock-breaking capabilities with locks that regular Mercurial
 operation would not break, because the hostnames registered in locks differ
 from the current hostname (happens a lot with succesive containers):
 
   $ ln -s invalid.host.test/effffffc:171814 .hg/store/lock
   $ ln -s invalid.host.test/effffffc:171814 .hg/wlock
   $ hg debuglock
   lock:  (.*?), process 171814, host invalid.host.test/effffffc \((\d+)s\) (re)
   wlock: (.*?), process 171814, host invalid.host.test/effffffc \((\d+)s\) (re)
   [2]
 
-  $ hg admin::chainsaw-update --no-purge-ignored --rev default --source ../src
+  $ hg admin::chainsaw-update --no-purge-ignored --dest . --rev default --source ../src
+  loaded repository at "."
   had to break store lock
   had to break working copy lock
   recovering after interrupted transaction, if any
   no interrupted transaction available
   pulling from ../src
   updating to revision 'default'
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   chainsaw-update to revision 'default' for repository at '$TESTTMP/repo' done
 
 Test file purging capabilities
 ------------------------------
 
 Let's also add local modifications (tracked and untracked) to demonstrate the
 purging.
 
   $ echo untracked > bar
   $ echo modified > foo
   $ hg status -A
   M foo
   ? bar
   C root
 
   $ echo 2 > ../src/foo
-  $ hg -R ../src commit -m2
-  $ hg admin::chainsaw-update --rev default --source ../src -q
+  $ hg -R ../src commit -mB_1
+  $ hg admin::chainsaw-update --dest . --rev default --source ../src -q
   no interrupted transaction available
+  $ hg log -G
+  @  changeset:   4:973ab81c95fb
+  |  tag:         tip
+  |  user:        test
+  |  date:        Thu Jan 01 00:00:00 1970 +0000
+  |  summary:     B_1
+  |
+  o  changeset:   3:bfcb8e629987
+  |  parent:      0:06f48e4098b8
+  |  user:        test
+  |  date:        Thu Jan 01 00:00:00 1970 +0000
+  |  summary:     B_0
+  |
+  | o  changeset:   2:7fd8de258aa4
+  | |  branch:      A
+  | |  user:        test
+  | |  date:        Thu Jan 01 00:00:00 1970 +0000
+  | |  summary:     A_1
+  | |
+  | o  changeset:   1:ae1692b8aadb
+  |/   branch:      A
+  |    user:        test
+  |    date:        Thu Jan 01 00:00:00 1970 +0000
+  |    summary:     A_0
+  |
+  o  changeset:   0:06f48e4098b8
+     user:        test
+     date:        Thu Jan 01 00:00:00 1970 +0000
+     summary:     R_0
+  
   $ hg status -A
   C foo
   C root
   $ cat foo
   2
 
 Now behaviour with respect to ignored files: they are not purged if
 the --no-purge-ignored flag is passed, but they are purged by default
 
   $ echo bar > .hgignore
   $ hg ci -Aqm hgignore
   $ echo ignored > bar
   $ hg status --all
   I bar
   C .hgignore
   C foo
   C root
 
-  $ hg admin::chainsaw-update --no-purge-ignored --rev default --source ../src -q
+  $ hg admin::chainsaw-update --no-purge-ignored --dest . --rev default --source ../src -q
   no interrupted transaction available
   $ hg status --all
   I bar
   C .hgignore
   C foo
   C root
   $ cat bar
   ignored
 
-  $ hg admin::chainsaw-update --rev default --source ../src -q
+  $ hg admin::chainsaw-update --dest . --rev default --source ../src -q
   no interrupted transaction available
   $ hg status --all
   C .hgignore
   C foo
   C root
   $ test -f bar
   [1]
 
+test --minimal-initial-cloning variant
+--------------------------------------
+
+With `--minimal-initial-cloning`, there is no "requesting all changes"
+message. Hence clone bundles would be bypassed (TODO test both cases
+# with an actual clone-bundle)
+
+  $ cd ..
+  $ hg admin::chainsaw-update --dest repo2 --rev default --source src --initial-clone-minimal
+  no such directory: "repo2"
+  creating repository at "repo2"
+  recovering after interrupted transaction, if any
+  no interrupted transaction available
+  pulling from src
+  updating to revision 'default'
+  2 files updated, 0 files merged, 0 files removed, 0 files unresolved
+  chainsaw-update to revision 'default' for repository at '$TESTTMP/repo2' done
+
+  $ cd repo2
+  $ hg log -G
+  @  changeset:   2:973ab81c95fb
+  |  tag:         tip
+  |  user:        test
+  |  date:        Thu Jan 01 00:00:00 1970 +0000
+  |  summary:     B_1
+  |
+  o  changeset:   1:bfcb8e629987
+  |  user:        test
+  |  date:        Thu Jan 01 00:00:00 1970 +0000
+  |  summary:     B_0
+  |
+  o  changeset:   0:06f48e4098b8
+     user:        test
+     date:        Thu Jan 01 00:00:00 1970 +0000
+     summary:     R_0
+  
+  $ hg status -A
+  C foo
+  C root
+  $ cat foo
+  2