From patchwork Fri Nov 19 23:03:28 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629703 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B9377C433F5 for ; Fri, 19 Nov 2021 23:03:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234515AbhKSXGv (ORCPT ); Fri, 19 Nov 2021 18:06:51 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35128 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233493AbhKSXGu (ORCPT ); Fri, 19 Nov 2021 18:06:50 -0500 Received: from mail-wr1-x42e.google.com (mail-wr1-x42e.google.com [IPv6:2a00:1450:4864:20::42e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 10E43C06173E for ; Fri, 19 Nov 2021 15:03:48 -0800 (PST) Received: by mail-wr1-x42e.google.com with SMTP id u1so20600003wru.13 for ; Fri, 19 Nov 2021 15:03:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=uQJ4Fsl7CqY1kSfF5905tSksE/gGYx0P1d+aDxCpFio=; b=dE8INfGTJbaMu0hrTC+1laKVhYVbwHYiWa/dQBYmZIZD1j09mSJU4cUU0f2/cfrQQ7 zKEPLDeILDujDH4KqDrh4D7ldCJBJkwXBqgFTUJLd7KncgXpz44aQNMSqe71riS7con3 cD8OwlRdtwIMu4vsqt12uiBrq/dRb8X+hnAk0PcclZDIYPNrzKM75HaymHeMxn56YvyV B37ubKTuFn9hMFKRMNKR+XVnxxgOOXcz7WF7ta9MM0VjL02KNwfJzfSQT/OgUNZv3BXC XN2dMY5u83xQ3cBvLS/7tWgCJQl3cFjQ7+2Z4jy9NE+pcvg4OBC82O2B7yOz66Qv5goh JhuQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=uQJ4Fsl7CqY1kSfF5905tSksE/gGYx0P1d+aDxCpFio=; b=mPfRPfbRAgOLnWne2zXILtXIToUMF9xPi3b3HHzOJzYxG3eltDs/eVG1nK8vgimcB3 1zwsPNqPpOA0ngEOJwluiL3vDgrNLzGe0WXPWa6OYD1f8YTYCRy4m6mym/4NQddSk4P4 B9kLxlpD47kicLyoWtRmgLw7jnVmRkbgzJUO6SA/Z1tbTGjFJcL+9JrGyi3BFUjMpN7Y akpC10k7s8tzUy2jX9R3vQTSG4/sFdcN1Ii7RmfBJdvLBzyxfT7wwBAP26V1K+5CA6WV Y3bdWEXDeHhZSCitq5yE0lqrMiJPe/ds9IRARdCFej67mSLnm6uWUxrNIrXX9XAKma/R IHnA== X-Gm-Message-State: AOAM532rbi0c7uD/Z4iP2R4y7MTAdsyWeXxrdR+bVdjcN6EvtUXDGG40 gvzy86uSY+RHC+TxrTORdCRP8RMC/qY= X-Google-Smtp-Source: ABdhPJwF+ezmDkBeT+GD0ViYp+jnrv51xxijaX1EyCdsOQFaT84aKjfwb88uOIy8XwkjC0/WX9oEDw== X-Received: by 2002:a05:6000:18a3:: with SMTP id b3mr12031963wri.343.1637363026468; Fri, 19 Nov 2021 15:03:46 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id l124sm13916383wml.8.2021.11.19.15.03.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:46 -0800 (PST) Message-Id: <3a2e28275f112d114bbd3ba046f440c5f917fc32.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:28 +0000 Subject: [PATCH v8 01/17] scalar: add a README with a roadmap Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin The Scalar command will be contributed incrementally, over a bunch of patch series. Let's document what Scalar is about, and then describe the patch series that are planned. Signed-off-by: Johannes Schindelin --- contrib/scalar/README.md | 82 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 contrib/scalar/README.md diff --git a/contrib/scalar/README.md b/contrib/scalar/README.md new file mode 100644 index 00000000000..634b5771ed3 --- /dev/null +++ b/contrib/scalar/README.md @@ -0,0 +1,82 @@ +# Scalar - an opinionated repository management tool + +Scalar is an add-on to Git that helps users take advantage of advanced +performance features in Git. Originally implemented in C# using .NET Core, +based on the learnings from the VFS for Git project, most of the techniques +developed by the Scalar project have been integrated into core Git already: + +* partial clone, +* commit graphs, +* multi-pack index, +* sparse checkout (cone mode), +* scheduled background maintenance, +* etc + +This directory contains the remaining parts of Scalar that are not (yet) in +core Git. + +## Roadmap + +The idea is to populate this directory via incremental patch series and +eventually move to a top-level directory next to `gitk-git/` and to `git-gui/`. The +current plan involves the following patch series: + +- `scalar-the-beginning`: The initial patch series which sets up + `contrib/scalar/` and populates it with a minimal `scalar` command that + demonstrates the fundamental ideas. + +- `scalar-c-and-C`: The `scalar` command learns about two options that can be + specified before the command, `-c =` and `-C `. + +- `scalar-diagnose`: The `scalar` command is taught the `diagnose` subcommand. + +- `scalar-and-builtin-fsmonitor`: The built-in FSMonitor is enabled in `scalar + register` and in `scalar clone`, for an enormous performance boost when + working in large worktrees. This patch series necessarily depends on Jeff + Hostetler's FSMonitor patch series to be integrated into Git. + +- `scalar-gentler-config-locking`: Scalar enlistments are registered in the + user's Git config. This usually does not represent any problem because it is + rare for a user to register an enlistment. However, in Scalar's functional + tests, Scalar enlistments are created galore, and in parallel, which can lead + to lock contention. This patch series works around that problem by re-trying + to lock the config file in a gentle fashion. + +- `scalar-extra-docs`: Add some extensive documentation that has been written + in the original Scalar project (all subject to discussion, of course). + +- `optionally-install-scalar`: Now that Scalar is feature (and documentation) + complete and is verified in CI builds, let's offer to install it. + +- `move-scalar-to-toplevel`: Now that Scalar is complete, let's move it next to + `gitk-git/` and to `git-gui/`, making it a top-level command. + +The following two patch series exist in Microsoft's fork of Git and are +publicly available. There is no current plan to upstream them, not because I +want to withhold these patches, but because I don't think the Git community is +interested in these patches. + +There are some interesting ideas there, but the implementation is too specific +to Azure Repos and/or VFS for Git to be of much help in general (and also: my +colleagues tried to upstream some patches already and the enthusiasm for +integrating things related to Azure Repos and VFS for Git can be summarized in +very, very few words). + +These still exist mainly because the GVFS protocol is what Azure Repos has +instead of partial clone, while Git is focused on improving partial clone: + +- `scalar-with-gvfs`: The primary purpose of this patch series is to support + existing Scalar users whose repositories are hosted in Azure Repos (which + does not support Git's partial clones, but supports its predecessor, the GVFS + protocol, which is used by Scalar to emulate the partial clone). + + Since the GVFS protocol will never be supported by core Git, this patch + series will remain in Microsoft's fork of Git. + +- `run-scalar-functional-tests`: The Scalar project developed a quite + comprehensive set of integration tests (or, "Functional Tests"). They are the + sole remaining part of the original C#-based Scalar project, and this patch + adds a GitHub workflow that runs them all. + + Since the tests partially depend on features that are only provided in the + `scalar-with-gvfs` patch series, this patch cannot be upstreamed. From patchwork Fri Nov 19 23:03:29 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629705 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 77033C433FE for ; Fri, 19 Nov 2021 23:03:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234847AbhKSXGx (ORCPT ); Fri, 19 Nov 2021 18:06:53 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35130 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234495AbhKSXGv (ORCPT ); Fri, 19 Nov 2021 18:06:51 -0500 Received: from mail-wr1-x42f.google.com (mail-wr1-x42f.google.com [IPv6:2a00:1450:4864:20::42f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CDF30C061574 for ; Fri, 19 Nov 2021 15:03:48 -0800 (PST) Received: by mail-wr1-x42f.google.com with SMTP id n29so20578597wra.11 for ; Fri, 19 Nov 2021 15:03:48 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=9Ejg+jt4xVscGt18Qdg892vaZletSiZ1QxqdhJa+MTg=; b=P7oOxVZYY80rTWo88YBRJh2GmODqqS3Tvgj+AEMytWDOmN8Je3ou7yvUcH7/L5/Ss2 GRYgSYg2w0Bgxkg/MV9XDsiPPp6wRYpRiw7qUiPY7PWhurJsx7J7kRPM0EnU9rWKKY64 BiCYZgT+DrJ/1OjD/djySOFxsZJlbzJxXcsWtuLWYRTebKChozBOR6bPHlttA6LqYolQ EnDFVqqhtePcRf8iT11xkSp4kJlT6meaJN4WFo3873DSi4Xd4N7BCCZile/3UYLBqNaE kloFnFq3yhHbcEiNWgD79fD2GrY2v0teANt9RkbvtYBqwt7tAP1Kr1O3U99yedsG0FHt ynrw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=9Ejg+jt4xVscGt18Qdg892vaZletSiZ1QxqdhJa+MTg=; b=byXZ9YAwhxK5Z6k5PT+gznQ7wDscmV1m3ImD1hhXgK7jLKjFd/EUKGlUQ9dzqcN1tb +SyFJTJUijqP3prA8HzRT/BLCLbEyTPo8ajzF4sp+Y0vKP2yQvLLa31Y8459xQIbLd1c vd6vq+FYXZSNf0z8ijMO1Y+3m+bcyXI8wpieLzpkLJoScavr8K+fz9ElGAh6fUvo+LVE LO3KHidY3XvnVtMKk1a+q9uuD9ox58Vwnyj7BGuFTsCYRh+k20rRXN6EtgNH9y+rQvDH H0WSEuftjqj7A/4plPZ+KOkzuZ53+8SDJHGFv2cFUeih7/TVi4Oo1PgI6KpEsaqEOisk 32GA== X-Gm-Message-State: AOAM533vKoiNUmvlvSiBll18cDo1Z/ggM0gLh3it0wZH3YAMOX/QOGkL gEGBU3iQhZGnAKhFNyrJYgD41dzlRuQ= X-Google-Smtp-Source: ABdhPJxoBOSAyNuCjXXcAPtHkwYS+4lQO6pBKIj38H7YsN9CgQIPqi1Tn0ekRheNFihRRSQYxHnx9g== X-Received: by 2002:a5d:508d:: with SMTP id a13mr12010032wrt.41.1637363027170; Fri, 19 Nov 2021 15:03:47 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id k27sm16508920wms.41.2021.11.19.15.03.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:46 -0800 (PST) Message-Id: <50160d61a41c182d9b8c6c859975f89415de8482.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:29 +0000 Subject: [PATCH v8 02/17] scalar: create a rudimentary executable Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin The idea of Scalar (https://github.com/microsoft/scalar), and before that, of VFS for Git, has always been to prove that Git _can_ scale, and to upstream whatever strategies have been demonstrated to help. With this patch, we start the journey from that C# project to move what is left to Git's own `contrib/` directory, reimplementing it in pure C, with the intention to facilitate integrating the functionality into core Git all while maintaining backwards-compatibility for existing Scalar users (which will be much easier when both live in the same worktree). It has always been the plan to contribute all of the proven strategies back to core Git. For example, while the virtual filesystem provided by VFS for Git helped the team developing the Windows operating system to move onto Git, while trying to upstream it we realized that it cannot be done: getting the virtual filesystem to work (which we only managed to implement fully on Windows, but not on, say, macOS or Linux), and the required server-side support for the GVFS protocol, made this not quite feasible. The Scalar project learned from that and tackled the problem with different tactics: instead of pretending to Git that the working directory is fully populated, it _specifically_ teaches Git about partial clone (which is based on VFS for Git's cache server), about sparse checkout (which VFS for Git tried to do transparently, in the file system layer), and regularly runs maintenance tasks to keep the repository in a healthy state. With partial clone, sparse checkout and `git maintenance` having been upstreamed, there is little left that `scalar.exe` does which `git.exe` cannot do. One such thing is that `scalar clone ` will automatically set up a partial, sparse clone, and configure known-helpful settings from the start. So let's bring this convenience into Git's tree. The idea here is that you can (optionally) build Scalar via make -C contrib/scalar/ This will build the `scalar` executable and put it into the contrib/scalar/ subdirectory. The slightly awkward addition of the `contrib/scalar/*` bits to the top-level `Makefile` are actually really required: we want to link to `libgit.a`, which means that we will need to use the very same `CFLAGS` and `LDFLAGS` as the rest of Git. An early development version of this patch tried to replicate all the conditional code in `contrib/scalar/Makefile` (e.g. `NO_POLL`) just like `contrib/svn-fe/Makefile` used to do before it was retired. It turned out to be quite the whack-a-mole game: the SHA-1-related flags, the flags enabling/disabling `compat/poll/`, `compat/regex/`, `compat/win32mmap.c` & friends depending on the current platform... To put it mildly: it was a major mess. Instead, this patch makes minimal changes to the top-level `Makefile` so that the bits in `contrib/scalar/` can be compiled and linked, and adds a `contrib/scalar/Makefile` that uses the top-level `Makefile` in a most minimal way to do the actual compiling. Note: With this commit, we only establish the infrastructure, no Scalar functionality is implemented yet; We will do that incrementally over the next few commits. Signed-off-by: Johannes Schindelin --- Makefile | 9 +++++++++ contrib/scalar/.gitignore | 2 ++ contrib/scalar/Makefile | 34 ++++++++++++++++++++++++++++++++++ contrib/scalar/scalar.c | 36 ++++++++++++++++++++++++++++++++++++ 4 files changed, 81 insertions(+) create mode 100644 contrib/scalar/.gitignore create mode 100644 contrib/scalar/Makefile create mode 100644 contrib/scalar/scalar.c diff --git a/Makefile b/Makefile index 12be39ac497..fe898aeea08 100644 --- a/Makefile +++ b/Makefile @@ -2456,6 +2456,11 @@ OBJECTS += $(FUZZ_OBJS) ifndef NO_CURL OBJECTS += http.o http-walker.o remote-curl.o endif + +SCALAR_SOURCES := contrib/scalar/scalar.c +SCALAR_OBJECTS := $(SCALAR_SOURCES:c=o) +OBJECTS += $(SCALAR_OBJECTS) + .PHONY: objects objects: $(OBJECTS) @@ -2589,6 +2594,10 @@ $(REMOTE_CURL_PRIMARY): remote-curl.o http.o http-walker.o GIT-LDFLAGS $(GITLIBS $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \ $(CURL_LIBCURL) $(EXPAT_LIBEXPAT) $(LIBS) +contrib/scalar/scalar$X: $(SCALAR_OBJECTS) GIT-LDFLAGS $(GITLIBS) + $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) \ + $(filter %.o,$^) $(LIBS) + $(LIB_FILE): $(LIB_OBJS) $(QUIET_AR)$(RM) $@ && $(AR) $(ARFLAGS) $@ $^ diff --git a/contrib/scalar/.gitignore b/contrib/scalar/.gitignore new file mode 100644 index 00000000000..ff3d47e84d0 --- /dev/null +++ b/contrib/scalar/.gitignore @@ -0,0 +1,2 @@ +/*.exe +/scalar diff --git a/contrib/scalar/Makefile b/contrib/scalar/Makefile new file mode 100644 index 00000000000..f6f0036f0fa --- /dev/null +++ b/contrib/scalar/Makefile @@ -0,0 +1,34 @@ +QUIET_SUBDIR0 = +$(MAKE) -C # space to separate -C and subdir +QUIET_SUBDIR1 = + +ifneq ($(findstring s,$(MAKEFLAGS)),s) +ifndef V + QUIET_SUBDIR0 = +@subdir= + QUIET_SUBDIR1 = ;$(NO_SUBDIR) echo ' ' SUBDIR $$subdir; \ + $(MAKE) $(PRINT_DIR) -C $$subdir +else + export V +endif +endif + +all: + +include ../../config.mak.uname +-include ../../config.mak.autogen +-include ../../config.mak + +TARGETS = scalar$(X) scalar.o +GITLIBS = ../../common-main.o ../../libgit.a ../../xdiff/lib.a + +all: scalar$(X) + +$(GITLIBS): + $(QUIET_SUBDIR0)../.. $(QUIET_SUBDIR1) $(subst ../../,,$@) + +$(TARGETS): $(GITLIBS) scalar.c + $(QUIET_SUBDIR0)../.. $(QUIET_SUBDIR1) $(patsubst %,contrib/scalar/%,$@) + +clean: + $(RM) $(TARGETS) + +.PHONY: $(GITLIBS) all clean FORCE diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c new file mode 100644 index 00000000000..7cff29e0fcd --- /dev/null +++ b/contrib/scalar/scalar.c @@ -0,0 +1,36 @@ +/* + * The Scalar command-line interface. + */ + +#include "cache.h" +#include "gettext.h" +#include "parse-options.h" + +static struct { + const char *name; + int (*fn)(int, const char **); +} builtins[] = { + { NULL, NULL}, +}; + +int cmd_main(int argc, const char **argv) +{ + struct strbuf scalar_usage = STRBUF_INIT; + int i; + + if (argc > 1) { + argv++; + argc--; + + for (i = 0; builtins[i].name; i++) + if (!strcmp(builtins[i].name, argv[0])) + return !!builtins[i].fn(argc, argv); + } + + strbuf_addstr(&scalar_usage, + N_("scalar []\n\nCommands:\n")); + for (i = 0; builtins[i].name; i++) + strbuf_addf(&scalar_usage, "\t%s\n", builtins[i].name); + + usage(scalar_usage.buf); +} From patchwork Fri Nov 19 23:03:30 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629707 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0E500C433EF for ; Fri, 19 Nov 2021 23:03:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234888AbhKSXGy (ORCPT ); Fri, 19 Nov 2021 18:06:54 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35134 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233493AbhKSXGw (ORCPT ); Fri, 19 Nov 2021 18:06:52 -0500 Received: from mail-wr1-x42c.google.com (mail-wr1-x42c.google.com [IPv6:2a00:1450:4864:20::42c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7DBFAC061574 for ; Fri, 19 Nov 2021 15:03:49 -0800 (PST) Received: by mail-wr1-x42c.google.com with SMTP id d27so20653846wrb.6 for ; Fri, 19 Nov 2021 15:03:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=8D4/O9BIeJDyx7UkKc8qSSrWGbYPXQcqw1HfHqLPa9c=; b=AvxgtVriyR3+KN9ApzI6rc5OUAHCzJuv1MVG/m/G2aZVhev03PUlSp2IfJDB0Rljs5 BkXiX1/mBLssrHW7oqm0BVqk/ZiHe5yvf4MJaXpRzolSBgNQFUuPBtqxkdGoUZXPbKmp ry6q1pUyzcHWM8TZOjeJdCbVcLrpGInC/B+e5zD2TID8I6n6Uzh+4ppr9pMcTKgiFxv+ sfL0NbYqb+buJoEV7v1qBwIYEuppNyQosWqrEw+ivUKUmDD2eM5QvaHzs2ZNFSsBl4FQ W0fwmuHWn+AWpwmgxqdE+qHSM4pyPVhQrZPQDkw8ZhJ5+B7BsvomV4zVI5KmXfdeLAZ7 LnaA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=8D4/O9BIeJDyx7UkKc8qSSrWGbYPXQcqw1HfHqLPa9c=; b=OUPEs2YR9YbypPrd7NW9E1MICyW26KMWr1rcuwi4cwMrQl4tuzLHYNotBxZKRTJ2ni ADxbWL0nsDmG7MphxXrwZ+9KV1BbINvQAY+CWxOFhCjL28qXQNAaRf4QasnEM4rmQ+GD GL7+wCjYV5BPgoR3ARM2Qjf6tyzNs8Gb1VMx7x9ObqKo7XVSEl8KQRy6Co13OD5AQLRm Qa3Fy0/aE4UzJVI01prxPO9KKWp7t4uAVRK5zHnurDke2iMMu4aiax6goIHkqtuE1IzT 26gD69241iNeefO1bq4J9M4XRBDmTU1933BUe+Jmmna8gQdt0N3R50JXkz2RrdMbRTPu UctQ== X-Gm-Message-State: AOAM533gOBPfmlpRlmG3DIXerH/DinJmkIlYIbqR+y2dX2xqE9PM0+zJ WLogPEI0pLvAT/sjwJsM+zdZolHGpIU= X-Google-Smtp-Source: ABdhPJyX2BCCwTbI+iyUL7QRVzYc3FFuvJU8QIUtodpSvuqwRZbskmzdU1iAxDVIgESTsmRVqNKyBA== X-Received: by 2002:adf:cd04:: with SMTP id w4mr11833344wrm.406.1637363027926; Fri, 19 Nov 2021 15:03:47 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id z11sm977367wrt.58.2021.11.19.15.03.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:47 -0800 (PST) Message-Id: <74cd64109319748e532339017b3b76a4823f9c86.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:30 +0000 Subject: [PATCH v8 03/17] scalar: start documenting the command Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin Let's build up the documentation for the Scalar command along with the patches that implement its functionality. Note: To discourage the feature-incomplete documentation from being mistaken for the complete thing, we do not yet provide any way to build HTML or manual pages from the text file. Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.txt | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 contrib/scalar/scalar.txt diff --git a/contrib/scalar/scalar.txt b/contrib/scalar/scalar.txt new file mode 100644 index 00000000000..5f7131861a5 --- /dev/null +++ b/contrib/scalar/scalar.txt @@ -0,0 +1,38 @@ +scalar(1) +========= + +NAME +---- +scalar - an opinionated repository management tool + +SYNOPSIS +-------- +[verse] +scalar [] + +DESCRIPTION +----------- + +Scalar is an opinionated repository management tool. By creating new +repositories or registering existing repositories with Scalar, your Git +experience will speed up. Scalar sets advanced Git config settings, +maintains your repositories in the background, and helps reduce data sent +across the network. + +An important Scalar concept is the enlistment: this is the top-level directory +of the project. It usually contains the subdirectory `src/` which is a Git +worktree. This encourages the separation between tracked files (inside `src/`) +and untracked files, such as build artifacts (outside `src/`). When registering +an existing Git worktree with Scalar whose name is not `src`, the enlistment +will be identical to the worktree. + +The `scalar` command implements various subcommands, and different options +depending on the subcommand. + +SEE ALSO +-------- +linkgit:git-maintenance[1]. + +Scalar +--- +Associated with the linkgit:git[1] suite From patchwork Fri Nov 19 23:03:31 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629709 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B9411C4332F for ; Fri, 19 Nov 2021 23:03:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234991AbhKSXGz (ORCPT ); Fri, 19 Nov 2021 18:06:55 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35140 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234599AbhKSXGw (ORCPT ); Fri, 19 Nov 2021 18:06:52 -0500 Received: from mail-wm1-x329.google.com (mail-wm1-x329.google.com [IPv6:2a00:1450:4864:20::329]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1FF8AC06173E for ; Fri, 19 Nov 2021 15:03:50 -0800 (PST) Received: by mail-wm1-x329.google.com with SMTP id 133so9869188wme.0 for ; Fri, 19 Nov 2021 15:03:50 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=urTN5i86EXuc5a/mSz2OtPkPDT42VYR77j7zOne496I=; b=LexhkXgm50fend/Ph6eoVGUI823f/jhFX0Kn5u1JUgocnUUAhlnj5tr2h7s9DlAHTI FCSwC24I1IbvXUHDdlJjv7J/rKJ+2NL2VKLV3y0I+Dmaj1zAqU6dL1nB7YjmllLxaUcK l8UsZujWYegAKl+JPq3CjO3K0SxONFTTLCqqmsXIUsDxF8t6kv1owVdBpMVNBwoTWHwH Px+2JSYb1v/BdVblxb2QGitp3r7SlBSCjPT8oEQ0MkQcsxzbElNsKVBTSb2rPa5EnNNx 2QiP11J8e1eCp47fCHeYbNP0Y9SnzbTgVbpkaWPSCdB9GDbwYdS/3sIhl91wK3egJ+ff A/Xg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=urTN5i86EXuc5a/mSz2OtPkPDT42VYR77j7zOne496I=; b=cNeiDnGsbOLWFDEQhrvSPdcruSdPGeVHb8BL/dWtrjGAXHHbXsFV3bJwOV232uvHzz QDElLlNL3MFT8YMkDmBxP7lS/Wo8O8DsSIIsXvXZSBxljn8r5EeYhMGadNq7j1+lS9/g uA+hm024orkQLwrxHQV1ZjuIxnmoJnP8KbjAvJUuPaMtk/w7NE/RBXgD81joJkbqY0NJ 5TCp4JfjASBR6X+tHvwTHVBBQbDCoaSMizLV4MBeU0NkqIoYDFINxyCTs1l3+gCsSWBF Y1uB1XuPwPK+Chq1X7nZaHOxY6To2e9bJg991C9rfybOQkm8xa5Bisw64aU02Ak3jrbq Havg== X-Gm-Message-State: AOAM531FqXm/gYQG0N0oF86FNLeqVzRRX+RfTTrZqLCJCundWcyIiWWD lcmob03njumF6yu+Er1iTMBE1K7cBus= X-Google-Smtp-Source: ABdhPJxmwhb4JDtcP0T6ESahbYoGcAWrXt5iKSOFoQ4H1gCJz/IAUSEG5Ah+6i658f+jE82EmnFGWg== X-Received: by 2002:a05:600c:2149:: with SMTP id v9mr4382589wml.59.1637363028529; Fri, 19 Nov 2021 15:03:48 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id m125sm13267235wmm.39.2021.11.19.15.03.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:48 -0800 (PST) Message-Id: <37231a4dd07833807639c8a650185569d0c99af2.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:31 +0000 Subject: [PATCH v8 04/17] scalar: create test infrastructure Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin To test the Scalar command, create a test script in contrib/scalar/t that is executed as `make -C contrib/scalar test`. Since Scalar has no meaningful capabilities yet, the only test is rather simple. We will add more tests in subsequent commits that introduce corresponding, new functionality. Note: This test script is intended to test `scalar` only lightly, even after all of the functionality is implemented. A more comprehensive functional (or: integration) test suite can be found at https://github.com/microsoft/scalar; It is used in the workflow https://github.com/microsoft/git/blob/HEAD/.github/workflows/scalar-functional-tests.yml in Microsoft's Git fork. This test suite performs end-to-end tests with a real remote repository, and is run as part of the regular CI and PR builds in that fork. Since those tests require some functionality supported only by Microsoft's Git fork ("GVFS protocol"), there is no intention to port that fuller test suite to `contrib/scalar/`. Signed-off-by: Johannes Schindelin --- contrib/scalar/Makefile | 17 +++++-- contrib/scalar/t/Makefile | 78 ++++++++++++++++++++++++++++++++ contrib/scalar/t/t9099-scalar.sh | 17 +++++++ 3 files changed, 109 insertions(+), 3 deletions(-) create mode 100644 contrib/scalar/t/Makefile create mode 100755 contrib/scalar/t/t9099-scalar.sh diff --git a/contrib/scalar/Makefile b/contrib/scalar/Makefile index f6f0036f0fa..231b1ee1796 100644 --- a/contrib/scalar/Makefile +++ b/contrib/scalar/Makefile @@ -3,6 +3,7 @@ QUIET_SUBDIR1 = ifneq ($(findstring s,$(MAKEFLAGS)),s) ifndef V + QUIET_GEN = @echo ' ' GEN $@; QUIET_SUBDIR0 = +@subdir= QUIET_SUBDIR1 = ;$(NO_SUBDIR) echo ' ' SUBDIR $$subdir; \ $(MAKE) $(PRINT_DIR) -C $$subdir @@ -20,7 +21,7 @@ include ../../config.mak.uname TARGETS = scalar$(X) scalar.o GITLIBS = ../../common-main.o ../../libgit.a ../../xdiff/lib.a -all: scalar$(X) +all: scalar$(X) ../../bin-wrappers/scalar $(GITLIBS): $(QUIET_SUBDIR0)../.. $(QUIET_SUBDIR1) $(subst ../../,,$@) @@ -29,6 +30,16 @@ $(TARGETS): $(GITLIBS) scalar.c $(QUIET_SUBDIR0)../.. $(QUIET_SUBDIR1) $(patsubst %,contrib/scalar/%,$@) clean: - $(RM) $(TARGETS) + $(RM) $(TARGETS) ../../bin-wrappers/scalar -.PHONY: $(GITLIBS) all clean FORCE +../../bin-wrappers/scalar: ../../wrap-for-bin.sh Makefile + @mkdir -p ../../bin-wrappers + $(QUIET_GEN)sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \ + -e 's|@@BUILD_DIR@@|$(shell cd ../.. && pwd)|' \ + -e 's|@@PROG@@|contrib/scalar/scalar$(X)|' < $< > $@ && \ + chmod +x $@ + +test: all + $(MAKE) -C t + +.PHONY: $(GITLIBS) all clean test FORCE diff --git a/contrib/scalar/t/Makefile b/contrib/scalar/t/Makefile new file mode 100644 index 00000000000..6170672bb37 --- /dev/null +++ b/contrib/scalar/t/Makefile @@ -0,0 +1,78 @@ +# Run scalar tests +# +# Copyright (c) 2005,2021 Junio C Hamano, Johannes Schindelin +# + +-include ../../../config.mak.autogen +-include ../../../config.mak + +SHELL_PATH ?= $(SHELL) +PERL_PATH ?= /usr/bin/perl +RM ?= rm -f +PROVE ?= prove +DEFAULT_TEST_TARGET ?= test +TEST_LINT ?= test-lint + +ifdef TEST_OUTPUT_DIRECTORY +TEST_RESULTS_DIRECTORY = $(TEST_OUTPUT_DIRECTORY)/test-results +else +TEST_RESULTS_DIRECTORY = ../../../t/test-results +endif + +# Shell quote; +SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH)) +PERL_PATH_SQ = $(subst ','\'',$(PERL_PATH)) +TEST_RESULTS_DIRECTORY_SQ = $(subst ','\'',$(TEST_RESULTS_DIRECTORY)) + +T = $(sort $(wildcard t[0-9][0-9][0-9][0-9]-*.sh)) + +all: $(DEFAULT_TEST_TARGET) + +test: $(TEST_LINT) + $(MAKE) aggregate-results-and-cleanup + +prove: $(TEST_LINT) + @echo "*** prove ***"; GIT_CONFIG=.git/config $(PROVE) --exec '$(SHELL_PATH_SQ)' $(GIT_PROVE_OPTS) $(T) :: $(GIT_TEST_OPTS) + $(MAKE) clean-except-prove-cache + +$(T): + @echo "*** $@ ***"; GIT_CONFIG=.git/config '$(SHELL_PATH_SQ)' $@ $(GIT_TEST_OPTS) + +clean-except-prove-cache: + $(RM) -r 'trash directory'.* '$(TEST_RESULTS_DIRECTORY_SQ)' + $(RM) -r valgrind/bin + +clean: clean-except-prove-cache + $(RM) .prove + +test-lint: test-lint-duplicates test-lint-executable test-lint-shell-syntax + +test-lint-duplicates: + @dups=`echo $(T) | tr ' ' '\n' | sed 's/-.*//' | sort | uniq -d` && \ + test -z "$$dups" || { \ + echo >&2 "duplicate test numbers:" $$dups; exit 1; } + +test-lint-executable: + @bad=`for i in $(T); do test -x "$$i" || echo $$i; done` && \ + test -z "$$bad" || { \ + echo >&2 "non-executable tests:" $$bad; exit 1; } + +test-lint-shell-syntax: + @'$(PERL_PATH_SQ)' ../../../t/check-non-portable-shell.pl $(T) + +aggregate-results-and-cleanup: $(T) + $(MAKE) aggregate-results + $(MAKE) clean + +aggregate-results: + for f in '$(TEST_RESULTS_DIRECTORY_SQ)'/t*-*.counts; do \ + echo "$$f"; \ + done | '$(SHELL_PATH_SQ)' ../../../t/aggregate-results.sh + +valgrind: + $(MAKE) GIT_TEST_OPTS="$(GIT_TEST_OPTS) --valgrind" + +test-results: + mkdir -p test-results + +.PHONY: $(T) aggregate-results clean valgrind diff --git a/contrib/scalar/t/t9099-scalar.sh b/contrib/scalar/t/t9099-scalar.sh new file mode 100755 index 00000000000..16f2b72b126 --- /dev/null +++ b/contrib/scalar/t/t9099-scalar.sh @@ -0,0 +1,17 @@ +#!/bin/sh + +test_description='test the `scalar` command' + +TEST_DIRECTORY=$PWD/../../../t +export TEST_DIRECTORY + +# Make it work with --no-bin-wrappers +PATH=$PWD/..:$PATH + +. ../../../t/test-lib.sh + +test_expect_success 'scalar shows a usage' ' + test_expect_code 129 scalar -h +' + +test_done From patchwork Fri Nov 19 23:03:32 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629711 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CD8ADC433EF for ; Fri, 19 Nov 2021 23:03:54 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235003AbhKSXG4 (ORCPT ); Fri, 19 Nov 2021 18:06:56 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35142 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234628AbhKSXGx (ORCPT ); Fri, 19 Nov 2021 18:06:53 -0500 Received: from mail-wr1-x42f.google.com (mail-wr1-x42f.google.com [IPv6:2a00:1450:4864:20::42f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id BE13EC061748 for ; Fri, 19 Nov 2021 15:03:50 -0800 (PST) Received: by mail-wr1-x42f.google.com with SMTP id a9so20634531wrr.8 for ; Fri, 19 Nov 2021 15:03:50 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=L9faUOUIjPF+NLN+ELTzI5NereQrkPug1GdsWQHqOzk=; b=T0F3DU821tppgYRJeM6hJlUvR8nx4a9ErAKpl6K/kg5U4/9N9/ZHIOO29O7RGeKViL U1S7p+4ETwBBbbLxooHAuS8caSAliLqW9rPLq0IjBD3ph8R+l3u2cmFE/jeuxRNqWtXL 7Lp1kGJKSeveWJcTZwmBFXaN5WRNCBfc/VZ97NzZibrjKUgmNEyEF6JyD+7NujChZB/p zOZpGP/SZpyWakSX12XSpC4vER03A67FRtT5DwoLqnpPjMerMoB6z9M1LVr/7eMkq9vJ bC6QkIJfCgjh9gzsRq1dBBOURm8p4IdWY1/c1qji11r93QmaWluei+/OoS7L1joag7Kn qoBw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=L9faUOUIjPF+NLN+ELTzI5NereQrkPug1GdsWQHqOzk=; b=WbozHxmfF56birBVwfVP96XXF36W0f24B8I/kWMH2QZReweKbKPaPbADu+/xYMiYH9 R5+4/vAP/71IQs8n1fwqZnwhK81HoIeGL0o7u7HW1I2AJ63Q0i5JygwKbrXXBJFgSZ8o CjPUJZXMIuQUVL1c/MmBvzkX/z3j/eilKqgRQSJsM9r8oSSfxmjpo3KRKTCZX2zNemFX 8J7mGhukbjrbhuCYfHRjMi2HaN1h6/RSskCjP6PkAxkIPLDeW8NMmhOtbyCFgNGnK7hp EQ6ZIytFcM01KOYMu8KOCoIfzbrdZdJ27xbPnmZIAbW0RJX1ZRpZplUhODz0KJGPBhJK RuFQ== X-Gm-Message-State: AOAM533GAWcIGoiKMBNYOJoDRRuyzMvcgAV10RWV6slWhALV7tGhZMSa 8wlTtwuq0vCoVN8pv+97Db7l2HnT4Io= X-Google-Smtp-Source: ABdhPJw3mzKyWXM31vspELa0PejOmkEwAxvc3awBQt3z99noTWIFOidA7enUK9VVvcunKvqZrsNFoQ== X-Received: by 2002:a5d:4904:: with SMTP id x4mr12584832wrq.139.1637363029252; Fri, 19 Nov 2021 15:03:49 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id 138sm8573759wma.17.2021.11.19.15.03.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:48 -0800 (PST) Message-Id: In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:32 +0000 Subject: [PATCH v8 05/17] cmake: optionally build `scalar`, too Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin The CMake configuration unfortunately does not let us easily encapsulate Scalar's build definition in the `contrib/scalar/` subdirectory: The `scalar` executable needs to link in `libgit.a` and `common-main.o`, for example. Also, `scalar.c` includes Git's header files, which means that `scalar.c` needs to be compiled with the very same flags as `libgit.a` lest `scalar.o` and `libgit.a` have different ideas of, say, `platform_SHA_CTX`, which would naturally lead to memory corruption. To alleviate that somewhat, we guard the inclusion of Scalar via the `INCLUDE_SCALAR` environment variable. Signed-off-by: Johannes Schindelin --- contrib/buildsystems/CMakeLists.txt | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/contrib/buildsystems/CMakeLists.txt b/contrib/buildsystems/CMakeLists.txt index fd1399c440f..dd7496b0322 100644 --- a/contrib/buildsystems/CMakeLists.txt +++ b/contrib/buildsystems/CMakeLists.txt @@ -729,6 +729,13 @@ if(CURL_FOUND) endif() endif() +if(DEFINED ENV{INCLUDE_SCALAR} AND NOT ENV{INCLUDE_SCALAR} STREQUAL "") + add_executable(scalar ${CMAKE_SOURCE_DIR}/contrib/scalar/scalar.c) + target_link_libraries(scalar common-main) + set_target_properties(scalar PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/contrib/scalar) + set_target_properties(scalar PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/contrib/scalar) +endif() + parse_makefile_for_executables(git_builtin_extra "BUILT_INS") option(SKIP_DASHED_BUILT_INS "Skip hardlinking the dashed versions of the built-ins") @@ -953,6 +960,13 @@ string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}") string(REPLACE "@@PROG@@" "git-cvsserver" content "${content}") file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/git-cvsserver ${content}) +if(DEFINED ENV{INCLUDE_SCALAR} AND NOT ENV{INCLUDE_SCALAR} STREQUAL "") + file(STRINGS ${CMAKE_SOURCE_DIR}/wrap-for-bin.sh content NEWLINE_CONSUME) + string(REPLACE "@@BUILD_DIR@@" "${CMAKE_BINARY_DIR}" content "${content}") + string(REPLACE "@@PROG@@" "contrib/scalar/scalar${EXE_EXTENSION}" content "${content}") + file(WRITE ${CMAKE_BINARY_DIR}/bin-wrappers/scalar ${content}) +endif() + #options for configuring test options option(PERL_TESTS "Perform tests that use perl" ON) option(PYTHON_TESTS "Perform tests that use python" ON) From patchwork Fri Nov 19 23:03:33 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629713 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0EFA2C433F5 for ; Fri, 19 Nov 2021 23:03:56 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235126AbhKSXG4 (ORCPT ); Fri, 19 Nov 2021 18:06:56 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35150 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234878AbhKSXGx (ORCPT ); Fri, 19 Nov 2021 18:06:53 -0500 Received: from mail-wm1-x331.google.com (mail-wm1-x331.google.com [IPv6:2a00:1450:4864:20::331]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 60A71C061757 for ; Fri, 19 Nov 2021 15:03:51 -0800 (PST) Received: by mail-wm1-x331.google.com with SMTP id i12so9825157wmq.4 for ; Fri, 19 Nov 2021 15:03:51 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=YGW/Iv+hj4Jo4PNf8rajEZsMbDt9HNnlI+ygkUeyL4U=; b=DcJgXc3kFKlce8NbkZOilh6ilbmtAJKYpD3xU/7mYaul9vtEJXzOIqjyQXpzYy9Yts mMQ9oF+Rjlg5Gr87UhNA+OtiYg8TCpSOsCsgpHM9EzafBxhF4ZPhx+CPwOGCZjNbS8ME Pf2s2McLCwmUMxqhxDyyvFEzhYXksUewdSiH6iICpiUmOX/2hJElzdD2RWfXzYQUEl9J W29cUDcvys8fYUgyFTpqOJT+Cs4NyPqx8IhivQQtuVWeZQv4Dnx8Qg5p4LeFsDFoOGPN wIUjq0ewMCVQT3xMu11Yh98taYxqjVZJk1YU/s9m277d/Uz9GhUtTGYZP8FSwF+TwkxY v13Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=YGW/Iv+hj4Jo4PNf8rajEZsMbDt9HNnlI+ygkUeyL4U=; b=7GK0R/yifbZipN0kO3VMjNBPi2yhwP+eVyUy/w+VLI0Q9aI6dm/wY1Buovjfb9rpaS zrX9fdwE+92eOXJEi2E9foLdHhB8Fk2reDit58+SfW1RkOwybfOUMfqJ2otdJZMtQ/3r 0/bzXyNrz1sLX+RBK7cSm+/jZpU8EMYJgriNUf3LdNXwkJVfOZUoTB+CHFa5hT/ojjkx D1BtrFhy94oKtmfWX+MMD5ZS6ccT1CuazLl4sjZun6j52mYDRv8XtGN4S8dlAUqnJurc q20SmVWE4T3QomYh+4qPjLOfYvsowZ1m1wTOhU9ETRf0M+eLWTE6YLrKevpPazTyQeMM G8eQ== X-Gm-Message-State: AOAM5316ivYaKWNGF3c7Z/Q5cHeuTPcqnDYPMQQckn0TatU4kFC9gPBL mH0oh/fZ6NKUXpJPZ1sEggylvk7toYM= X-Google-Smtp-Source: ABdhPJy+9J45ErbGMxa6Q4nUVh0XmrpKY/F0DNYxzna86jvIZBorVbX5ipb4LKL048anV+6Ek+dtLA== X-Received: by 2002:a05:600c:1e8d:: with SMTP id be13mr4234931wmb.79.1637363029807; Fri, 19 Nov 2021 15:03:49 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id s13sm13905079wmc.47.2021.11.19.15.03.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:49 -0800 (PST) Message-Id: <8e3542e43f7507282672dc8d0926ac1cc44b335a.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:33 +0000 Subject: [PATCH v8 06/17] ci: also run the `scalar` tests Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin Since Scalar depends on `libgit.a`, it makes sense to ensure in the CI and the PR builds that it does not get broken in case of industrious refactorings of the core Git code. Signed-off-by: Johannes Schindelin --- .github/workflows/main.yml | 15 +++++++++++++++ ci/run-build-and-tests.sh | 1 + ci/run-test-slice.sh | 5 +++++ 3 files changed, 21 insertions(+) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 6ed6a9e8076..6eda6be895d 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -89,6 +89,13 @@ jobs: HOME: ${{runner.workspace}} NO_PERL: 1 run: . /etc/profile && ci/make-test-artifacts.sh artifacts + - name: build Scalar + shell: bash + run: | + make -C contrib/scalar && + mkdir -p artifacts/bin-wrappers artifacts/contrib/scalar && + cp contrib/scalar/scalar.exe artifacts/contrib/scalar/ && + cp bin-wrappers/scalar artifacts/bin-wrappers/ - name: zip up tracked files run: git archive -o artifacts/tracked.tar.gz HEAD - name: upload tracked files and build artifacts @@ -157,6 +164,8 @@ jobs: run: compat\vcbuild\vcpkg_copy_dlls.bat release - name: generate Visual Studio solution shell: bash + env: + INCLUDE_SCALAR: YesPlease run: | cmake `pwd`/contrib/buildsystems/ -DCMAKE_PREFIX_PATH=`pwd`/compat/vcbuild/vcpkg/installed/x64-windows \ -DNO_GETTEXT=YesPlease -DPERL_TESTS=OFF -DPYTHON_TESTS=OFF -DCURL_NO_CURL_CMAKE=ON @@ -170,6 +179,12 @@ jobs: run: | mkdir -p artifacts && eval "$(make -n artifacts-tar INCLUDE_DLLS_IN_ARTIFACTS=YesPlease ARTIFACTS_DIRECTORY=artifacts NO_GETTEXT=YesPlease 2>&1 | grep ^tar)" + - name: copy Scalar + shell: bash + run: | + mkdir -p artifacts/bin-wrappers artifacts/contrib/scalar && + cp contrib/scalar/scalar.exe artifacts/contrib/scalar/ && + cp bin-wrappers/scalar artifacts/bin-wrappers/ - name: zip up tracked files run: git archive -o artifacts/tracked.tar.gz HEAD - name: upload tracked files and build artifacts diff --git a/ci/run-build-and-tests.sh b/ci/run-build-and-tests.sh index cc62616d806..07cedd25ff1 100755 --- a/ci/run-build-and-tests.sh +++ b/ci/run-build-and-tests.sh @@ -49,6 +49,7 @@ linux-gcc-4.8|pedantic) make test ;; esac +make -C contrib/scalar test check_unignored_build_artifacts diff --git a/ci/run-test-slice.sh b/ci/run-test-slice.sh index f8c2c3106a2..b741fd8f361 100755 --- a/ci/run-test-slice.sh +++ b/ci/run-test-slice.sh @@ -14,4 +14,9 @@ make --quiet -C t T="$(cd t && ./helper/test-tool path-utils slice-tests "$1" "$2" t[0-9]*.sh | tr '\n' ' ')" +if test 0 = "$1" +then + make -C contrib/scalar test +fi + check_unignored_build_artifacts From patchwork Fri Nov 19 23:03:34 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Derrick Stolee X-Patchwork-Id: 12629715 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3DE14C433EF for ; Fri, 19 Nov 2021 23:03:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234676AbhKSXG6 (ORCPT ); Fri, 19 Nov 2021 18:06:58 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35158 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234827AbhKSXGy (ORCPT ); Fri, 19 Nov 2021 18:06:54 -0500 Received: from mail-wr1-x432.google.com (mail-wr1-x432.google.com [IPv6:2a00:1450:4864:20::432]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2917CC061574 for ; Fri, 19 Nov 2021 15:03:52 -0800 (PST) Received: by mail-wr1-x432.google.com with SMTP id t30so20574854wra.10 for ; Fri, 19 Nov 2021 15:03:52 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=JfgQPeGK48E/0q8Fkiq5e3N8uuCWy/bAHbpQUBIoNJs=; b=Szu2XeM8DNmMMesTLRZPy/19Num6z1rfxroH0RptBwxRPFKb5nwYS0sJqIa7v04H+8 1EccGydvvUmhlu8slNEU6uDXtJhyy90wo2r2TSgJy2Y2F8li49LddzIY9kmuRoC9uXkB EzuJ83dQW7RKb94g90l9uOz5fBtF+kOrkjuDVJUVdCGiO8pqEC5GFWexOLif/t5foqHq VEHQnEAGlPmgwclngyU52cFW9+gIO3/B7DOweIb7j8SbP8Ezx2ppLdfSxC9NDeDsWLno YKKi7CzXf4aKUIixUvwBFUSNSl3l8m1KI7RWl2jRjiAm/qHA9BMO5dhle4gxq8BvrxyI UgLQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=JfgQPeGK48E/0q8Fkiq5e3N8uuCWy/bAHbpQUBIoNJs=; b=IoAYLSfAF6WlmM+OBhg+Sfgh4InwECqUd/zRVMtcYUFAHORtnvzqA1Nox22t3b5u5X DBGtlZ3YY/5D02GwqAVeDoeHwmJjvixjgBMvqih06lg529PxBPLrhnKXqU5o58vf5iyJ OdTVHCrAwEa+xw0Aapa5OpheCfZGFj0QBcE0+8U9TL4zhKcOOqW7XGefcegzwP4y5nJo UQYF4eW1BwJ0X3YcogSrPyHotGh3hj+EYS1LXs6z7M6LIhzzUVlt+KtbnHgxmNksElWJ z84ShtauefI2/+PqpCxMOv/xczFJ751KtL3wGoaLP6HLuy49VyUD4b5OFPAlYPaSoG18 nCKg== X-Gm-Message-State: AOAM5309cfIwFAeuCp4GxFLjnzlDJ3a1qdF9o3rKugHrrRX223Z1TxP+ 61dz1io3KGq20A/QEVkCyGZl6ZqPlr0= X-Google-Smtp-Source: ABdhPJyypHjzolFMU3S4LNPWxiPNrzSSJ77xhHzqvfGEPQLKmQ3ABpm1GBaSeh75YGAJPeWDpoT2jw== X-Received: by 2002:a5d:64af:: with SMTP id m15mr12271844wrp.267.1637363030475; Fri, 19 Nov 2021 15:03:50 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id l5sm1210624wrs.59.2021.11.19.15.03.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:50 -0800 (PST) Message-Id: <385abdb8d8e4743a16d6a1dc38737322354560d5.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:34 +0000 Subject: [PATCH v8 07/17] scalar: 'register' sets recommended config and starts maintenance Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Derrick Stolee Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Derrick Stolee From: Derrick Stolee Let's start implementing the `register` command. With this commit, recommended settings are configured upon `scalar register`, and Git's background maintenance is started. The recommended config settings may very well change in the future. For example, once the built-in FSMonitor is available, we will want to enable it upon `scalar register`. For that reason, we explicitly support running `scalar register` in an already-registered enlistment. Co-authored-by: Victoria Dye Signed-off-by: Derrick Stolee Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 249 ++++++++++++++++++++++++++++++++++++++ contrib/scalar/scalar.txt | 18 ++- 2 files changed, 266 insertions(+), 1 deletion(-) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index 7cff29e0fcd..03d5f84c764 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -5,11 +5,260 @@ #include "cache.h" #include "gettext.h" #include "parse-options.h" +#include "config.h" +#include "run-command.h" + +/* + * Remove the deepest subdirectory in the provided path string. Path must not + * include a trailing path separator. Returns 1 if parent directory found, + * otherwise 0. + */ +static int strbuf_parent_directory(struct strbuf *buf) +{ + size_t len = buf->len; + size_t offset = offset_1st_component(buf->buf); + char *path_sep = find_last_dir_sep(buf->buf + offset); + strbuf_setlen(buf, path_sep ? path_sep - buf->buf : offset); + + return buf->len < len; +} + +static void setup_enlistment_directory(int argc, const char **argv, + const char * const *usagestr, + const struct option *options, + struct strbuf *enlistment_root) +{ + struct strbuf path = STRBUF_INIT; + char *root; + int enlistment_found = 0; + + if (startup_info->have_repository) + BUG("gitdir already set up?!?"); + + if (argc > 1) + usage_with_options(usagestr, options); + + /* find the worktree, determine its corresponding root */ + if (argc == 1) + strbuf_add_absolute_path(&path, argv[0]); + else if (strbuf_getcwd(&path) < 0) + die(_("need a working directory")); + + strbuf_trim_trailing_dir_sep(&path); + do { + const size_t len = path.len; + + /* check if currently in enlistment root with src/ workdir */ + strbuf_addstr(&path, "/src"); + if (is_nonbare_repository_dir(&path)) { + if (enlistment_root) + strbuf_add(enlistment_root, path.buf, len); + + enlistment_found = 1; + break; + } + + /* reset to original path */ + strbuf_setlen(&path, len); + + /* check if currently in workdir */ + if (is_nonbare_repository_dir(&path)) { + if (enlistment_root) { + /* + * If the worktree's directory's name is `src`, the enlistment is the + * parent directory, otherwise it is identical to the worktree. + */ + root = strip_path_suffix(path.buf, "src"); + strbuf_addstr(enlistment_root, root ? root : path.buf); + free(root); + } + + enlistment_found = 1; + break; + } + } while (strbuf_parent_directory(&path)); + + if (!enlistment_found) + die(_("could not find enlistment root")); + + if (chdir(path.buf) < 0) + die_errno(_("could not switch to '%s'"), path.buf); + + strbuf_release(&path); + setup_git_directory(); +} + +static int run_git(const char *arg, ...) +{ + struct strvec argv = STRVEC_INIT; + va_list args; + const char *p; + int res; + + va_start(args, arg); + strvec_push(&argv, arg); + while ((p = va_arg(args, const char *))) + strvec_push(&argv, p); + va_end(args); + + res = run_command_v_opt(argv.v, RUN_GIT_CMD); + + strvec_clear(&argv); + return res; +} + +static int set_recommended_config(void) +{ + struct { + const char *key; + const char *value; + } config[] = { + { "am.keepCR", "true" }, + { "core.FSCache", "true" }, + { "core.multiPackIndex", "true" }, + { "core.preloadIndex", "true" }, +#ifndef WIN32 + { "core.untrackedCache", "true" }, +#else + /* + * Unfortunately, Scalar's Functional Tests demonstrated + * that the untracked cache feature is unreliable on Windows + * (which is a bummer because that platform would benefit the + * most from it). For some reason, freshly created files seem + * not to update the directory's `lastModified` time + * immediately, but the untracked cache would need to rely on + * that. + * + * Therefore, with a sad heart, we disable this very useful + * feature on Windows. + */ + { "core.untrackedCache", "false" }, +#endif + { "core.logAllRefUpdates", "true" }, + { "credential.https://dev.azure.com.useHttpPath", "true" }, + { "credential.validate", "false" }, /* GCM4W-only */ + { "gc.auto", "0" }, + { "gui.GCWarning", "false" }, + { "index.threads", "true" }, + { "index.version", "4" }, + { "merge.stat", "false" }, + { "merge.renames", "false" }, + { "pack.useBitmaps", "false" }, + { "pack.useSparse", "true" }, + { "receive.autoGC", "false" }, + { "reset.quiet", "true" }, + { "feature.manyFiles", "false" }, + { "feature.experimental", "false" }, + { "fetch.unpackLimit", "1" }, + { "fetch.writeCommitGraph", "false" }, +#ifdef WIN32 + { "http.sslBackend", "schannel" }, +#endif + { "status.aheadBehind", "false" }, + { "commitGraph.generationVersion", "1" }, + { "core.autoCRLF", "false" }, + { "core.safeCRLF", "false" }, + { "fetch.showForcedUpdates", "false" }, + { NULL, NULL }, + }; + int i; + char *value; + + for (i = 0; config[i].key; i++) { + if (git_config_get_string(config[i].key, &value)) { + trace2_data_string("scalar", the_repository, config[i].key, "created"); + if (git_config_set_gently(config[i].key, + config[i].value) < 0) + return error(_("could not configure %s=%s"), + config[i].key, config[i].value); + } else { + trace2_data_string("scalar", the_repository, config[i].key, "exists"); + free(value); + } + } + + /* + * The `log.excludeDecoration` setting is special because it allows + * for multiple values. + */ + if (git_config_get_string("log.excludeDecoration", &value)) { + trace2_data_string("scalar", the_repository, + "log.excludeDecoration", "created"); + if (git_config_set_multivar_gently("log.excludeDecoration", + "refs/prefetch/*", + CONFIG_REGEX_NONE, 0)) + return error(_("could not configure " + "log.excludeDecoration")); + } else { + trace2_data_string("scalar", the_repository, + "log.excludeDecoration", "exists"); + free(value); + } + + return 0; +} + +static int start_maintenance(void) +{ + return run_git("maintenance", "start", NULL); +} + +static int add_enlistment(void) +{ + int res; + + if (!the_repository->worktree) + die(_("Scalar enlistments require a worktree")); + + res = run_git("config", "--global", "--get", "--fixed-value", + "scalar.repo", the_repository->worktree, NULL); + + /* + * If the setting is already there, then do nothing. + */ + if (!res) + return 0; + + return run_git("config", "--global", "--add", + "scalar.repo", the_repository->worktree, NULL); +} + +static int register_dir(void) +{ + int res = add_enlistment(); + + if (!res) + res = set_recommended_config(); + + if (!res) + res = start_maintenance(); + + return res; +} + +static int cmd_register(int argc, const char **argv) +{ + struct option options[] = { + OPT_END(), + }; + const char * const usage[] = { + N_("scalar register []"), + NULL + }; + + argc = parse_options(argc, argv, NULL, options, + usage, 0); + + setup_enlistment_directory(argc, argv, usage, options, NULL); + + return register_dir(); +} static struct { const char *name; int (*fn)(int, const char **); } builtins[] = { + { "register", cmd_register }, { NULL, NULL}, }; diff --git a/contrib/scalar/scalar.txt b/contrib/scalar/scalar.txt index 5f7131861a5..568987064b2 100644 --- a/contrib/scalar/scalar.txt +++ b/contrib/scalar/scalar.txt @@ -8,7 +8,7 @@ scalar - an opinionated repository management tool SYNOPSIS -------- [verse] -scalar [] +scalar register [] DESCRIPTION ----------- @@ -29,6 +29,22 @@ will be identical to the worktree. The `scalar` command implements various subcommands, and different options depending on the subcommand. +COMMANDS +-------- + +Register +~~~~~~~~ + +register []:: + Adds the enlistment's repository to the list of registered repositories + and starts background maintenance. If `` is not provided, + then the enlistment associated with the current working directory is + registered. ++ +Note: when this subcommand is called in a worktree that is called `src/`, its +parent directory is considered to be the Scalar enlistment. If the worktree is +_not_ called `src/`, it itself will be considered to be the Scalar enlistment. + SEE ALSO -------- linkgit:git-maintenance[1]. From patchwork Fri Nov 19 23:03:35 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Derrick Stolee X-Patchwork-Id: 12629717 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 21AE6C433F5 for ; Fri, 19 Nov 2021 23:03:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235192AbhKSXG7 (ORCPT ); Fri, 19 Nov 2021 18:06:59 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35166 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234989AbhKSXGz (ORCPT ); Fri, 19 Nov 2021 18:06:55 -0500 Received: from mail-wr1-x42e.google.com (mail-wr1-x42e.google.com [IPv6:2a00:1450:4864:20::42e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B6709C061748 for ; Fri, 19 Nov 2021 15:03:52 -0800 (PST) Received: by mail-wr1-x42e.google.com with SMTP id s13so20670755wrb.3 for ; Fri, 19 Nov 2021 15:03:52 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=qaR47xznf9Xy5jW3JgfZrlmIasnjgC8KJcW13Zq+3oA=; b=JqQ8bUE3z6WaqxU/ijkxhQbkKWGmHORhA7EzIwzjh/Vl7g7bakGkae7cp2xfse3T3o uf2gNGcwLBhRakeH0OTzLThF/ltQSVC5MhoXp8rBB73QBnHv5lEv8+meOh9qz6vtQje9 hpdGClMi+HHEep/VIWuy53zUMK0vE+TNFvfDcAX+CwgVpQz6o2QzAzVdengQPip/nhoK Piqm24+s1I+nIYd05iKpbvfYtOyGPxfGiXR7CMsGTp2MT5pwVxyzbAY1832hxWBde17E WYlupb1Zh7FQRGeL5y1VW4GFqFhixyAN/oqGIrm8MquUPWLt4KoH/Wm9NK5YhLsN7ClM g6ow== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=qaR47xznf9Xy5jW3JgfZrlmIasnjgC8KJcW13Zq+3oA=; b=DZMqO6PmJ28Y4HIN8FRDq18nW96NJ+uqA8T0gPsoWP0mHVNI1tcdQG9dn1gPiPPATi 527nsrRA8MJnFay9bio8vscf7SgHxsRdyhzAfj82dMnxhsfMJtsqWfhT2qTFmWDfh2t3 H8q5O1FupBU1nqOukwzUA8Xh+0yaGGwiqwWHfSXoXk6D3O08ozTqJ6udYaE5bcrttnoK qTwIvv8ETWynwoGfRC3QQAXJ6MGJ6+kIW1o3EFdy7sYL7RdkOQk3soBLHieYl6puBnYK FWHTAdIxjO1c/IFYxxk9pANx7B5uQ9UWRYz2dmaOl8SOr4UiSllMxGeMXd2Lkrh7M+ml eXQw== X-Gm-Message-State: AOAM530uNE0XciPSDITtXJAFMZH6IQ9sfxmKSxnLaQ6aeMbNLtCq5Eso 4+DOrrifkyerkd2JQQPaVWRQfaWPHGc= X-Google-Smtp-Source: ABdhPJyUa8b4U8vgjvCL2saZMeMoeMPnhn5v8B6mneTxMoJ6TuMnGY4x3isY012rTwLK+dRkQY0uWQ== X-Received: by 2002:a5d:4904:: with SMTP id x4mr12585081wrq.139.1637363031178; Fri, 19 Nov 2021 15:03:51 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id w17sm1009194wrp.79.2021.11.19.15.03.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:50 -0800 (PST) Message-Id: <64c6a75353ef10977e56c7a30266d69e8de991ba.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:35 +0000 Subject: [PATCH v8 08/17] scalar: 'unregister' stops background maintenance Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Derrick Stolee Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Derrick Stolee From: Derrick Stolee Just like `scalar register` starts the scheduled background maintenance, `scalar unregister` stops it. Note that we use `git maintenance start` in `scalar register`, but we do not use `git maintenance stop` in `scalar unregister`: this would stop maintenance for _all_ repositories, not just for the one we want to unregister. The `unregister` command also removes the corresponding entry from the `[scalar]` section in the global Git config. Co-authored-by: Victoria Dye Signed-off-by: Derrick Stolee Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 50 ++++++++++++++++++++++++++++++++------- contrib/scalar/scalar.txt | 8 +++++++ 2 files changed, 50 insertions(+), 8 deletions(-) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index 03d5f84c764..bab0271c37d 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -198,12 +198,12 @@ static int set_recommended_config(void) return 0; } -static int start_maintenance(void) +static int toggle_maintenance(int enable) { - return run_git("maintenance", "start", NULL); + return run_git("maintenance", enable ? "start" : "unregister", NULL); } -static int add_enlistment(void) +static int add_or_remove_enlistment(int add) { int res; @@ -214,24 +214,39 @@ static int add_enlistment(void) "scalar.repo", the_repository->worktree, NULL); /* - * If the setting is already there, then do nothing. + * If we want to add and the setting is already there, then do nothing. + * If we want to remove and the setting is not there, then do nothing. */ - if (!res) + if ((add && !res) || (!add && res)) return 0; - return run_git("config", "--global", "--add", + return run_git("config", "--global", add ? "--add" : "--unset", + add ? "--no-fixed-value" : "--fixed-value", "scalar.repo", the_repository->worktree, NULL); } static int register_dir(void) { - int res = add_enlistment(); + int res = add_or_remove_enlistment(1); if (!res) res = set_recommended_config(); if (!res) - res = start_maintenance(); + res = toggle_maintenance(1); + + return res; +} + +static int unregister_dir(void) +{ + int res = 0; + + if (toggle_maintenance(0) < 0) + res = -1; + + if (add_or_remove_enlistment(0) < 0) + res = -1; return res; } @@ -254,11 +269,30 @@ static int cmd_register(int argc, const char **argv) return register_dir(); } +static int cmd_unregister(int argc, const char **argv) +{ + struct option options[] = { + OPT_END(), + }; + const char * const usage[] = { + N_("scalar unregister []"), + NULL + }; + + argc = parse_options(argc, argv, NULL, options, + usage, 0); + + setup_enlistment_directory(argc, argv, usage, options, NULL); + + return unregister_dir(); +} + static struct { const char *name; int (*fn)(int, const char **); } builtins[] = { { "register", cmd_register }, + { "unregister", cmd_unregister }, { NULL, NULL}, }; diff --git a/contrib/scalar/scalar.txt b/contrib/scalar/scalar.txt index 568987064b2..d9a79984492 100644 --- a/contrib/scalar/scalar.txt +++ b/contrib/scalar/scalar.txt @@ -9,6 +9,7 @@ SYNOPSIS -------- [verse] scalar register [] +scalar unregister [] DESCRIPTION ----------- @@ -45,6 +46,13 @@ Note: when this subcommand is called in a worktree that is called `src/`, its parent directory is considered to be the Scalar enlistment. If the worktree is _not_ called `src/`, it itself will be considered to be the Scalar enlistment. +Unregister +~~~~~~~~~~ + +unregister []:: + Remove the specified repository from the list of repositories + registered with Scalar and stop the scheduled background maintenance. + SEE ALSO -------- linkgit:git-maintenance[1]. From patchwork Fri Nov 19 23:03:36 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629719 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 29DE6C4332F for ; Fri, 19 Nov 2021 23:03:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235021AbhKSXHA (ORCPT ); Fri, 19 Nov 2021 18:07:00 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35170 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234928AbhKSXGz (ORCPT ); Fri, 19 Nov 2021 18:06:55 -0500 Received: from mail-wm1-x32e.google.com (mail-wm1-x32e.google.com [IPv6:2a00:1450:4864:20::32e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5AC36C061757 for ; Fri, 19 Nov 2021 15:03:53 -0800 (PST) Received: by mail-wm1-x32e.google.com with SMTP id 77-20020a1c0450000000b0033123de3425so11659748wme.0 for ; Fri, 19 Nov 2021 15:03:53 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=uLWWlghNT753Rcq+QFeAaezw69rdNihpNbSkEQ0YgSo=; b=UwTtNFOcBzcrprRCpgsil6Nca8R5uwrOR0IVs/tL5w9Zo/HdiTQBXDePtJBTY+rw+J ev9hQvZOD5PHDHKu/nncMcYVapip2p9PXg4o1I4CQGN4RNpqQ7eGRa9kqsVnbQzee9nw IMy2CrnnD8nc7s5d1mDaOtWZgCLB1/zQnSAzPCipu7vivQsKiewqb7cE9vtGPhzgc0qK Ac9HwKEGnWgoksTlWOnckqVrqMMbYf4CC97qlSkig1S+DesE1yocnjqGQmU4wKoTbShn mI3NnYYP8MiCAovRT9JsBS1rkcv/iG2v7SMauAy0QUlnXuRZq3iASkEF2NH054t1yNOq /EwQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=uLWWlghNT753Rcq+QFeAaezw69rdNihpNbSkEQ0YgSo=; b=bB1odGPzRI2W/HpKw+pwLJy+w2LBAvY/TI2AYF6BTSY9N8n+o4YeQpIQ1Tb2zNVLdS Sn6mzJ0lwRIeCuhFz67Jcv6fBGewRWeSXBNGx/8rRDLCMj2UM1xZQuDsNJeAjr6Z7Ycj R3vV7vNyT33cDjdvBkXpPSsD927QuHavzzBR3yvWeJiLlusmSdZ21dN7MJ+fHiNropec 07uNTqkOxjg32AZ8tjY/TNcx/DVpI6QCV2qXlzrU/i84+gZ33H3bkO4/JAbSfm1wZ4vX XIyJYNOf1gc2+yM0/h7lP53dQHbz9O1Lk2ER85DgM8ek5Y+Pn20E8e9plzCpuKr0eFBn pwiA== X-Gm-Message-State: AOAM533BfGGG+KY/GDorA6sNYIUU2vpQD4toBLrMAOywgExjHPaFvarB qmDuPvpdqvymIaonJ9/YlLlaCO1W07I= X-Google-Smtp-Source: ABdhPJyj/kC818DSmzSzek43ib7v9C/pSXzYjYe0WsXtkzqtnNmw0wCiZXQ5LOW4SK/P+kAQhEyP/g== X-Received: by 2002:a05:600c:1f19:: with SMTP id bd25mr4213309wmb.75.1637363031800; Fri, 19 Nov 2021 15:03:51 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id ay21sm13762542wmb.7.2021.11.19.15.03.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:51 -0800 (PST) Message-Id: In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:36 +0000 Subject: [PATCH v8 09/17] scalar: let 'unregister' handle a deleted enlistment directory gracefully Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin When a user deleted an enlistment manually, let's be generous and _still_ unregister it. Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 46 ++++++++++++++++++++++++++++++++ contrib/scalar/t/t9099-scalar.sh | 15 +++++++++++ 2 files changed, 61 insertions(+) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index bab0271c37d..097d3bd478b 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -269,6 +269,24 @@ static int cmd_register(int argc, const char **argv) return register_dir(); } +static int remove_deleted_enlistment(struct strbuf *path) +{ + int res = 0; + strbuf_realpath_forgiving(path, path->buf, 1); + + if (run_git("config", "--global", + "--unset", "--fixed-value", + "scalar.repo", path->buf, NULL) < 0) + res = -1; + + if (run_git("config", "--global", + "--unset", "--fixed-value", + "maintenance.repo", path->buf, NULL) < 0) + res = -1; + + return res; +} + static int cmd_unregister(int argc, const char **argv) { struct option options[] = { @@ -282,6 +300,34 @@ static int cmd_unregister(int argc, const char **argv) argc = parse_options(argc, argv, NULL, options, usage, 0); + /* + * Be forgiving when the enlistment or worktree does not even exist any + * longer; This can be the case if a user deleted the worktree by + * mistake and _still_ wants to unregister the thing. + */ + if (argc == 1) { + struct strbuf src_path = STRBUF_INIT, workdir_path = STRBUF_INIT; + + strbuf_addf(&src_path, "%s/src/.git", argv[0]); + strbuf_addf(&workdir_path, "%s/.git", argv[0]); + if (!is_directory(src_path.buf) && !is_directory(workdir_path.buf)) { + /* remove possible matching registrations */ + int res = -1; + + strbuf_strip_suffix(&src_path, "/.git"); + res = remove_deleted_enlistment(&src_path) && res; + + strbuf_strip_suffix(&workdir_path, "/.git"); + res = remove_deleted_enlistment(&workdir_path) && res; + + strbuf_release(&src_path); + strbuf_release(&workdir_path); + return res; + } + strbuf_release(&src_path); + strbuf_release(&workdir_path); + } + setup_enlistment_directory(argc, argv, usage, options, NULL); return unregister_dir(); diff --git a/contrib/scalar/t/t9099-scalar.sh b/contrib/scalar/t/t9099-scalar.sh index 16f2b72b126..ef0e8d680d5 100755 --- a/contrib/scalar/t/t9099-scalar.sh +++ b/contrib/scalar/t/t9099-scalar.sh @@ -14,4 +14,19 @@ test_expect_success 'scalar shows a usage' ' test_expect_code 129 scalar -h ' +test_expect_success 'scalar unregister' ' + git init vanish/src && + scalar register vanish/src && + git config --get --global --fixed-value \ + maintenance.repo "$(pwd)/vanish/src" && + scalar list >scalar.repos && + grep -F "$(pwd)/vanish/src" scalar.repos && + rm -rf vanish/src/.git && + scalar unregister vanish && + test_must_fail git config --get --global --fixed-value \ + maintenance.repo "$(pwd)/vanish/src" && + scalar list >scalar.repos && + ! grep -F "$(pwd)/vanish/src" scalar.repos +' + test_done From patchwork Fri Nov 19 23:03:37 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Derrick Stolee X-Patchwork-Id: 12629721 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 656A9C433F5 for ; Fri, 19 Nov 2021 23:04:00 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235348AbhKSXHB (ORCPT ); Fri, 19 Nov 2021 18:07:01 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35180 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235124AbhKSXG4 (ORCPT ); Fri, 19 Nov 2021 18:06:56 -0500 Received: from mail-wr1-x42e.google.com (mail-wr1-x42e.google.com [IPv6:2a00:1450:4864:20::42e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 28D40C061574 for ; Fri, 19 Nov 2021 15:03:54 -0800 (PST) Received: by mail-wr1-x42e.google.com with SMTP id n29so20578812wra.11 for ; Fri, 19 Nov 2021 15:03:54 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=97iVUlZN97wuaA47a0t2uiGKid4HTvg3w7rjoSoQOX8=; b=X3+MapMnC0I8aXBynZG3+p5DQVs5xp6AlbtehBByJT7RkVLgkWk23idQuZVIpfwYpz 5VLBD4TmkDi5n8AdqrKqEFfJn3snhuenv1AYtri60QKv8LbasooLN0tiGyraBUf4PvUD kGaZ6WAtvqmDnoLnAIXpe1cCLoDuhVKWBXR9+dnLIT5fCrgaQ68OQhMnqIBiWSGbCUra QvbWYB42KwTpzwcjY14f2lUmtkub7RAJTD0vvH5WGmadoo26cmlsjUhWMwuVP3SbeeRQ CW8wWdlURuXzurF+7hMySFC3z5vbsXWisUMPopWnj6SROISJv93V9AmhiuP2ph3Hkxr1 eQvg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=97iVUlZN97wuaA47a0t2uiGKid4HTvg3w7rjoSoQOX8=; b=LCd4jJqdOmrwn/PDxMYmE3/+3jlKleuwd4SkGstq1ebs7UOOqgtD1Rih5pCW0f2K7y RwOTzCIRxbqIehYgmfvZXpyBtGUQmM3rCNKEIahFy0aeA+bwf0l4nlYoAIoJBkf+K5JL uiB3T0xMNDiRUTfnSceVHfm8d1Cv+aH4ex3mhRoNlliOBO1HDXwAHZWMFpuRfqtn6RrN BFOjszNlinCA3d7RjPSfZ9W15dwJusueXyeRaee220kcEwL2g1kzEqk7RtNTtlgomtQ5 aALV1iRyhDCDNjFctWKt2hWudjMqE4707HkrsP6Zgc88iaJHj2e8mCyI9aAby0cd33XL L3wg== X-Gm-Message-State: AOAM531sgcWbzBqhUL9VTv3mv7cuRluHWGa7PUhPf3H/EveSEcOkwZqV zNqFwjPE+A4l1agVXyvn/zGWW2nDPi4= X-Google-Smtp-Source: ABdhPJyAAQA/NeIrWnAnCHDYNVG+fwoI7/A+0//WeATIczaGo67mmLoFtWFMTWN0S4JywvRzWfbUbw== X-Received: by 2002:adf:cd89:: with SMTP id q9mr11907182wrj.205.1637363032539; Fri, 19 Nov 2021 15:03:52 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id k27sm16509088wms.41.2021.11.19.15.03.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:52 -0800 (PST) Message-Id: In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:37 +0000 Subject: [PATCH v8 10/17] scalar: implement 'scalar list' Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Derrick Stolee Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Derrick Stolee From: Derrick Stolee The produced list simply consists of those repositories registered under the multi-valued `scalar.repo` config setting in the user's Git config. Signed-off-by: Derrick Stolee Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 11 +++++++++++ contrib/scalar/scalar.txt | 11 ++++++++++- 2 files changed, 21 insertions(+), 1 deletion(-) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index 097d3bd478b..4feacd8d62b 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -251,6 +251,16 @@ static int unregister_dir(void) return res; } +static int cmd_list(int argc, const char **argv) +{ + if (argc != 1) + die(_("`scalar list` does not take arguments")); + + if (run_git("config", "--global", "--get-all", "scalar.repo", NULL) < 0) + return -1; + return 0; +} + static int cmd_register(int argc, const char **argv) { struct option options[] = { @@ -337,6 +347,7 @@ static struct { const char *name; int (*fn)(int, const char **); } builtins[] = { + { "list", cmd_list }, { "register", cmd_register }, { "unregister", cmd_unregister }, { NULL, NULL}, diff --git a/contrib/scalar/scalar.txt b/contrib/scalar/scalar.txt index d9a79984492..f93e3d00efd 100644 --- a/contrib/scalar/scalar.txt +++ b/contrib/scalar/scalar.txt @@ -8,6 +8,7 @@ scalar - an opinionated repository management tool SYNOPSIS -------- [verse] +scalar list scalar register [] scalar unregister [] @@ -28,11 +29,19 @@ an existing Git worktree with Scalar whose name is not `src`, the enlistment will be identical to the worktree. The `scalar` command implements various subcommands, and different options -depending on the subcommand. +depending on the subcommand. With the exception of `list`, all subcommands +expect to be run in an enlistment. COMMANDS -------- +List +~~~~ + +list:: + List enlistments that are currently registered by Scalar. This + subcommand does not need to be run inside an enlistment. + Register ~~~~~~~~ From patchwork Fri Nov 19 23:03:38 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629723 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 01575C433EF for ; Fri, 19 Nov 2021 23:04:00 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235384AbhKSXHC (ORCPT ); Fri, 19 Nov 2021 18:07:02 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35200 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234989AbhKSXG7 (ORCPT ); Fri, 19 Nov 2021 18:06:59 -0500 Received: from mail-wr1-x429.google.com (mail-wr1-x429.google.com [IPv6:2a00:1450:4864:20::429]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E680FC061757 for ; Fri, 19 Nov 2021 15:03:54 -0800 (PST) Received: by mail-wr1-x429.google.com with SMTP id c4so20602735wrd.9 for ; Fri, 19 Nov 2021 15:03:54 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=r61DTTjZtGcp+DyKnMUP3/d+tsXMFXvUlmG/yKPaWRs=; b=cntbVXXfruFgS2iJPf+ZF0carRUkiGnwxD25Fi9oyCZR0st8PAUkeszIvebGApa4Ht sdoH/q3NPZ/kSwWtKBC2GMS5xJNeAL5lWL7ybdNN2snkzE+YqFrt61I6KU7ifczZJlmC wPbKO1pRwOW5TS5IXkjtjm61II1Lv8kMnnRdHVlpf0wLBOgz+600m+UHI5Jj09RHHbcC 05ilKyeCiRYF3eWqSfw9AiIrbFHVcKqi6woWWBkKHhvSQPAqb09lIEneIrfDrNlnt26X fuoPO9GZMwE8DF53F3ZOAJ3uVpxFE/4eIeAwTtRg/GMbBYfSkM6bOqMvEenoisDR/Koa EMFA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=r61DTTjZtGcp+DyKnMUP3/d+tsXMFXvUlmG/yKPaWRs=; b=4+0aKMpQMyqgH4fMulF4RrPjCmvMfoyFP9WEyPDq8UQuL6PGCOmZKGZa0EpKFoNyzD EW3fK/1yTlCRN2eB18kIN6Ulfl43w4zgEKIw2ZrWBb2uR6OzCLv2epohjtIDKEUTwY+8 4oLLtst7yZGvhktrFAplNZPefLKIRYesMBPnV9Hw9knvnbr/ldIETLgdHwxNwOKGuImZ FfuSwc8GDtKeQqfBLxfvRnwbPhGTKYmQspQ64H6TZ9BcyNLYKCcJJlc9K3N77hRlwGMM 5ucZqjq4Mt2VlXLnHY340S28kn+Q6L3rpp4tszH0fZJrV1CtGx68gM9cTOaEUiK32Kke ttzw== X-Gm-Message-State: AOAM530FWAILSm6g/qE09pggIfn5W2BzDScowVRlWnKlt14rzU2Xwyrf wzkOc4tevXqi7jG7XEToByR+1zxRpCI= X-Google-Smtp-Source: ABdhPJx83HfA6s4mu7yvDw8/zrBoO+lCR1c03X+K/EQogxUb3TId4e0dnnGogi8T2BUNGllLsuxRWg== X-Received: by 2002:adf:e7cf:: with SMTP id e15mr12046860wrn.287.1637363033247; Fri, 19 Nov 2021 15:03:53 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id g18sm16861297wmq.4.2021.11.19.15.03.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:52 -0800 (PST) Message-Id: <4966a43aad9d887d5530307f4e1b340b34389785.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:38 +0000 Subject: [PATCH v8 11/17] scalar: implement the `clone` subcommand Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin This implements Scalar's opinionated `clone` command: it tries to use a partial clone and sets up a sparse checkout by default. In contrast to `git clone`, `scalar clone` sets up the worktree in the `src/` subdirectory, to encourage a separation between the source files and the build output (which helps Git tremendously because it avoids untracked files that have to be specifically ignored when refreshing the index). Also, it registers the repository for regular, scheduled maintenance, and configures a flurry of configuration settings based on the experience and experiments of the Microsoft Windows and the Microsoft Office development teams. Note: since the `scalar clone` command is by far the most commonly called `scalar` subcommand, we document it at the top of the manual page. Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 201 +++++++++++++++++++++++++++++++ contrib/scalar/scalar.txt | 32 ++++- contrib/scalar/t/t9099-scalar.sh | 32 +++++ 3 files changed, 262 insertions(+), 3 deletions(-) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index 4feacd8d62b..43f83dde33b 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -7,6 +7,7 @@ #include "parse-options.h" #include "config.h" #include "run-command.h" +#include "refs.h" /* * Remove the deepest subdirectory in the provided path string. Path must not @@ -251,6 +252,205 @@ static int unregister_dir(void) return res; } +/* printf-style interface, expects `=` argument */ +static int set_config(const char *fmt, ...) +{ + struct strbuf buf = STRBUF_INIT; + char *value; + int res; + va_list args; + + va_start(args, fmt); + strbuf_vaddf(&buf, fmt, args); + va_end(args); + + value = strchr(buf.buf, '='); + if (value) + *(value++) = '\0'; + res = git_config_set_gently(buf.buf, value); + strbuf_release(&buf); + + return res; +} + +static char *remote_default_branch(const char *url) +{ + struct child_process cp = CHILD_PROCESS_INIT; + struct strbuf out = STRBUF_INIT; + + cp.git_cmd = 1; + strvec_pushl(&cp.args, "ls-remote", "--symref", url, "HEAD", NULL); + if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) { + const char *line = out.buf; + + while (*line) { + const char *eol = strchrnul(line, '\n'), *p; + size_t len = eol - line; + char *branch; + + if (!skip_prefix(line, "ref: ", &p) || + !strip_suffix_mem(line, &len, "\tHEAD")) { + line = eol + (*eol == '\n'); + continue; + } + + eol = line + len; + if (skip_prefix(p, "refs/heads/", &p)) { + branch = xstrndup(p, eol - p); + strbuf_release(&out); + return branch; + } + + error(_("remote HEAD is not a branch: '%.*s'"), + (int)(eol - p), p); + strbuf_release(&out); + return NULL; + } + } + warning(_("failed to get default branch name from remote; " + "using local default")); + strbuf_reset(&out); + + child_process_init(&cp); + cp.git_cmd = 1; + strvec_pushl(&cp.args, "symbolic-ref", "--short", "HEAD", NULL); + if (!pipe_command(&cp, NULL, 0, &out, 0, NULL, 0)) { + strbuf_trim(&out); + return strbuf_detach(&out, NULL); + } + + strbuf_release(&out); + error(_("failed to get default branch name")); + return NULL; +} + +static int cmd_clone(int argc, const char **argv) +{ + const char *branch = NULL; + int full_clone = 0; + struct option clone_options[] = { + OPT_STRING('b', "branch", &branch, N_(""), + N_("branch to checkout after clone")), + OPT_BOOL(0, "full-clone", &full_clone, + N_("when cloning, create full working directory")), + OPT_END(), + }; + const char * const clone_usage[] = { + N_("scalar clone [] [--] []"), + NULL + }; + const char *url; + char *enlistment = NULL, *dir = NULL; + struct strbuf buf = STRBUF_INIT; + int res; + + argc = parse_options(argc, argv, NULL, clone_options, clone_usage, 0); + + if (argc == 2) { + url = argv[0]; + enlistment = xstrdup(argv[1]); + } else if (argc == 1) { + url = argv[0]; + + strbuf_addstr(&buf, url); + /* Strip trailing slashes, if any */ + while (buf.len > 0 && is_dir_sep(buf.buf[buf.len - 1])) + strbuf_setlen(&buf, buf.len - 1); + /* Strip suffix `.git`, if any */ + strbuf_strip_suffix(&buf, ".git"); + + enlistment = find_last_dir_sep(buf.buf); + if (!enlistment) { + die(_("cannot deduce worktree name from '%s'"), url); + } + enlistment = xstrdup(enlistment + 1); + } else { + usage_msg_opt(_("You must specify a repository to clone."), + clone_usage, clone_options); + } + + if (is_directory(enlistment)) + die(_("directory '%s' exists already"), enlistment); + + dir = xstrfmt("%s/src", enlistment); + + strbuf_reset(&buf); + if (branch) + strbuf_addf(&buf, "init.defaultBranch=%s", branch); + else { + char *b = repo_default_branch_name(the_repository, 1); + strbuf_addf(&buf, "init.defaultBranch=%s", b); + free(b); + } + + if ((res = run_git("-c", buf.buf, "init", "--", dir, NULL))) + goto cleanup; + + if (chdir(dir) < 0) { + res = error_errno(_("could not switch to '%s'"), dir); + goto cleanup; + } + + setup_git_directory(); + + /* common-main already logs `argv` */ + trace2_def_repo(the_repository); + + if (!branch && !(branch = remote_default_branch(url))) { + res = error(_("failed to get default branch for '%s'"), url); + goto cleanup; + } + + if (set_config("remote.origin.url=%s", url) || + set_config("remote.origin.fetch=" + "+refs/heads/*:refs/remotes/origin/*") || + set_config("remote.origin.promisor=true") || + set_config("remote.origin.partialCloneFilter=blob:none")) { + res = error(_("could not configure remote in '%s'"), dir); + goto cleanup; + } + + if (!full_clone && + (res = run_git("sparse-checkout", "init", "--cone", NULL))) + goto cleanup; + + if (set_recommended_config()) + return error(_("could not configure '%s'"), dir); + + if ((res = run_git("fetch", "--quiet", "origin", NULL))) { + warning(_("partial clone failed; attempting full clone")); + + if (set_config("remote.origin.promisor") || + set_config("remote.origin.partialCloneFilter")) { + res = error(_("could not configure for full clone")); + goto cleanup; + } + + if ((res = run_git("fetch", "--quiet", "origin", NULL))) + goto cleanup; + } + + if ((res = set_config("branch.%s.remote=origin", branch))) + goto cleanup; + if ((res = set_config("branch.%s.merge=refs/heads/%s", + branch, branch))) + goto cleanup; + + strbuf_reset(&buf); + strbuf_addf(&buf, "origin/%s", branch); + res = run_git("checkout", "-f", "-t", buf.buf, NULL); + if (res) + goto cleanup; + + res = register_dir(); + +cleanup: + free(enlistment); + free(dir); + strbuf_release(&buf); + return res; +} + static int cmd_list(int argc, const char **argv) { if (argc != 1) @@ -347,6 +547,7 @@ static struct { const char *name; int (*fn)(int, const char **); } builtins[] = { + { "clone", cmd_clone }, { "list", cmd_list }, { "register", cmd_register }, { "unregister", cmd_unregister }, diff --git a/contrib/scalar/scalar.txt b/contrib/scalar/scalar.txt index f93e3d00efd..e8730967f16 100644 --- a/contrib/scalar/scalar.txt +++ b/contrib/scalar/scalar.txt @@ -8,6 +8,7 @@ scalar - an opinionated repository management tool SYNOPSIS -------- [verse] +scalar clone [--branch ] [--full-clone] [] scalar list scalar register [] scalar unregister [] @@ -29,12 +30,37 @@ an existing Git worktree with Scalar whose name is not `src`, the enlistment will be identical to the worktree. The `scalar` command implements various subcommands, and different options -depending on the subcommand. With the exception of `list`, all subcommands -expect to be run in an enlistment. +depending on the subcommand. With the exception of `clone` and `list`, all +subcommands expect to be run in an enlistment. COMMANDS -------- +Clone +~~~~~ + +clone [] []:: + Clones the specified repository, similar to linkgit:git-clone[1]. By + default, only commit and tree objects are cloned. Once finished, the + worktree is located at `/src`. ++ +The sparse-checkout feature is enabled (except when run with `--full-clone`) +and the only files present are those in the top-level directory. Use +`git sparse-checkout set` to expand the set of directories you want to see, +or `git sparse-checkout disable` to expand to all files (see +linkgit:git-sparse-checkout[1] for more details). You can explore the +subdirectories outside your sparse-checkout by using `git ls-tree +HEAD[:]`. + +-b :: +--branch :: + Instead of checking out the branch pointed to by the cloned + repository's HEAD, check out the `` branch instead. + +--[no-]full-clone:: + A sparse-checkout is initialized by default. This behavior can be + turned off via `--full-clone`. + List ~~~~ @@ -64,7 +90,7 @@ unregister []:: SEE ALSO -------- -linkgit:git-maintenance[1]. +linkgit:git-clone[1], linkgit:git-maintenance[1]. Scalar --- diff --git a/contrib/scalar/t/t9099-scalar.sh b/contrib/scalar/t/t9099-scalar.sh index ef0e8d680d5..984d69e8f75 100755 --- a/contrib/scalar/t/t9099-scalar.sh +++ b/contrib/scalar/t/t9099-scalar.sh @@ -10,6 +10,9 @@ PATH=$PWD/..:$PATH . ../../../t/test-lib.sh +GIT_TEST_MAINT_SCHEDULER="crontab:test-tool crontab ../cron.txt,launchctl:true,schtasks:true" +export GIT_TEST_MAINT_SCHEDULER + test_expect_success 'scalar shows a usage' ' test_expect_code 129 scalar -h ' @@ -29,4 +32,33 @@ test_expect_success 'scalar unregister' ' ! grep -F "$(pwd)/vanish/src" scalar.repos ' +test_expect_success 'set up repository to clone' ' + test_commit first && + test_commit second && + test_commit third && + git switch -c parallel first && + mkdir -p 1/2 && + test_commit 1/2/3 && + git config uploadPack.allowFilter true && + git config uploadPack.allowAnySHA1InWant true +' + +test_expect_success 'scalar clone' ' + second=$(git rev-parse --verify second:second.t) && + scalar clone "file://$(pwd)" cloned && + ( + cd cloned/src && + + git config --get --global --fixed-value maintenance.repo \ + "$(pwd)" && + + test_path_is_missing 1/2 && + test_must_fail git rev-list --missing=print $second && + git rev-list $second && + git cat-file blob $second >actual && + echo "second" >expect && + test_cmp expect actual + ) +' + test_done From patchwork Fri Nov 19 23:03:39 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629725 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E5BC1C433FE for ; Fri, 19 Nov 2021 23:04:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235203AbhKSXHD (ORCPT ); Fri, 19 Nov 2021 18:07:03 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35210 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235368AbhKSXHA (ORCPT ); Fri, 19 Nov 2021 18:07:00 -0500 Received: from mail-wr1-x429.google.com (mail-wr1-x429.google.com [IPv6:2a00:1450:4864:20::429]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 97F4AC06175B for ; Fri, 19 Nov 2021 15:03:55 -0800 (PST) Received: by mail-wr1-x429.google.com with SMTP id u18so20650412wrg.5 for ; Fri, 19 Nov 2021 15:03:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=aNTH9FlmLUV1D0smRDtl/JcI0aq3IqqJlw7lcxaJwfw=; b=jrKderguPTCnCJhw91fM+6Q8m0ZwqxSVB5qJEXbflUXRIXYK74E32RtGnUXc3CknYE 8dGLxUvZ1thtZIGUJ9nedhU3qMZtzxpCAa5E1YQNKEHvUWKvue+Hhvps2X9xJY57UiPs hudCkRr8n/w1QTxA3pmcIwYR4TV6pjUx3kov8/xDvEZD0DSRZCb0vc0+4keLPsWnwIH0 2mG7lA4GdWgYTqKpOtSkSQSjfbdVB0OVTiYjuJeXnY4LRr3Y42Y4GrOcBkso/yHuD1/4 XunMO5HrZldl1y/fB8qjV/XZsbe0zgwDKQqrmcVP9cF73vlIhveHoMaTn2fZ5sUDOX83 8F8g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=aNTH9FlmLUV1D0smRDtl/JcI0aq3IqqJlw7lcxaJwfw=; b=xugSPnVvVG/ZYjn0aIlWpMGWqft7x5qZIbyaEznAiMsSzB9yAoUu7pm3QKu3nk3Nnn 62Ro5Q9+e+P19owwz5gT3ytgl9AQJnSHkuz+GJOfJF8nPeKjcB2QMvqv/N11qo9kzW6d FhuKcezosSBg7Nc/R0IcEyslE/34mJtGuF4dk+WcoXvr36FDbg5VYZfr1SWzqD06S42O PscoizemsCvQFHVsG/NJO6gwzsyBiFEbmU3mcBk89W7f/ix1gTgq73A8L+oCqPawyBJ4 OGo7+/59atx2t2ElJYDzH7iAjUya8CvQA6GTsKDqLvBRunicphWhGmJwwnUNBHUEVkK7 nvvA== X-Gm-Message-State: AOAM533Uvh4E0M+21ORZE0Cl2L4ONIElV97uYmaDCkvXkFmSxavjYELe HcNy7vEVT5K97T3TPOp+d0WxmW6Lhcg= X-Google-Smtp-Source: ABdhPJwWvYFHaMepKHQq4ZNT4zMn5dqN4MLLPo7kX0nMzDJEnBdO4Ux7H7vV6MQ3eM8LnLioxeRkzg== X-Received: by 2002:adf:dd0a:: with SMTP id a10mr12367646wrm.60.1637363033975; Fri, 19 Nov 2021 15:03:53 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id x4sm13014397wmi.3.2021.11.19.15.03.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:53 -0800 (PST) Message-Id: In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:39 +0000 Subject: [PATCH v8 12/17] scalar: teach 'clone' to support the --single-branch option Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin Just like `git clone`, the `scalar clone` command now also offers to restrict the clone to a single branch. Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 9 +++++++-- contrib/scalar/scalar.txt | 12 +++++++++++- contrib/scalar/t/t9099-scalar.sh | 6 +++++- 3 files changed, 23 insertions(+), 4 deletions(-) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index 43f83dde33b..516a75be3c4 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -327,12 +327,15 @@ static char *remote_default_branch(const char *url) static int cmd_clone(int argc, const char **argv) { const char *branch = NULL; - int full_clone = 0; + int full_clone = 0, single_branch = 0; struct option clone_options[] = { OPT_STRING('b', "branch", &branch, N_(""), N_("branch to checkout after clone")), OPT_BOOL(0, "full-clone", &full_clone, N_("when cloning, create full working directory")), + OPT_BOOL(0, "single-branch", &single_branch, + N_("only download metadata for the branch that will " + "be checked out")), OPT_END(), }; const char * const clone_usage[] = { @@ -403,7 +406,9 @@ static int cmd_clone(int argc, const char **argv) if (set_config("remote.origin.url=%s", url) || set_config("remote.origin.fetch=" - "+refs/heads/*:refs/remotes/origin/*") || + "+refs/heads/%s:refs/remotes/origin/%s", + single_branch ? branch : "*", + single_branch ? branch : "*") || set_config("remote.origin.promisor=true") || set_config("remote.origin.partialCloneFilter=blob:none")) { res = error(_("could not configure remote in '%s'"), dir); diff --git a/contrib/scalar/scalar.txt b/contrib/scalar/scalar.txt index e8730967f16..56f744a4aa9 100644 --- a/contrib/scalar/scalar.txt +++ b/contrib/scalar/scalar.txt @@ -8,7 +8,7 @@ scalar - an opinionated repository management tool SYNOPSIS -------- [verse] -scalar clone [--branch ] [--full-clone] [] +scalar clone [--single-branch] [--branch ] [--full-clone] [] scalar list scalar register [] scalar unregister [] @@ -57,6 +57,16 @@ HEAD[:]`. Instead of checking out the branch pointed to by the cloned repository's HEAD, check out the `` branch instead. +--[no-]single-branch:: + Clone only the history leading to the tip of a single branch, either + specified by the `--branch` option or the primary branch remote's + `HEAD` points at. ++ +Further fetches into the resulting repository will only update the +remote-tracking branch for the branch this option was used for the initial +cloning. If the HEAD at the remote did not point at any branch when +`--single-branch` clone was made, no remote-tracking branch is created. + --[no-]full-clone:: A sparse-checkout is initialized by default. This behavior can be turned off via `--full-clone`. diff --git a/contrib/scalar/t/t9099-scalar.sh b/contrib/scalar/t/t9099-scalar.sh index 984d69e8f75..f60e086d6f9 100755 --- a/contrib/scalar/t/t9099-scalar.sh +++ b/contrib/scalar/t/t9099-scalar.sh @@ -45,13 +45,17 @@ test_expect_success 'set up repository to clone' ' test_expect_success 'scalar clone' ' second=$(git rev-parse --verify second:second.t) && - scalar clone "file://$(pwd)" cloned && + scalar clone "file://$(pwd)" cloned --single-branch && ( cd cloned/src && git config --get --global --fixed-value maintenance.repo \ "$(pwd)" && + git for-each-ref --format="%(refname)" refs/remotes/origin/ >actual && + echo "refs/remotes/origin/parallel" >expect && + test_cmp expect actual && + test_path_is_missing 1/2 && test_must_fail git rev-list --missing=print $second && git rev-list $second && From patchwork Fri Nov 19 23:03:40 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Derrick Stolee X-Patchwork-Id: 12629727 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4D128C4332F for ; Fri, 19 Nov 2021 23:04:03 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235615AbhKSXHE (ORCPT ); Fri, 19 Nov 2021 18:07:04 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35204 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234928AbhKSXHA (ORCPT ); Fri, 19 Nov 2021 18:07:00 -0500 Received: from mail-wm1-x333.google.com (mail-wm1-x333.google.com [IPv6:2a00:1450:4864:20::333]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 59E3EC0613D7 for ; Fri, 19 Nov 2021 15:03:56 -0800 (PST) Received: by mail-wm1-x333.google.com with SMTP id 77-20020a1c0450000000b0033123de3425so11659815wme.0 for ; Fri, 19 Nov 2021 15:03:56 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=5J6efhqLKwPw37BZdtrl+rmUFh3AZSA48OGeWE6mV7E=; b=hbTZmqF0qfhYkv4WmCS3iv7ASIpip02etnv4PW4I00OrI/E6bg/go4i7Xesjbks4bQ B0rxkYfZUvSRVXs3CXVtSfrqAsVXzBl/mbv9H8/yp/jwwWjaqdih5Knv9L/qcscF/2yi resp/DwLWXY3Ce5s+iS5wpTaLxS2zrZApwMdiTU9N05RqLeIuT1TDh2HEcPexDmglM9m mnwkkPzmPe4xkXuE72zNFR8WEVAQrxsWkK7LxIaOdRxJJmJopiu75GES+303BR+7SSUp iLpFOVQP3gBMHn/fMY8co0X3jO7GvL+PuDb2qRG2/YjezyYyzOdm3ZcfEd06YP9Bq/zv mDsQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=5J6efhqLKwPw37BZdtrl+rmUFh3AZSA48OGeWE6mV7E=; b=GNPbjNBF7mwo/wq0U4d114MVejSj1qKcLLErMb2yvQT9mXYGeG3yWfexOh0xTg225S 33tBXgh0SSWnYcnDITxEhHaMtbIIC3MZUdtjnnyINZLJg7/yqC7WcIke62FnvSm2Pnhh DYSFvlktxfeYTcWpW3fSOkZFv9+Gavgq54PDCeoEhZeB9csr0kzvtLcn3OsIobOPpfDc FiItC5RKzGZ6/5p3uXzOBowLFyF9vHHgGCssZ37GtjyQVXHhb0qkuuK/Bap9YwZ6moz8 5ybiNABCiTapn78msMA/B/HDbnrDYOFjNcKZC1HZSLO5zAF0pcjPTdhl/jA1sO7boEin aURQ== X-Gm-Message-State: AOAM533QRdN1JnyvrucdwETJGJHFhdPPi0eqFdRt4FK1neH5h3RorftT QMCvZJQQE7CsffXdZKJn/i8upF2IFaE= X-Google-Smtp-Source: ABdhPJziz0edIywbq3C5dbHnIQfsTeL8R3kUWH9A7yMx9hZopTiqa+es3/j0WtImNP0/flBxzwPgog== X-Received: by 2002:a05:600c:1548:: with SMTP id f8mr4623887wmg.20.1637363034679; Fri, 19 Nov 2021 15:03:54 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id az4sm13688554wmb.20.2021.11.19.15.03.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:54 -0800 (PST) Message-Id: <771d826bbb1fb6c8ff11b3e6bdd890833289a71e.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:40 +0000 Subject: [PATCH v8 13/17] scalar: implement the `run` command Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Derrick Stolee Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Derrick Stolee From: Derrick Stolee Note: this subcommand is provided primarily for backwards-compatibility, for existing Scalar uses. It is mostly just a shim for `git maintenance`, mapping task names from the way Scalar called them to the way Git calls them. The reason why those names differ? The background maintenance was first implemented in Scalar, and when it was contributed as a patch series implementing the `git maintenance` command, reviewers suggested better names, those suggestions were accepted before the patches were integrated into core Git. Signed-off-by: Derrick Stolee Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 64 +++++++++++++++++++++++++++++++++++++++ contrib/scalar/scalar.txt | 19 ++++++++++++ 2 files changed, 83 insertions(+) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index 516a75be3c4..ca524576011 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -484,6 +484,69 @@ static int cmd_register(int argc, const char **argv) return register_dir(); } +static int cmd_run(int argc, const char **argv) +{ + struct option options[] = { + OPT_END(), + }; + struct { + const char *arg, *task; + } tasks[] = { + { "config", NULL }, + { "commit-graph", "commit-graph" }, + { "fetch", "prefetch" }, + { "loose-objects", "loose-objects" }, + { "pack-files", "incremental-repack" }, + { NULL, NULL } + }; + struct strbuf buf = STRBUF_INIT; + const char *usagestr[] = { NULL, NULL }; + int i; + + strbuf_addstr(&buf, N_("scalar run []\nTasks:\n")); + for (i = 0; tasks[i].arg; i++) + strbuf_addf(&buf, "\t%s\n", tasks[i].arg); + usagestr[0] = buf.buf; + + argc = parse_options(argc, argv, NULL, options, + usagestr, 0); + + if (!argc) + usage_with_options(usagestr, options); + + if (!strcmp("all", argv[0])) { + i = -1; + } else { + for (i = 0; tasks[i].arg && strcmp(tasks[i].arg, argv[0]); i++) + ; /* keep looking for the task */ + + if (i > 0 && !tasks[i].arg) { + error(_("no such task: '%s'"), argv[0]); + usage_with_options(usagestr, options); + } + } + + argc--; + argv++; + setup_enlistment_directory(argc, argv, usagestr, options, NULL); + strbuf_release(&buf); + + if (i == 0) + return register_dir(); + + if (i > 0) + return run_git("maintenance", "run", + "--task", tasks[i].task, NULL); + + if (register_dir()) + return -1; + for (i = 1; tasks[i].arg; i++) + if (run_git("maintenance", "run", + "--task", tasks[i].task, NULL)) + return -1; + return 0; +} + static int remove_deleted_enlistment(struct strbuf *path) { int res = 0; @@ -556,6 +619,7 @@ static struct { { "list", cmd_list }, { "register", cmd_register }, { "unregister", cmd_unregister }, + { "run", cmd_run }, { NULL, NULL}, }; diff --git a/contrib/scalar/scalar.txt b/contrib/scalar/scalar.txt index 56f744a4aa9..39143b08324 100644 --- a/contrib/scalar/scalar.txt +++ b/contrib/scalar/scalar.txt @@ -12,6 +12,7 @@ scalar clone [--single-branch] [--branch ] [--full-clone] [] scalar unregister [] +scalar run ( all | config | commit-graph | fetch | loose-objects | pack-files ) [] DESCRIPTION ----------- @@ -98,6 +99,24 @@ unregister []:: Remove the specified repository from the list of repositories registered with Scalar and stop the scheduled background maintenance. +Run +~~~ + +scalar run ( all | config | commit-graph | fetch | loose-objects | pack-files ) []:: + Run the given maintenance task (or all tasks, if `all` was specified). + Except for `all` and `config`, this subcommand simply hands off to + linkgit:git-maintenance[1] (mapping `fetch` to `prefetch` and + `pack-files` to `incremental-repack`). ++ +These tasks are run automatically as part of the scheduled maintenance, +as soon as the repository is registered with Scalar. It should therefore +not be necessary to run this subcommand manually. ++ +The `config` task is specific to Scalar and configures all those +opinionated default settings that make Git work more efficiently with +large repositories. As this task is run as part of `scalar clone` +automatically, explicit invocations of this task are rarely needed. + SEE ALSO -------- linkgit:git-clone[1], linkgit:git-maintenance[1]. From patchwork Fri Nov 19 23:03:41 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629729 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E633CC433EF for ; Fri, 19 Nov 2021 23:04:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235513AbhKSXHG (ORCPT ); Fri, 19 Nov 2021 18:07:06 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35230 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235433AbhKSXHA (ORCPT ); Fri, 19 Nov 2021 18:07:00 -0500 Received: from mail-wr1-x42a.google.com (mail-wr1-x42a.google.com [IPv6:2a00:1450:4864:20::42a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1B5A5C0613F4 for ; Fri, 19 Nov 2021 15:03:57 -0800 (PST) Received: by mail-wr1-x42a.google.com with SMTP id w29so20594547wra.12 for ; Fri, 19 Nov 2021 15:03:57 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=m7FNXGAFF5pKL7d91XTp2X+SrZe8ykWkptqO9g88h1Y=; b=krJYDRU577Dj0+uabyu+CTSKr5iAPGRri1eny0GhvJKBL6m3IbOh9Jg/aPAKUH+9or mN7SRhtjsLOXLHHZ+O3GvX2YaaAPDr9xiTbqcoc0ZZ9aiGVgKz3qD65YmKjZKoL5zT2l LAHp1BjXgyDgGq37C6xSi2wH1A0ungmU5RXo4BUqbUxlXAwC1kCPR4GaxLqQzDP8kgtK XZmOVARJDO5QcBntiv6VNGMweNa5ZutY+qZBBIILpXmBvcTAdQHHabZ0Sq9SDIcIP2KD lbUtt35/np9yMV4tdelTZfp2pShwLhTywsSlGuP/QjWIBV1YvplgKxNiMYQWCs8aZPzb Qwvg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=m7FNXGAFF5pKL7d91XTp2X+SrZe8ykWkptqO9g88h1Y=; b=Q+KNM3+5JHaLAOO516s4bph8+FWXl6C2N+P7fKUwYy2S6VPtOhffm1mNW0qf4PiO3U 9pk4nPkxTXkW5pYX6JC7jB3RPHwlYVV5dTnMxEB+TImIKPJRNZx4WjG4Wk4kTKLbsGD3 LtSdqCk88jdAWkstrhqHFYcrOtKD2JL4j8h5nAi1jmNdqpsjM2dyYAKRAvmO0363jvpe /i2QcqIxbtULLDJPN+11NuOsglLk2xhHOSiNI6r5f/uiy+ciO/gAucrakcge0f1C6+V6 2h5fhnFKhcfFpVm34n3mlYf4sa04JYuXG8EwGqupNUCrAKrMgBfq8f8h5oQuSnyzrx3S pdGw== X-Gm-Message-State: AOAM533FiLoWz+AweF8QHsBZ2QnTcDTwmse57gZpg4QRKSer85Wyswzz dwXKh2oe3UOFO6ny+faI8nekKwOCzLM= X-Google-Smtp-Source: ABdhPJxwaqOroQRmszQLxpc8jyLqPwSu6pZS4Uct5D3BSwI46ZUGSWBJSG+PPRHTNRfqrOy3wfjH6A== X-Received: by 2002:a5d:64cd:: with SMTP id f13mr12032928wri.382.1637363035461; Fri, 19 Nov 2021 15:03:55 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id t8sm1002900wrv.30.2021.11.19.15.03.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:55 -0800 (PST) Message-Id: In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:41 +0000 Subject: [PATCH v8 14/17] scalar: allow reconfiguring an existing enlistment Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin This comes in handy during Scalar upgrades, or when config settings were messed up by mistake. Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 79 +++++++++++++++++++++----------- contrib/scalar/scalar.txt | 8 ++++ contrib/scalar/t/t9099-scalar.sh | 8 ++++ 3 files changed, 67 insertions(+), 28 deletions(-) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index ca524576011..b799decbc2f 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -108,18 +108,20 @@ static int run_git(const char *arg, ...) return res; } -static int set_recommended_config(void) +static int set_recommended_config(int reconfigure) { struct { const char *key; const char *value; + int overwrite_on_reconfigure; } config[] = { - { "am.keepCR", "true" }, - { "core.FSCache", "true" }, - { "core.multiPackIndex", "true" }, - { "core.preloadIndex", "true" }, + /* Required */ + { "am.keepCR", "true", 1 }, + { "core.FSCache", "true", 1 }, + { "core.multiPackIndex", "true", 1 }, + { "core.preloadIndex", "true", 1 }, #ifndef WIN32 - { "core.untrackedCache", "true" }, + { "core.untrackedCache", "true", 1 }, #else /* * Unfortunately, Scalar's Functional Tests demonstrated @@ -133,28 +135,29 @@ static int set_recommended_config(void) * Therefore, with a sad heart, we disable this very useful * feature on Windows. */ - { "core.untrackedCache", "false" }, + { "core.untrackedCache", "false", 1 }, #endif - { "core.logAllRefUpdates", "true" }, - { "credential.https://dev.azure.com.useHttpPath", "true" }, - { "credential.validate", "false" }, /* GCM4W-only */ - { "gc.auto", "0" }, - { "gui.GCWarning", "false" }, - { "index.threads", "true" }, - { "index.version", "4" }, - { "merge.stat", "false" }, - { "merge.renames", "false" }, - { "pack.useBitmaps", "false" }, - { "pack.useSparse", "true" }, - { "receive.autoGC", "false" }, - { "reset.quiet", "true" }, - { "feature.manyFiles", "false" }, - { "feature.experimental", "false" }, - { "fetch.unpackLimit", "1" }, - { "fetch.writeCommitGraph", "false" }, + { "core.logAllRefUpdates", "true", 1 }, + { "credential.https://dev.azure.com.useHttpPath", "true", 1 }, + { "credential.validate", "false", 1 }, /* GCM4W-only */ + { "gc.auto", "0", 1 }, + { "gui.GCWarning", "false", 1 }, + { "index.threads", "true", 1 }, + { "index.version", "4", 1 }, + { "merge.stat", "false", 1 }, + { "merge.renames", "false", 1 }, + { "pack.useBitmaps", "false", 1 }, + { "pack.useSparse", "true", 1 }, + { "receive.autoGC", "false", 1 }, + { "reset.quiet", "true", 1 }, + { "feature.manyFiles", "false", 1 }, + { "feature.experimental", "false", 1 }, + { "fetch.unpackLimit", "1", 1 }, + { "fetch.writeCommitGraph", "false", 1 }, #ifdef WIN32 - { "http.sslBackend", "schannel" }, + { "http.sslBackend", "schannel", 1 }, #endif + /* Optional */ { "status.aheadBehind", "false" }, { "commitGraph.generationVersion", "1" }, { "core.autoCRLF", "false" }, @@ -166,7 +169,8 @@ static int set_recommended_config(void) char *value; for (i = 0; config[i].key; i++) { - if (git_config_get_string(config[i].key, &value)) { + if ((reconfigure && config[i].overwrite_on_reconfigure) || + git_config_get_string(config[i].key, &value)) { trace2_data_string("scalar", the_repository, config[i].key, "created"); if (git_config_set_gently(config[i].key, config[i].value) < 0) @@ -231,7 +235,7 @@ static int register_dir(void) int res = add_or_remove_enlistment(1); if (!res) - res = set_recommended_config(); + res = set_recommended_config(0); if (!res) res = toggle_maintenance(1); @@ -419,7 +423,7 @@ static int cmd_clone(int argc, const char **argv) (res = run_git("sparse-checkout", "init", "--cone", NULL))) goto cleanup; - if (set_recommended_config()) + if (set_recommended_config(0)) return error(_("could not configure '%s'"), dir); if ((res = run_git("fetch", "--quiet", "origin", NULL))) { @@ -484,6 +488,24 @@ static int cmd_register(int argc, const char **argv) return register_dir(); } +static int cmd_reconfigure(int argc, const char **argv) +{ + struct option options[] = { + OPT_END(), + }; + const char * const usage[] = { + N_("scalar reconfigure []"), + NULL + }; + + argc = parse_options(argc, argv, NULL, options, + usage, 0); + + setup_enlistment_directory(argc, argv, usage, options, NULL); + + return set_recommended_config(1); +} + static int cmd_run(int argc, const char **argv) { struct option options[] = { @@ -620,6 +642,7 @@ static struct { { "register", cmd_register }, { "unregister", cmd_unregister }, { "run", cmd_run }, + { "reconfigure", cmd_reconfigure }, { NULL, NULL}, }; diff --git a/contrib/scalar/scalar.txt b/contrib/scalar/scalar.txt index 39143b08324..89fd7901585 100644 --- a/contrib/scalar/scalar.txt +++ b/contrib/scalar/scalar.txt @@ -13,6 +13,7 @@ scalar list scalar register [] scalar unregister [] scalar run ( all | config | commit-graph | fetch | loose-objects | pack-files ) [] +scalar reconfigure DESCRIPTION ----------- @@ -117,6 +118,13 @@ opinionated default settings that make Git work more efficiently with large repositories. As this task is run as part of `scalar clone` automatically, explicit invocations of this task are rarely needed. +Reconfigure +~~~~~~~~~~~ + +After a Scalar upgrade, or when the configuration of a Scalar enlistment +was somehow corrupted or changed by mistake, this subcommand allows to +reconfigure the enlistment. + SEE ALSO -------- linkgit:git-clone[1], linkgit:git-maintenance[1]. diff --git a/contrib/scalar/t/t9099-scalar.sh b/contrib/scalar/t/t9099-scalar.sh index f60e086d6f9..fb5e2efee0a 100755 --- a/contrib/scalar/t/t9099-scalar.sh +++ b/contrib/scalar/t/t9099-scalar.sh @@ -65,4 +65,12 @@ test_expect_success 'scalar clone' ' ) ' +test_expect_success 'scalar reconfigure' ' + git init one/src && + scalar register one && + git -C one/src config core.preloadIndex false && + scalar reconfigure one && + test true = "$(git -C one/src config core.preloadIndex)" +' + test_done From patchwork Fri Nov 19 23:03:42 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629731 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B87F9C433F5 for ; Fri, 19 Nov 2021 23:04:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235417AbhKSXHH (ORCPT ); Fri, 19 Nov 2021 18:07:07 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35242 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235289AbhKSXHB (ORCPT ); Fri, 19 Nov 2021 18:07:01 -0500 Received: from mail-wm1-x32e.google.com (mail-wm1-x32e.google.com [IPv6:2a00:1450:4864:20::32e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 24228C061574 for ; Fri, 19 Nov 2021 15:03:58 -0800 (PST) Received: by mail-wm1-x32e.google.com with SMTP id 67-20020a1c1946000000b0030d4c90fa87so8638365wmz.2 for ; Fri, 19 Nov 2021 15:03:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=vm/dhDtJBmVuRxe+hDMgC9L6CFNXEm12z46YWE+zzbA=; b=MATMaCHhsmZxeY0tZOCRRdcLc9k0XcJE36C0BIVOZD3xFdVg31i1LzofLgeaHVouJ/ V6NVghbLEloogTTmhtvsn1UnwF7+9u4VSX3yan3cYQyAH3Cr6gY/hvw7CpWCOR8GC+t/ No0QQrBrR/BuKExIW+UZyILXHpmiCDYq7uBxXIls8AF5qTMpB9T60XwDdi78eMjm4Chm TOTxg+PRL630FUCH0U9+//4xZDOQYxX6gONq3KDBVebWOV7bVzxF9Sy2OFINKuU+uv0k +vY85iD+tGGYZSICrXerXZc9E7hVTcs5whoISP70VwPPCuyISsWWOTdDWxpG9I5KmF2V +bJw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=vm/dhDtJBmVuRxe+hDMgC9L6CFNXEm12z46YWE+zzbA=; b=i+sBjyY0iylbBL5JBAu6NQg1cbtqBkroJMJzL1k+c/7n/jlJ++AUnz5BLfq6n/HiFM KpGJzoWMyuHzhxaKqjHHKO+ZrwIfzjcsp/rNbVoauAK7oMSR2qC2FOH5im0wwQ2rYH7B 84qa+wRtnaIxLvjBdmDnbvsKKWIlwE9mRY15tzode9XKkmjbeahSjINedyF0fxsfHjQM 2iowVOEHL70fNstNqgvk0zzhRKaomms2tpakc65bAetmVKzUvXHYdUvvqio2mTRelV+J w/L9UBYqrMTVM6BT8AYRch4gNaDec9YWqV5zxnOup6XFEUEJxLu6MX0A2yKxYHcLWpQi bnZw== X-Gm-Message-State: AOAM532OJaYvpwHwBfkK5g3jePqmDRaku9qSvld4RWHwQKOSQ1zUOKeK 6Ug1AEML7bPSe3thCFzA3kRJzQ4R/Ok= X-Google-Smtp-Source: ABdhPJxF0F1/jg/xNuCmrF6s2vgeL2CNRCvOfjNUG9BT8pFub7W02yTZePAqYk9NLtcjVr+mr23TEw== X-Received: by 2002:a05:600c:1d91:: with SMTP id p17mr4258851wms.193.1637363036410; Fri, 19 Nov 2021 15:03:56 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id j40sm15903796wms.19.2021.11.19.15.03.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:55 -0800 (PST) Message-Id: In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:42 +0000 Subject: [PATCH v8 15/17] scalar: teach 'reconfigure' to optionally handle all registered enlistments Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin After a Scalar upgrade, it can come in really handy if there is an easy way to reconfigure all Scalar enlistments. This new option offers this functionality. Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 61 ++++++++++++++++++++++++++++++-- contrib/scalar/scalar.txt | 9 +++-- contrib/scalar/t/t9099-scalar.sh | 3 ++ 3 files changed, 67 insertions(+), 6 deletions(-) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index b799decbc2f..71ca573f3af 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -488,22 +488,77 @@ static int cmd_register(int argc, const char **argv) return register_dir(); } +static int get_scalar_repos(const char *key, const char *value, void *data) +{ + struct string_list *list = data; + + if (!strcmp(key, "scalar.repo")) + string_list_append(list, value); + + return 0; +} + static int cmd_reconfigure(int argc, const char **argv) { + int all = 0; struct option options[] = { + OPT_BOOL('a', "all", &all, + N_("reconfigure all registered enlistments")), OPT_END(), }; const char * const usage[] = { - N_("scalar reconfigure []"), + N_("scalar reconfigure [--all | ]"), NULL }; + struct string_list scalar_repos = STRING_LIST_INIT_DUP; + int i, res = 0; + struct repository r = { NULL }; + struct strbuf commondir = STRBUF_INIT, gitdir = STRBUF_INIT; argc = parse_options(argc, argv, NULL, options, usage, 0); - setup_enlistment_directory(argc, argv, usage, options, NULL); + if (!all) { + setup_enlistment_directory(argc, argv, usage, options, NULL); + + return set_recommended_config(1); + } + + if (argc > 0) + usage_msg_opt(_("--all or , but not both"), + usage, options); + + git_config(get_scalar_repos, &scalar_repos); - return set_recommended_config(1); + for (i = 0; i < scalar_repos.nr; i++) { + const char *dir = scalar_repos.items[i].string; + + strbuf_reset(&commondir); + strbuf_reset(&gitdir); + + if (chdir(dir) < 0) { + warning_errno(_("could not switch to '%s'"), dir); + res = -1; + } else if (discover_git_directory(&commondir, &gitdir) < 0) { + warning_errno(_("git repository gone in '%s'"), dir); + res = -1; + } else { + git_config_clear(); + + the_repository = &r; + r.commondir = commondir.buf; + r.gitdir = gitdir.buf; + + if (set_recommended_config(1) < 0) + res = -1; + } + } + + string_list_clear(&scalar_repos, 1); + strbuf_release(&commondir); + strbuf_release(&gitdir); + + return res; } static int cmd_run(int argc, const char **argv) diff --git a/contrib/scalar/scalar.txt b/contrib/scalar/scalar.txt index 89fd7901585..737cf563c1a 100644 --- a/contrib/scalar/scalar.txt +++ b/contrib/scalar/scalar.txt @@ -13,7 +13,7 @@ scalar list scalar register [] scalar unregister [] scalar run ( all | config | commit-graph | fetch | loose-objects | pack-files ) [] -scalar reconfigure +scalar reconfigure [ --all | ] DESCRIPTION ----------- @@ -32,8 +32,8 @@ an existing Git worktree with Scalar whose name is not `src`, the enlistment will be identical to the worktree. The `scalar` command implements various subcommands, and different options -depending on the subcommand. With the exception of `clone` and `list`, all -subcommands expect to be run in an enlistment. +depending on the subcommand. With the exception of `clone`, `list` and +`reconfigure --all`, all subcommands expect to be run in an enlistment. COMMANDS -------- @@ -125,6 +125,9 @@ After a Scalar upgrade, or when the configuration of a Scalar enlistment was somehow corrupted or changed by mistake, this subcommand allows to reconfigure the enlistment. +With the `--all` option, all enlistments currently registered with Scalar +will be reconfigured. Use this option after each Scalar upgrade. + SEE ALSO -------- linkgit:git-clone[1], linkgit:git-maintenance[1]. diff --git a/contrib/scalar/t/t9099-scalar.sh b/contrib/scalar/t/t9099-scalar.sh index fb5e2efee0a..58af546fd84 100755 --- a/contrib/scalar/t/t9099-scalar.sh +++ b/contrib/scalar/t/t9099-scalar.sh @@ -70,6 +70,9 @@ test_expect_success 'scalar reconfigure' ' scalar register one && git -C one/src config core.preloadIndex false && scalar reconfigure one && + test true = "$(git -C one/src config core.preloadIndex)" && + git -C one/src config core.preloadIndex false && + scalar reconfigure -a && test true = "$(git -C one/src config core.preloadIndex)" ' From patchwork Fri Nov 19 23:03:43 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Matthew John Cheetham X-Patchwork-Id: 12629733 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id AFE59C433FE for ; Fri, 19 Nov 2021 23:04:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235541AbhKSXHI (ORCPT ); Fri, 19 Nov 2021 18:07:08 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35208 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235538AbhKSXHB (ORCPT ); Fri, 19 Nov 2021 18:07:01 -0500 Received: from mail-wr1-x42c.google.com (mail-wr1-x42c.google.com [IPv6:2a00:1450:4864:20::42c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id EA83BC061759 for ; Fri, 19 Nov 2021 15:03:58 -0800 (PST) Received: by mail-wr1-x42c.google.com with SMTP id a9so20635003wrr.8 for ; Fri, 19 Nov 2021 15:03:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=9DF8xacLLxcfovMqJ/eqpmiu+Qris70HYXyQdV96HVg=; b=VDwyIaiOfVX3unfQtIeJGVMi6vdRk+yH9xfHsgo7QL+aQj05TmvdxfiYvU8EE/m0Qv IB4bYMApYE93WrcZXatBwQTnAhZaYL0ny0hqSL/U7NGttmeW38WqmcIjW85x3eo/J8Hd zlBbOSt7jKXguKejwoW4xVDNgLNE6igfufG6G7pWzgdSNjeKzy9btWA5UDEi7LGvpPXP Y/VcG2CS0bem7i+DPZqIqKxNmRzEjPFnsqHc0tHUDMoMjOTwtFdslaY5qc+QYDXnWZ6k CnLs246u1X4nrsZvidDQc6MWLNhGmZeP/lhhyqdIHxnKCvF+uFWJQMnAOdTfD9Mk1Ebe FZHA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=9DF8xacLLxcfovMqJ/eqpmiu+Qris70HYXyQdV96HVg=; b=uJdNoM4XOZb6wt37eaaqxDiO3hbem+u6AlE5wOZQ95gwTLZSlczigcSns8KQA0XzRY Y/G29LW1NH3KJgg8BLOXJymwoTRgLnajq183H3Epv4LxYhVkiTjJ7rvHFZsA6SHR31Ie XxSeEBCd51MV2S3JfL6SFpniKXiXOTJf3mNUkkzekXg3Pds2fpC5lbA9i1G37MLfN4Pj L9oRZkPZ91n/F3JYme5vzRmxvhlteMQ1/iL0uMMWokxl4sSVJ36SwBrNOuhzcyMwqhPh owjtv9kKelDWYeZ9WOMRSKxxUUtaGNMQLX1wyt802CVpfs6O2eoWEMQcAjhK/b8tnDqB w08A== X-Gm-Message-State: AOAM5337NXMc8+CBBOTVYBsMLhuvS796eW/NJTx7UDkPF8PIEQKo3B+J cRnSLpCSNR3LZ8EYyoTBoCmueXujJSk= X-Google-Smtp-Source: ABdhPJxknrHvx2qcQJx7gI5uFrCVtIsBcDkHxXOiPF2FTzN9ZSrXwISpm+LvA76VyUdMxGZMNObT1Q== X-Received: by 2002:adf:f08d:: with SMTP id n13mr12368459wro.395.1637363037300; Fri, 19 Nov 2021 15:03:57 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id p19sm1168478wmq.4.2021.11.19.15.03.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:56 -0800 (PST) Message-Id: <9983eb8912c6deede05282af617c0ede3ea52f58.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:43 +0000 Subject: [PATCH v8 16/17] scalar: implement the `delete` command Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Matthew John Cheetham Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Matthew John Cheetham From: Matthew John Cheetham Delete an enlistment by first unregistering the repository and then deleting the enlistment directory (usually the directory containing the worktree `src/` directory). On Windows, if the current directory is inside the enlistment's directory, change to the parent of the enlistment directory, to allow us to delete the enlistment (directories used by processes e.g. as current working directories cannot be deleted on Windows). Co-authored-by: Victoria Dye Signed-off-by: Matthew John Cheetham Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 63 ++++++++++++++++++++++++++++++++ contrib/scalar/scalar.txt | 8 ++++ contrib/scalar/t/t9099-scalar.sh | 9 +++++ 3 files changed, 80 insertions(+) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index 71ca573f3af..c53697ad6a0 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -8,6 +8,8 @@ #include "config.h" #include "run-command.h" #include "refs.h" +#include "dir.h" +#include "packfile.h" /* * Remove the deepest subdirectory in the provided path string. Path must not @@ -328,6 +330,33 @@ static char *remote_default_branch(const char *url) return NULL; } +static int delete_enlistment(struct strbuf *enlistment) +{ +#ifdef WIN32 + struct strbuf parent = STRBUF_INIT; +#endif + + if (unregister_dir()) + die(_("failed to unregister repository")); + +#ifdef WIN32 + /* + * Change the current directory to one outside of the enlistment so + * that we may delete everything underneath it. + */ + strbuf_addbuf(&parent, enlistment); + strbuf_parent_directory(&parent); + if (chdir(parent.buf) < 0) + die_errno(_("could not switch to '%s'"), parent.buf); + strbuf_release(&parent); +#endif + + if (remove_dir_recursively(enlistment, 0)) + die(_("failed to delete enlistment directory")); + + return 0; +} + static int cmd_clone(int argc, const char **argv) { const char *branch = NULL; @@ -688,6 +717,39 @@ static int cmd_unregister(int argc, const char **argv) return unregister_dir(); } +static int cmd_delete(int argc, const char **argv) +{ + char *cwd = xgetcwd(); + struct option options[] = { + OPT_END(), + }; + const char * const usage[] = { + N_("scalar delete "), + NULL + }; + struct strbuf enlistment = STRBUF_INIT; + int res = 0; + + argc = parse_options(argc, argv, NULL, options, + usage, 0); + + if (argc != 1) + usage_with_options(usage, options); + + setup_enlistment_directory(argc, argv, usage, options, &enlistment); + + if (dir_inside_of(cwd, enlistment.buf) >= 0) + res = error(_("refusing to delete current working directory")); + else { + close_object_store(the_repository->objects); + res = delete_enlistment(&enlistment); + } + strbuf_release(&enlistment); + free(cwd); + + return res; +} + static struct { const char *name; int (*fn)(int, const char **); @@ -698,6 +760,7 @@ static struct { { "unregister", cmd_unregister }, { "run", cmd_run }, { "reconfigure", cmd_reconfigure }, + { "delete", cmd_delete }, { NULL, NULL}, }; diff --git a/contrib/scalar/scalar.txt b/contrib/scalar/scalar.txt index 737cf563c1a..f416d637289 100644 --- a/contrib/scalar/scalar.txt +++ b/contrib/scalar/scalar.txt @@ -14,6 +14,7 @@ scalar register [] scalar unregister [] scalar run ( all | config | commit-graph | fetch | loose-objects | pack-files ) [] scalar reconfigure [ --all | ] +scalar delete DESCRIPTION ----------- @@ -128,6 +129,13 @@ reconfigure the enlistment. With the `--all` option, all enlistments currently registered with Scalar will be reconfigured. Use this option after each Scalar upgrade. +Delete +~~~~~~ + +delete :: + This subcommand lets you delete an existing Scalar enlistment from your + local file system, unregistering the repository. + SEE ALSO -------- linkgit:git-clone[1], linkgit:git-maintenance[1]. diff --git a/contrib/scalar/t/t9099-scalar.sh b/contrib/scalar/t/t9099-scalar.sh index 58af546fd84..2e1502ad45e 100755 --- a/contrib/scalar/t/t9099-scalar.sh +++ b/contrib/scalar/t/t9099-scalar.sh @@ -76,4 +76,13 @@ test_expect_success 'scalar reconfigure' ' test true = "$(git -C one/src config core.preloadIndex)" ' +test_expect_success 'scalar delete without enlistment shows a usage' ' + test_expect_code 129 scalar delete +' + +test_expect_success 'scalar delete with enlistment' ' + scalar delete cloned && + test_path_is_missing cloned +' + test_done From patchwork Fri Nov 19 23:03:44 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Johannes Schindelin X-Patchwork-Id: 12629735 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CA087C433EF for ; Fri, 19 Nov 2021 23:04:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235790AbhKSXHK (ORCPT ); Fri, 19 Nov 2021 18:07:10 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35216 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235233AbhKSXHC (ORCPT ); Fri, 19 Nov 2021 18:07:02 -0500 Received: from mail-wr1-x42f.google.com (mail-wr1-x42f.google.com [IPv6:2a00:1450:4864:20::42f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id DA5A0C06175E for ; Fri, 19 Nov 2021 15:03:59 -0800 (PST) Received: by mail-wr1-x42f.google.com with SMTP id c4so20603101wrd.9 for ; Fri, 19 Nov 2021 15:03:59 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:in-reply-to:references:from:date:subject:fcc :content-transfer-encoding:mime-version:to:cc; bh=2WSVpdckOKo8sTzLhexO457CfG7Z/d/GCqQg3H5ly1Q=; b=FHmglD+93qL8l5tA4AGRndNdqnjtUraulyRzPpHbokIRPQkq3x/gbHhNor+Md64DPW Qad9v599pOxjWdjj7bw00o4+YKQbQD6unfqBX/aDImKsxHo0oddeNHxVnGeTO4M0vbYA JxJS6AzSjavoJHuC6Qcpsor7MVmZgPVSv6jIT5OURHaM76CtYsQWyMLIjJLk3K/c7hsh N/J0A5tcxeT4wgztbjsIVGcVhAXBJ/buE7DnULkJ/4+4M7XQi+ONLvP0R7iy1pXEpY9Q W3NvJhKxNy2cD6xwLZkNsgh4MIBrSO6EbPqkc8pvReEEkCJeSiHrvnBR6tlzmnzkS8Gx U2jg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:in-reply-to:references:from:date :subject:fcc:content-transfer-encoding:mime-version:to:cc; bh=2WSVpdckOKo8sTzLhexO457CfG7Z/d/GCqQg3H5ly1Q=; b=jZzE6e+Mv2YXk4oeOzy+ponRSrfh+fl5krPj3NZ4TX96LMRGNbyt/Ogw/H5QPDM9kU 0RL1nQJmuxkeguwXHNqQqfTXQ0qjafOBLuyDbB+jYXQt6nl303SVK8Dwb3uvZzREYj6y q/CTCf31IwSZsKGqQ7XE9IcOYY9F3zwfPIBQIHbRdUP2grl6WqKcwOcJk88/sSjflYfL EQMiGifzEk/98je2fQQXaBJSrKK5SQoq2/jkHj5S8a5hkmbQtLIf3HPMssfgngeWd2vx H7yyIPpyu2JaL5wRW8u99kZ90SuAZLUjEubdaDKcUBBXayt+mf1RRM4nSOiLFu4g9rsB Y6Fw== X-Gm-Message-State: AOAM532jJzqT6qYHmA0+7mdTOTFwVF8xZ/CMWwbRf87nGmwTHMXO5AK3 Q7JxECMw2O8YuQttl4GZ3MnLJP1Uz2A= X-Google-Smtp-Source: ABdhPJz9ZjoaEOpLiV9sUXEPa13DFPzUv3Z0/x3t/wkFpSNNTStEEFIkuqxfZoNugF2s5Bqs600zRg== X-Received: by 2002:adf:ee4b:: with SMTP id w11mr11882442wro.115.1637363038301; Fri, 19 Nov 2021 15:03:58 -0800 (PST) Received: from [127.0.0.1] ([13.74.141.28]) by smtp.gmail.com with ESMTPSA id p13sm13541008wmi.0.2021.11.19.15.03.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 19 Nov 2021 15:03:57 -0800 (PST) Message-Id: <889f613ab188bdc883d85f40988a3eda2dad19a5.1637363025.git.gitgitgadget@gmail.com> In-Reply-To: References: Date: Fri, 19 Nov 2021 23:03:44 +0000 Subject: [PATCH v8 17/17] scalar: implement the `version` command Fcc: Sent MIME-Version: 1.0 To: git@vger.kernel.org Cc: Derrick Stolee , Eric Sunshine , =?utf-8?b?w4Z2YXIgQXJuZmrDtnLDsA==?= Bjarmason , Elijah Newren , Bagas Sanjaya , Theodore Ts'o , Matt Rogers , Johannes Schindelin , Johannes Schindelin Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org From: Johannes Schindelin From: Johannes Schindelin The .NET version of Scalar has a `version` command. This was necessary because it was versioned independently of Git. Since Scalar is now tightly coupled with Git, it does not make sense for them to show different versions. Therefore, it shows the same output as `git version`. For backwards-compatibility with the .NET version, `scalar version` prints to `stderr`, though (`git version` prints to `stdout` instead). Signed-off-by: Johannes Schindelin --- contrib/scalar/scalar.c | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/contrib/scalar/scalar.c b/contrib/scalar/scalar.c index c53697ad6a0..1fc4965bebb 100644 --- a/contrib/scalar/scalar.c +++ b/contrib/scalar/scalar.c @@ -10,6 +10,7 @@ #include "refs.h" #include "dir.h" #include "packfile.h" +#include "help.h" /* * Remove the deepest subdirectory in the provided path string. Path must not @@ -357,6 +358,15 @@ static int delete_enlistment(struct strbuf *enlistment) return 0; } +/* + * Dummy implementation; Using `get_version_info()` would cause a link error + * without this. + */ +void load_builtin_commands(const char *prefix, struct cmdnames *cmds) +{ + die("not implemented"); +} + static int cmd_clone(int argc, const char **argv) { const char *branch = NULL; @@ -750,6 +760,34 @@ static int cmd_delete(int argc, const char **argv) return res; } +static int cmd_version(int argc, const char **argv) +{ + int verbose = 0, build_options = 0; + struct option options[] = { + OPT__VERBOSE(&verbose, N_("include Git version")), + OPT_BOOL(0, "build-options", &build_options, + N_("include Git's build options")), + OPT_END(), + }; + const char * const usage[] = { + N_("scalar verbose [-v | --verbose] [--build-options]"), + NULL + }; + struct strbuf buf = STRBUF_INIT; + + argc = parse_options(argc, argv, NULL, options, + usage, 0); + + if (argc != 0) + usage_with_options(usage, options); + + get_version_info(&buf, build_options); + fprintf(stderr, "%s\n", buf.buf); + strbuf_release(&buf); + + return 0; +} + static struct { const char *name; int (*fn)(int, const char **); @@ -761,6 +799,7 @@ static struct { { "run", cmd_run }, { "reconfigure", cmd_reconfigure }, { "delete", cmd_delete }, + { "version", cmd_version }, { NULL, NULL}, };