This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12611

auto-upgrade: introduce a way to auto-upgrade to/from share-safe
ClosedPublic

Authored by marmoute on Fri, May 6, 4:37 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHG2ab79873786e: auto-upgrade: introduce a way to auto-upgrade to/from share-safe
Summary

This is the first "automatic-upgrade" capability. In the following commits,
similar features are coming for other "fast to upgrade" formats.

This is different from the safe-mismatch.source-not-safe and
safe-mismatch.source-safe configuration that deal with mismatch between a
share and its share-source. Here we are dealing with mismatch between a
repository configuration and its actual format.

We will need further work for cases were the repository cannot be locked. A
basic protection is in place to avoid a infinite loop for now, but it will get
proper attention in a later changeset.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

marmoute created this revision.Fri, May 6, 4:37 AM
Alphare accepted this revision.Tue, May 17, 11:53 AM
Alphare added a subscriber: Alphare.

Will amend typos on-the-fly

This revision is now accepted and ready to land.Tue, May 17, 11:53 AM
baymax edited the summary of this revision. (Show Details)Thu, May 19, 6:36 AM
baymax updated this revision to Diff 33409.

✅ refresh by Heptapod after a successful CI run (🐙 💚)

baymax updated this revision to Diff 33424.Tue, May 24, 10:33 AM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

Diff 33424

mercurial/configitems.py

) )
coreconfigitem( coreconfigitem(
b'format', b'format',
b'use-share-safe', b'use-share-safe',
default=True, default=True,
) )
coreconfigitem( coreconfigitem(
b'format', b'format',
b'use-share-safe.automatic-upgrade-of-mismatching-repositories',
default=False,
experimental=True,
)
coreconfigitem(
b'format',
b'internal-phase', b'internal-phase',
default=False, default=False,
experimental=True, experimental=True,
) )
coreconfigitem( coreconfigitem(
b'fsmonitor', b'fsmonitor',
b'warn_when_unused', b'warn_when_unused',
default=True, default=True,

mercurial/helptext/config.txt

default, Mercurial will refuse to interact with them until the mismatch default, Mercurial will refuse to interact with them until the mismatch
is resolved. See :hg:`help config.share.safe-mismatch.source-safe` and is resolved. See :hg:`help config.share.safe-mismatch.source-safe` and
:hg:`help config.share.safe-mismatch.source-not-safe` for details. :hg:`help config.share.safe-mismatch.source-not-safe` for details.
Introduced in Mercurial 5.7. Introduced in Mercurial 5.7.
Enabled by default in Mercurial 6.1. Enabled by default in Mercurial 6.1.
``use-share-safe.automatic-upgrade-of-mismatching-repositories``
When enabled, an automatic upgrade will be triggered when a repository format
does not match its `use-share-safe` config.
This is an advanced behavior that most users will not need. We recommend you
don't use this unless you are a seasoned administrator of a Mercurial install
base.
Automatic upgrade means that any process accessing the repository will
upgrade the repository format to use `share-safe`. This only triggers if a
change is needed. This also applies to operation that would have been
read-only (like hg status).
This configuration will apply for moves in any direction, either adding the
`share-safe` format if `format.use-share-safe=yes` or removing the
`share-safe` requirement if `format.use-share-safe=no`. So we recommend
setting both this value and `format.use-share-safe` at the same time.
``usestore`` ``usestore``
Enable or disable the "store" repository format which improves Enable or disable the "store" repository format which improves
compatibility with systems that fold case or otherwise mangle compatibility with systems that fold case or otherwise mangle
filenames. Disabling this option will allow you to store longer filenames filenames. Disabling this option will allow you to store longer filenames
in some situations at the expense of compatibility. in some situations at the expense of compatibility.
Repositories with this on-disk format require Mercurial version 0.9.4. Repositories with this on-disk format require Mercurial version 0.9.4.

mercurial/localrepo.py

def undoname(fn): def undoname(fn):
base, name = os.path.split(fn) base, name = os.path.split(fn)
assert name.startswith(b'journal') assert name.startswith(b'journal')
return os.path.join(base, name.replace(b'journal', b'undo', 1)) return os.path.join(base, name.replace(b'journal', b'undo', 1))
def instance(ui, path, create, intents=None, createopts=None): def instance(ui, path, create, intents=None, createopts=None):
# prevent cyclic import localrepo -> upgrade -> localrepo
from . import upgrade
localpath = urlutil.urllocalpath(path) localpath = urlutil.urllocalpath(path)
if create: if create:
createrepository(ui, localpath, createopts=createopts) createrepository(ui, localpath, createopts=createopts)
def repo_maker():
return makelocalrepository(ui, localpath, intents=intents) return makelocalrepository(ui, localpath, intents=intents)
repo = repo_maker()
repo = upgrade.may_auto_upgrade(repo, repo_maker)
return repo
def islocal(path): def islocal(path):
return True return True
def defaultcreateopts(ui, createopts=None): def defaultcreateopts(ui, createopts=None):
"""Populate the default creation options for a repository. """Populate the default creation options for a repository.

mercurial/upgrade.py

lock as lockmod, lock as lockmod,
pycompat, pycompat,
requirements as requirementsmod, requirements as requirementsmod,
scmutil, scmutil,
) )
from .upgrade_utils import ( from .upgrade_utils import (
actions as upgrade_actions, actions as upgrade_actions,
auto_upgrade,
engine as upgrade_engine, engine as upgrade_engine,
) )
from .utils import ( from .utils import (
stringutil, stringutil,
) )
may_auto_upgrade = auto_upgrade.may_auto_upgrade
allformatvariant = upgrade_actions.allformatvariant allformatvariant = upgrade_actions.allformatvariant
def upgraderepo( def upgraderepo(
ui, ui,
repo, repo,
run=False, run=False,
optimize=None, optimize=None,

mercurial/upgrade_utils/auto_upgrade.py

  • This file was added.
# upgrade.py - functions for automatic upgrade of Mercurial repository
#
# Copyright (c) 2022-present, Pierre-Yves David
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
from ..i18n import _
from .. import (
error,
requirements as requirementsmod,
scmutil,
)
def get_share_safe_action(repo):
"""return an automatic-upgrade action for `share-safe` if applicable
If no action is needed, return None, otherwise return a callback to upgrade
or downgrade the repository according the configuration and repository
format.
"""
ui = repo.ui
requirements = repo.requirements
auto_upgrade_share_source = ui.configbool(
b'format',
b'use-share-safe.automatic-upgrade-of-mismatching-repositories',
)
action = None
if (
auto_upgrade_share_source
and requirementsmod.SHARED_REQUIREMENT not in requirements
):
sf_config = ui.configbool(b'format', b'use-share-safe')
sf_local = requirementsmod.SHARESAFE_REQUIREMENT in requirements
if sf_config and not sf_local:
msg = _(
b"automatically upgrading repository to the `share-safe`"
b" feature\n"
)
hint = b"(see `hg help config.format.use-share-safe` for details)\n"
def action():
if not ui.quiet:
ui.write_err(msg)
ui.write_err(hint)
requirements.add(requirementsmod.SHARESAFE_REQUIREMENT)
scmutil.writereporequirements(repo, requirements)
elif sf_local and not sf_config:
msg = _(
b"automatically downgrading repository from the `share-safe`"
b" feature\n"
)
hint = b"(see `hg help config.format.use-share-safe` for details)\n"
def action():
if not ui.quiet:
ui.write_err(msg)
ui.write_err(hint)
requirements.discard(requirementsmod.SHARESAFE_REQUIREMENT)
scmutil.writereporequirements(repo, requirements)
return action
AUTO_UPGRADE_ACTIONS = [
get_share_safe_action,
]
def may_auto_upgrade(repo, maker_func):
"""potentially perform auto-upgrade and return the final repository to use
Auto-upgrade are "quick" repository upgrade that might automatically be run
by "any" repository access. See `hg help config.format` for automatic
upgrade documentation.
note: each relevant upgrades are done one after the other for simplicity.
This avoid having repository is partially inconsistent state while
upgrading.
repo: the current repository instance
maker_func: a factory function that can recreate a repository after an upgrade
"""
clear = False
loop = 0
while not clear:
loop += 1
if loop > 100:
# XXX basic protection against infinite loop, make it better.
raise error.ProgrammingError("Too many auto upgrade loops")
clear = True
for get_action in AUTO_UPGRADE_ACTIONS:
action = get_action(repo)
if action is not None:
clear = False
with repo.wlock(wait=False), repo.lock(wait=False):
action = get_action(repo)
if action is not None:
action()
repo = maker_func()
return repo

rust/rhg/src/main.rs

extern crate log; extern crate log;
use crate::error::CommandError; use crate::error::CommandError;
use crate::ui::{local_to_utf8, Ui}; use crate::ui::{local_to_utf8, Ui};
use clap::App; use clap::App;
use clap::AppSettings; use clap::AppSettings;
use clap::Arg; use clap::Arg;
use clap::ArgMatches; use clap::ArgMatches;
use format_bytes::{format_bytes, join}; use format_bytes::{format_bytes, join};
use hg::config::{Config, ConfigSource}; use hg::config::{Config, ConfigSource};
use hg::exit_codes;
use hg::repo::{Repo, RepoError}; use hg::repo::{Repo, RepoError};
use hg::utils::files::{get_bytes_from_os_str, get_path_from_bytes}; use hg::utils::files::{get_bytes_from_os_str, get_path_from_bytes};
use hg::utils::SliceExt; use hg::utils::SliceExt;
use hg::{exit_codes, requirements};
use std::collections::HashSet; use std::collections::HashSet;
use std::ffi::OsString; use std::ffi::OsString;
use std::os::unix::prelude::CommandExt; use std::os::unix::prelude::CommandExt;
use std::path::PathBuf; use std::path::PathBuf;
use std::process::Command; use std::process::Command;
mod blackbox; mod blackbox;
mod color; mod color;
message: format_bytes!( message: format_bytes!(
b"extensions: {} (consider adding them to 'rhg.ignored-extensions' config)", b"extensions: {} (consider adding them to 'rhg.ignored-extensions' config)",
join(unsupported, b", ") join(unsupported, b", ")
), ),
}) })
} }
} }
/// Array of tuples of (auto upgrade conf, feature conf, local requirement)
const AUTO_UPGRADES: &[((&str, &str), (&str, &str), &str)] = &[
(
("format", "use-share-safe.automatic-upgrade-of-mismatching-repositories"),
("format", "use-share-safe"),
requirements::SHARESAFE_REQUIREMENT,
),
];
/// Mercurial allows users to automatically upgrade their repository.
/// `rhg` does not have the ability to upgrade yet, so fallback if an upgrade
/// is needed.
fn check_auto_upgrade(
config: &Config,
reqs: &HashSet<String>,
) -> Result<(), CommandError> {
for (upgrade_conf, feature_conf, local_req) in AUTO_UPGRADES.iter() {
let auto_upgrade = config
.get_bool(upgrade_conf.0.as_bytes(), upgrade_conf.1.as_bytes())?;
if auto_upgrade {
let want_it = config.get_bool(
feature_conf.0.as_bytes(),
feature_conf.1.as_bytes(),
)?;
let have_it = reqs.contains(*local_req);
let action = match (want_it, have_it) {
(true, false) => Some("upgrade"),
(false, true) => Some("downgrade"),
_ => None,
};
if let Some(action) = action {
let message = format!(
"automatic {} {}.{}",
action, upgrade_conf.0, upgrade_conf.1
);
return Err(CommandError::unsupported(message));
}
}
}
Ok(())
}
fn check_unsupported( fn check_unsupported(
config: &Config, config: &Config,
repo: Result<&Repo, &NoRepoInCwdError>, repo: Result<&Repo, &NoRepoInCwdError>,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
check_extensions(config)?; check_extensions(config)?;
if std::env::var_os("HG_PENDING").is_some() { if std::env::var_os("HG_PENDING").is_some() {
// TODO: only if the value is `== repo.working_directory`? // TODO: only if the value is `== repo.working_directory`?
// What about relative v.s. absolute paths? // What about relative v.s. absolute paths?
Err(CommandError::unsupported("$HG_PENDING"))? Err(CommandError::unsupported("$HG_PENDING"))?
} }
if let Ok(repo) = repo { if let Ok(repo) = repo {
if repo.has_subrepos()? { if repo.has_subrepos()? {
Err(CommandError::unsupported("sub-repositories"))? Err(CommandError::unsupported("sub-repositories"))?
} }
check_auto_upgrade(config, repo.requirements())?;
} }
if config.has_non_empty_section(b"encode") { if config.has_non_empty_section(b"encode") {
Err(CommandError::unsupported("[encode] config"))? Err(CommandError::unsupported("[encode] config"))?
} }
if config.has_non_empty_section(b"decode") { if config.has_non_empty_section(b"decode") {
Err(CommandError::unsupported("[decode] config"))? Err(CommandError::unsupported("[decode] config"))?
} }
Ok(()) Ok(())
} }

tests/test-help.t

"use-dirstate-v2" "use-dirstate-v2"
"use-dirstate-tracked-hint" "use-dirstate-tracked-hint"
"use-persistent-nodemap" "use-persistent-nodemap"
"use-share-safe" "use-share-safe"
"use-share-safe.automatic-upgrade-of-mismatching-repositories"
"usestore" "usestore"
"sparse-revlog" "sparse-revlog"
"revlog-compression" "revlog-compression"
"bookmarks-in-store" "bookmarks-in-store"