facebook/sapling
1
1
Fork 0
mirror of https://github.com/facebook/sapling.git synced 2024-10-10 08:47:12 +03:00
Code Issues Projects Releases Wiki Activity
8637678d4e
sapling/hgext/largefiles/uisetup.py

205 lines
8.7 KiB
Python
Raw Normal View History

hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
# Copyright 2009-2010 Gregory P. Ward
# Copyright 2009-2010 Intelerad Medical Systems Incorporated
# Copyright 2010-2011 Fog Creek Software
# Copyright 2010-2011 Unity Technologies
#
# This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version.
'''setup for largefiles extension: uisetup'''
py3: make largefiles/uisetup.py use absolute_import
2016-05-10 16:14:41 +03:00
from __future__ import absolute_import
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
from mercurial.i18n import _
py3: make largefiles/uisetup.py use absolute_import
2016-05-10 16:14:41 +03:00
from mercurial.hgweb import (
hgweb_mod,
webcommands,
)
from mercurial import (
archival,
cmdutil,
commands,
copies,
exchange,
extensions,
filemerge,
hg,
httppeer,
merge,
scmutil,
sshpeer,
subrepo,
wireproto,
)
from . import (
overrides,
proto,
)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
def uisetup(ui):
# Disable auto-status for some commands which assume that all
# files in the result are under Mercurial's control
largefiles: fix over-long lines
2011-09-30 02:04:57 +04:00
entry = extensions.wrapcommand(commands.table, 'add',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overrideadd)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
addopt = [('', 'large', None, _('add as largefile')),
largefiles: add --normal option to hg add (issue3061)
2011-12-02 21:20:32 +04:00
('', 'normal', None, _('add as normal file')),
largefiles: fix indentation
2011-12-09 20:34:56 +04:00
('', 'lfsize', '', _('add all files above this size '
'(in megabytes) as largefiles '
'(default: 10)'))]
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
entry[1].extend(addopt)
largefiles: handle commit -A properly, after a --large commit (issue3542) Previous to this, 'commit -A' would add as normal files, files that were already committed as largefiles, resulting in files being listed twice by 'status -A'. It also missed when (only) a largefile was deleted, even though status reported it as '!'. This also has the side effect of properly reporting the state of the affected largefiles in the post commit hook after a remove that also affected a normal file (the largefiles used to be 'R', now are properly absent). Since scmutil.addremove() is called both by the ui command (after some trivial argument validation) and during the commit process when -A is specified, it seems like a more appropriate method to wrap than the addremove command. Currently, a repo is only enabled to use largefiles after an add that explicitly identifies some file as large, and a subsequent commit. Therefore, this patch only changes behavior after such a largefile enabling commit. Note that in the test, if the final commit had a '-v', 'removing large8' would be printed twice. Both of these originate in removelargefiles(). The first print is in verbose mode after traversing remove + forget, the second is because the '_isaddremove' attr is set and 'after' is not.
2012-07-31 04:56:41 +04:00
# The scmutil function is called both by the (trivial) addremove command,
# and in the process of handling commit -A (issue3542)
entry = extensions.wrapfunction(scmutil, 'addremove',
overrides.scmutiladdremove)
largefiles: enable subrepo support for add The --large, --normal and --lfsize args couldn't be passed to a subrepo before, and files in the subrepos would be added silently (if -v wasn't specified) as normal files. As an added bonus, 'hg add --dry-run' no longer prints that largefiles would also be added as normal files as well.
2015-01-13 05:44:43 +03:00
extensions.wrapfunction(cmdutil, 'add', overrides.cmdutiladd)
largefiles: enable subrepo support for remove Previously, remove failed when operating on a largefile in a subrepo, stating that the file is untracked.
2014-12-31 05:12:52 +03:00
extensions.wrapfunction(cmdutil, 'remove', overrides.cmdutilremove)
largefiles: enable subrepo support for forget
2015-01-12 07:20:51 +03:00
extensions.wrapfunction(cmdutil, 'forget', overrides.cmdutilforget)
largefiles: fix status -S reporting of subrepos (issue3231) Wrapping the status command will only invoke overridestatus() and set the lfstatus field for the top level repository. Wrapping the status function is required to set the field on child repositories. Previously, status -S would report large files in a subrepo as '?' regardless of their actual states, and was inconsistent with what status would report from within that subrepo.
2012-04-22 11:47:34 +04:00
largefiles: report the source of copied/moved largefiles in status -C Previously, the source was silently skipped because the largefile was in the list of changed files, but the standin was in the copies dictionary. The source is only displayed if the changed file is a key in the copies dictionary.
2015-01-25 10:45:49 +03:00
extensions.wrapfunction(copies, 'pathcopies', overrides.copiespathcopies)
largefiles: fix status -S reporting of subrepos (issue3231) Wrapping the status command will only invoke overridestatus() and set the lfstatus field for the top level repository. Wrapping the status function is required to set the field on child repositories. Previously, status -S would report large files in a subrepo as '?' regardless of their actual states, and was inconsistent with what status would report from within that subrepo.
2012-04-22 11:47:34 +04:00
# Subrepos call status function
largefiles: fix over-long lines
2011-09-30 02:04:57 +04:00
entry = extensions.wrapcommand(commands.table, 'status',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overridestatus)
largefiles: import whole modules instead of importing parts of them Be more friendly to demandimport.
2014-04-08 02:48:36 +04:00
entry = extensions.wrapfunction(subrepo.hgsubrepo, 'status',
largefiles: fix status -S reporting of subrepos (issue3231) Wrapping the status command will only invoke overridestatus() and set the lfstatus field for the top level repository. Wrapping the status function is required to set the field on child repositories. Previously, status -S would report large files in a subrepo as '?' regardless of their actual states, and was inconsistent with what status would report from within that subrepo.
2012-04-22 11:47:34 +04:00
overrides.overridestatusfn)
largefiles: fix over-long lines
2011-09-30 02:04:57 +04:00
entry = extensions.wrapcommand(commands.table, 'log',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overridelog)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
entry = extensions.wrapcommand(commands.table, 'rollback',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overriderollback)
largefiles: fix over-long lines
2011-09-30 02:04:57 +04:00
entry = extensions.wrapcommand(commands.table, 'verify',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overrideverify)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
largefiles: make verify --lfa and --lfc work without --large The slightly obscure --lfa and --lfc only worked as modifiers to --large and could be combined. The documentation was however not clear what they did. Instead they now imply --large and the description is updated.
2013-01-25 02:57:44 +04:00
verifyopt = [('', 'large', None,
_('verify that all largefiles in current revision exists')),
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
('', 'lfa', None,
largefiles: make verify --lfa and --lfc work without --large The slightly obscure --lfa and --lfc only worked as modifiers to --large and could be combined. The documentation was however not clear what they did. Instead they now imply --large and the description is updated.
2013-01-25 02:57:44 +04:00
_('verify largefiles in all revisions, not just current')),
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
('', 'lfc', None,
largefiles: make verify --lfa and --lfc work without --large The slightly obscure --lfa and --lfc only worked as modifiers to --large and could be combined. The documentation was however not clear what they did. Instead they now imply --large and the description is updated.
2013-01-25 02:57:44 +04:00
_('verify local largefile contents, not just existence'))]
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
entry[1].extend(verifyopt)
largefiles: introduce basic debugstate --large functionality Very useful for debugging largefiles "performance" issues. This is used for testing 45d039e26849.
2012-12-28 14:55:57 +04:00
entry = extensions.wrapcommand(commands.table, 'debugstate',
overrides.overridedebugstate)
debugstateopt = [('', 'large', None, _('display largefiles dirstate'))]
entry[1].extend(debugstateopt)
largefiles: use "outgoinghooks" to avoid redundant outgoing check Before this patch, "hg outgoing" invokes "findcommonoutgoing()" not only in "commands.outgoing()" but also in "overrides.overrideoutgoing()" (via "getoutgoinglfiles()"), when largefiles is enabled. The latter is redundant. This patch uses "outgoinghooks" to avoid redundant outgoing check. Newly introduced function "overrides.outgoinghook()" is registered into "outgoinghooks" to get the result of outgoing check in "commands.outgoing()". It invokes "lfutil.getlfilestoupload()" directly with the result of outgoing check to avoid redundant outgoing check in "getoutgoinglfiles()": "sort()" is needed, because "lfutil.getlfilestoupload()" doesn't sort the result of it. This patch also omits "if toupload is None" ("No remote repo") case, because failure of looking remote repository up should raise exception in "commands.outgoing()" before invocation of "outgoinghooks". Newly added "hg outgoing --large --graph" tests examine "outgoinghooks" invocations in "hg outgoing --graph" code path.
2014-04-15 19:37:24 +04:00
outgoing = lambda orgfunc, *arg, **kwargs: orgfunc(*arg, **kwargs)
entry = extensions.wrapcommand(commands.table, 'outgoing', outgoing)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
outgoingopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(outgoingopt)
largefiles: use "outgoinghooks" to avoid redundant outgoing check Before this patch, "hg outgoing" invokes "findcommonoutgoing()" not only in "commands.outgoing()" but also in "overrides.overrideoutgoing()" (via "getoutgoinglfiles()"), when largefiles is enabled. The latter is redundant. This patch uses "outgoinghooks" to avoid redundant outgoing check. Newly introduced function "overrides.outgoinghook()" is registered into "outgoinghooks" to get the result of outgoing check in "commands.outgoing()". It invokes "lfutil.getlfilestoupload()" directly with the result of outgoing check to avoid redundant outgoing check in "getoutgoinglfiles()": "sort()" is needed, because "lfutil.getlfilestoupload()" doesn't sort the result of it. This patch also omits "if toupload is None" ("No remote repo") case, because failure of looking remote repository up should raise exception in "commands.outgoing()" before invocation of "outgoinghooks". Newly added "hg outgoing --large --graph" tests examine "outgoinghooks" invocations in "hg outgoing --graph" code path.
2014-04-15 19:37:24 +04:00
cmdutil.outgoinghooks.add('largefiles', overrides.outgoinghook)
largefiles: fix over-long lines
2011-09-30 02:04:57 +04:00
entry = extensions.wrapcommand(commands.table, 'summary',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overridesummary)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
summaryopt = [('', 'large', None, _('display outgoing largefiles'))]
entry[1].extend(summaryopt)
largefiles: use "summaryremotehooks" to avoid redundant outgoing check Before this patch, "hg summary --remote --large" invokes "findcommonoutgoing()" not only in "commands.summary()" but also in "overrides.overridesummary()" (via "getoutgoinglfiles()"). The latter is redundant. This patch uses "summaryremotehooks" to avoid redundant outgoing check. Newly introduced function "overrides.summaryremotehook()" is registered into "summaryremotehooks" to get the result of outgoing check in "commands.summary()". It invokes "lfutil.getlfilestoupload()" directly with the result of outgoing check to avoid redundant outgoing check in "getoutgoinglfiles()".
2014-04-15 19:37:24 +04:00
cmdutil.summaryremotehooks.add('largefiles', overrides.summaryremotehook)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
largefiles: fix over-long lines
2011-09-30 02:04:57 +04:00
entry = extensions.wrapcommand(commands.table, 'pull',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overridepull)
largefiles: add --all-largefiles flag to pull
2012-05-12 13:45:22 +04:00
pullopt = [('', 'all-largefiles', None,
largefiles: deprecate --all-largefiles for pull The same can be achieved with --lfrev pulled() and we shouldn't advertise unnecessary command line options.
2013-04-15 03:59:11 +04:00
_('download all pulled versions of largefiles (DEPRECATED)')),
largefiles: introduce pull --lfrev option The revset will be evaluated after the changesets has been pulled, and missing largefiles from matching revisions will be pulled to the local caches. This in combination with revsets will make it possible to specify different strategies for pulling largefiles. The revset expressions used for this option might be quite complex and will probably be most useful from scripts or an alias ... but less complicated than configuring hooks.
2013-04-15 03:57:16 +04:00
('', 'lfrev', [],
_('download largefiles for these revisions'), _('REV'))]
largefiles: add --all-largefiles flag to pull
2012-05-12 13:45:22 +04:00
entry[1].extend(pullopt)
largefiles: introduce pulled() revset expression for use in --lfrev This provides a general way to do what already can be done with --all-largefiles and --cache-largefiles.
2013-04-15 03:59:04 +04:00
largefiles: introduce push --lfrev to control which revisions are pushed The default of pushing all largefiles referenced in outgoing revisions is safe, but also expensive and sometimes not what is needed. We thus introduce a --lfrev option, similar to what pull already has. By specifying an empty set of revisions (or null), it is possible to get lazy (and insecure!) pushes of revisions without referenced largefiles, similar to how pull works.
2016-03-27 23:00:28 +03:00
entry = extensions.wrapcommand(commands.table, 'push',
overrides.overridepush)
pushopt = [('', 'lfrev', [],
_('upload largefiles for these revisions'), _('REV'))]
entry[1].extend(pushopt)
entry = extensions.wrapfunction(exchange, 'pushoperation',
overrides.exchangepushoperation)
largefiles: add --all-largefiles flag to clone (issue3188)
2012-05-12 01:11:43 +04:00
entry = extensions.wrapcommand(commands.table, 'clone',
overrides.overrideclone)
cloneopt = [('', 'all-largefiles', None,
_('download all versions of all largefiles'))]
entry[1].extend(cloneopt)
largefiles: delegate to the wrapped clone command This allows the wrapped command's validation code to run (which is currently only to ensure 'noupdate' and 'updaterev' aren't both specified), the copy/pasted unpacking of hg.clone() args to be removed, and any future changes to the base command (however unlikely) to be inherited by largefiles. Unfortunately, the command override can't be swapped entirely for an hg.clone() override because the extra --all-largefiles arg needs to be injected. It also isn't enough to call the wrapped clone command and leave the caching code after it, because the file caching code needs access to the destination repo, which is only available from hg.clone(). An alternative would be to use the dest path in the clone command override to re-obtain a reference to the repo. A slight deviation from the regular hg.clone() function is that the repo is NOT deleted if the caching fails, but that was also the previous behavior. Maybe it should for consistency?
2012-09-09 20:43:24 +04:00
entry = extensions.wrapfunction(hg, 'clone', overrides.hgclone)
largefiles: set the extension as enabled locally after a share requiring it This has been done for clone since bd19f94d30e9, so it makes sense here for the same reasons.
2017-04-12 03:54:50 +03:00
entry = extensions.wrapfunction(hg, 'postshare', overrides.hgpostshare)
largefiles: delegate to the wrapped clone command This allows the wrapped command's validation code to run (which is currently only to ensure 'noupdate' and 'updaterev' aren't both specified), the copy/pasted unpacking of hg.clone() args to be removed, and any future changes to the base command (however unlikely) to be inherited by largefiles. Unfortunately, the command override can't be swapped entirely for an hg.clone() override because the extra --all-largefiles arg needs to be injected. It also isn't enough to call the wrapped clone command and leave the caching code after it, because the file caching code needs access to the destination repo, which is only available from hg.clone(). An alternative would be to use the dest path in the clone command override to re-obtain a reference to the repo. A slight deviation from the regular hg.clone() function is that the repo is NOT deleted if the caching fails, but that was also the previous behavior. Maybe it should for consistency?
2012-09-09 20:43:24 +04:00
largefiles: fix cat for largefiles (issue3352) This is a fix to largefiles so that 'hg cat' will work correctly when a largefile is specified. As per discussion on Issue 3352: 1) The file will be printed regardless if it is binary or large. 2) The file is downloaded if it is not readily available (not found in the system cache), so that it can be printed. If the download fails, then we abort.
2012-04-16 19:03:39 +04:00
entry = extensions.wrapcommand(commands.table, 'cat',
overrides.overridecat)
merge: refactor unknown file conflict checking Previously, we would do a full working directory walk including unknown files to perform a merge. In many cases, this was painful because unknown files greatly outnumbered tracked files and generally had no useful effect on the merge. Here we instead wait until we find a file in the destination that's not tracked locally and detect if it exists and is not ignored. This is usually cheaper but can be -more- expensive in the case where we're adding a huge number of files. On the other hand, the cost of statting the new files should be dwarfed by the cost of eventually writing them. In this version, case collisions are detected implicitly by os.path.exists and wctx[f] lookup.
2012-02-10 02:50:19 +04:00
entry = extensions.wrapfunction(merge, '_checkunknownfile',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overridecheckunknownfile)
largefiles: override calculateupdates instead of manifestmerge That will give calculateupdates a purpose in life ... and be convenient later.
2014-03-02 21:30:41 +04:00
entry = extensions.wrapfunction(merge, 'calculateupdates',
overrides.overridecalculateupdates)
largefiles: keep largefiles from colliding with normal one during linear merge Before this patch, linear merging of modified or newly added largefile causes unexpected result, if (1) largefile collides with same name normal one in the target revision and (2) "local" largefile is chosen, even though branch merging between such revisions doesn't. Expected result of such linear merging is: (1) (not yet recorded) largefile is kept in the working directory (2) largefile is marked as (re-)"added" (3) colliding normal file is marked as "removed" But actual result is: (1) largefile in the working directory is unlinked (2) largefile is marked as "normal" (so treated as "missing") (3) the dirstate entry for colliding normal file is just dropped (1) is very serious, because there is no way to restore temporarily modified largefiles. (3) prevents the next commit from adding the manifest with correct "removal of (normal) file" information for newly created changeset. The root cause of this problem is putting "lfile" into "actions['r']" in linear-merging case. At liner merging, "actions['r']" causes: - unlinking "target file" in the working directory, but "lfile" as "target file" is also largefile itself in this case - dropping the dirstate entry for target file "actions['f']" (= "forget") does only the latter, and this is reason why this patch doesn't choose putting "lfile" into it instead of "actions['r']". This patch newly introduces action "lfmr" (LargeFiles: Mark as Removed) to mark colliding normal file as "removed" without unlinking it. This patch uses "hg debugdirstate" instead of "hg status" in test, because: - choosing "local largefile" hides "removed" status of "remote normal file" in "hg status" output, and - "hg status" for "large2" in this case has another problem fixed in the subsequent patch
2014-08-15 15:28:51 +04:00
entry = extensions.wrapfunction(merge, 'recordupdates',
overrides.mergerecordupdates)
largefiles: update largefiles even if rebase is aborted by conflict Before this patch, largefiles in the working directory aren't updated correctly, if rebase is aborted by conflict. This prevents users from viewing appropriate largefiles while resolving conflicts. While rebase, largefiles in the working directory are updated only at successful committing in the special code path of "lfilesrepo.commit()". To update largefiles even if rebase is aborted by conflict, this patch centralizes the logic of updating largefiles in the working directory into the "mergeupdate" wrapping "merge.update". This is a temporary way to fix with less changes. For fundamental resolution of this kind of problems in the future, largefiles in the working directory should be updated with other (normal) files simultaneously while "merge.update" execution: maybe by hooking "applyupdates". "Action list based updating" introduced by hooking "applyupdates" will also improve performance of updating, because it automatically decreases target files to be checked. Just after this patch, there are some improper things in "Case 0" code path of "lfilesrepo.commit()": - "updatelfiles" invocation is redundant for rebase - detailed comment doesn't meet to rebase behavior These will be resolved after the subsequent patch for transplant, because this code path is shared with transplant. Even though replacing "merge.update" in rebase extension by "hg.merge" can also avoid this problem, this patch chooses centralizing the logic into "mergeupdate", because: - "merge.update" invocation in rebase extension can't be directly replaced by "hg.merge", because: - rebase requires some extra arguments, which "hg.merge" doesn't take (e.g. "ancestor") - rebase doesn't require statistics information forcibly displayed in "hg.merge" - introducing "mergeupdate" can resolve also problem of some other code paths directly using "merge.update" largefiles in the working directory aren't updated regardless of the result of commands below, before this patch: - backout (for revisions other than the parent revision of the working directory without "--merge") - graft - histedit (for revisions other than the parent of the working directory When "partial" is specified, "merge.update" doesn't update dirstate entries for standins, even though standins themselves are updated. In this case, "normallookup" should be used to mark largefiles as "possibly dirty" forcibly, because applying "normal" on lfdirstate treats them as "clean" unexpectedly. This is reason why "normallookup=partial" is specified for "lfcommands.updatelfiles". This patch doesn't test "hg rebase --continue", because it doesn't work correctly if largefiles in the working directory are modified manually while resolving conflicts. This will be fixed in the next step of refactoring for largefiles. All changes of tests/*.t files other than test-largefiles-update.t in this patch come from invoking "updatelfiles" not after but before statistics output of "hg.update", "hg.clean" and "hg.merge".
2014-08-24 18:47:26 +04:00
entry = extensions.wrapfunction(merge, 'update',
overrides.mergeupdate)
filemerge: add a wrapper around the filemerge function We'll introduce a separate premerge function that calls the same code.
2015-10-11 22:31:08 +03:00
entry = extensions.wrapfunction(filemerge, '_filemerge',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overridefilemerge)
largefiles: fix over-long lines
2011-09-30 02:04:57 +04:00
entry = extensions.wrapfunction(cmdutil, 'copy',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overridecopy)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
largefiles: notice dirty large files in a subrepo Summary and commit use dirty() to check the status of a subrepository, so this overrides dirty() in the subrepo in the same manner as status() to check the large files instead of their standins. Previously, if only a large file was changed in a subrepo, summary in the top level repo would not report the subrepo was dirty and commit -S would report nothing changed. If any type of file was changed in the top repo and only a large file in the subrepo, commit -S would not commit the changes to the subrepo.
2012-04-22 21:19:22 +04:00
# Summary calls dirty on the subrepos
largefiles: import whole modules instead of importing parts of them Be more friendly to demandimport.
2014-04-08 02:48:36 +04:00
entry = extensions.wrapfunction(subrepo.hgsubrepo, 'dirty',
largefiles: notice dirty large files in a subrepo Summary and commit use dirty() to check the status of a subrepository, so this overrides dirty() in the subrepo in the same manner as status() to check the large files instead of their standins. Previously, if only a large file was changed in a subrepo, summary in the top level repo would not report the subrepo was dirty and commit -S would report nothing changed. If any type of file was changed in the top repo and only a large file in the subrepo, commit -S would not commit the changes to the subrepo.
2012-04-22 21:19:22 +04:00
overrides.overridedirty)
largefiles: override cmdutil.revert() instead of comands.revert() By overriding the cmdutil method we don't need to override both the function and the command. Also, we get access to the 'ctx' and 'parents' variables, which will soon prove useful. Rename the 'ctx' argument to overridematch() to 'mctx' rather than letting it shadow new 'ctx'.
2015-03-20 20:05:31 +03:00
entry = extensions.wrapfunction(cmdutil, 'revert',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overriderevert)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
largefiles: allow the archiving of largefiles to be disabled There are currently no users of this, but it is a necessary step before converting extdiff to use archive. It may be useful to add an argument to extdiff in the future and allow largefiles to be diffed, but archiving largefiles can have significant overhead and may not be very diffable, so archiving them by default seems wrong. It is a mystery to me why the lfstatus attribute needs to be set on the unfiltered repo. However if it is set on the filtered repo instead (and the filtered repo is passed to the original command), the lfstatus attribute is False in the overrides for archival.archive() and hgsubrepo.archive() when invoking the archive command. This smells like the buggy status behavior (see 9fc565fa1621, which was reverted in e1574a4a2cad). Neither the status nor summary commands have this weird behavior in their respective overrides.
2015-07-12 06:26:33 +03:00
extensions.wrapcommand(commands.table, 'archive',
overrides.overridearchivecmd)
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
extensions.wrapfunction(archival, 'archive', overrides.overridearchive)
largefiles: import whole modules instead of importing parts of them Be more friendly to demandimport.
2014-04-08 02:48:36 +04:00
extensions.wrapfunction(subrepo.hgsubrepo, 'archive',
overrides.hgsubrepoarchive)
largefiles: restore archiving largefiles with hgweb (issue4859) This regressed in f07f4c45a8f2, when trying to conditionally disable archiving of largefiles. I'm not sure if wrapfunction() is the right way to do this, but it seems to work. The mysterious issue with lfstatus getting out of sync in the proxy and the unfiltered view crops up again here. See the referenced cset for more info.
2015-09-30 06:29:44 +03:00
extensions.wrapfunction(webcommands, 'archive',
overrides.hgwebarchive)
largefiles: drop more unnecessary compatibility checks
2011-10-23 18:23:31 +04:00
extensions.wrapfunction(cmdutil, 'bailifchanged',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overridebailifchanged)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
largefiles: report the missing file count after a commit that does nothing This is the same warning that is printed for normal files.
2016-01-24 07:32:49 +03:00
extensions.wrapfunction(cmdutil, 'postcommitstatus',
overrides.postcommitstatus)
largefiles: update largefiles even if transplant is aborted by conflict Before this patch, largefiles in the working directory aren't updated correctly, if transplant is aborted by conflict. This prevents users from viewing appropriate largefiles while resolving conflicts. While transplant, largefiles in the working directory are updated only at successful committing in the special code path of "lfilesrepo.commit()". To update largefiles even if transplant is aborted by conflict, this patch wraps "scmutil.marktouched", which is invoked from "patch.patch" with "files" list of added/modified/deleted files. This patch invokes "updatelfiles" with: - "printmessage=False", to suppress "getting changed largefiles ..." messages while automated committing by transplant - "normallookup=True", because "patch.patch" doesn't update dirstate for modified files in such case, "normallookup=False" may cause marking modified largefiles as "clean" unexpectedly
2014-08-24 18:47:26 +04:00
extensions.wrapfunction(scmutil, 'marktouched',
overrides.scmutilmarktouched)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
# create the new wireproto commands ...
wireproto.commands['putlfile'] = (proto.putlfile, 'sha')
wireproto.commands['getlfile'] = (proto.getlfile, 'sha')
wireproto.commands['statlfile'] = (proto.statlfile, 'sha')
# ... and wrap some existing ones
wireproto.commands['capabilities'] = (proto.capabilities, '')
wireproto.commands['heads'] = (proto.heads, '')
wireproto.commands['lheads'] = (wireproto.heads, '')
largefiles: more work on cleaning up comments - always say "largefile", not "lfile" - cleanup mangled syntax, hopefully correctly (punctuation: it's your friend!) - wrap to 75 columns (where feasible)
2011-10-14 04:45:49 +04:00
# make putlfile behave the same as push and {get,stat}lfile behave
# the same as pull w.r.t. permissions checks
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
hgweb_mod.perms['putlfile'] = 'push'
hgweb_mod.perms['getlfile'] = 'pull'
hgweb_mod.perms['statlfile'] = 'pull'
largefiles: hide .hglf/ prefix for largefiles in hgweb This makes the manifest view in hgweb match what you see in the working copy and what you get when you download an archive in hgweb.
2012-04-15 18:05:57 +04:00
extensions.wrapfunction(webcommands, 'decodepath', overrides.decodepath)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
# the hello wireproto command uses wireproto.capabilities, so it won't see
# our largefiles capability unless we replace the actual function as well.
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
proto.capabilitiesorig = wireproto.capabilities
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
wireproto.capabilities = proto.capabilities
# can't do this in reposetup because it needs to have happened before
# wirerepo.__init__ is called
peer: introduce real peer classes This change separates peer implementations from the repository implementation. localpeer currently is a simple pass-through to localrepository, except for legacy calls, which have already been removed from localpeer. This ensures that the local client code only uses the most modern peer API when talking to local repos. Peers have a .local() method which returns either None or the underlying localrepository (or descendant thereof). Repos have a .peer() method to return a freshly constructed localpeer. The latter is used by hg.peer(), and also to allow folks to pass either a peer or a repo to some generic helper methods. We might want to get rid of .peer() eventually. The only user of locallegacypeer is debugdiscovery, which uses it to pose as a pre-setdiscovery client. But we decided to leave the old API defined in locallegacypeer for clarity and maybe for other uses in the future. It might be nice to actually define the peer API directly in peer.py as stub methods. One problem there is, however, that localpeer implements lock/addchangegroup, whereas the true remote peers implement unbundle. It might be desireable to get rid of this distinction eventually.
2012-07-13 23:47:06 +04:00
proto.ssholdcallstream = sshpeer.sshpeer._callstream
proto.httpoldcallstream = httppeer.httppeer._callstream
sshpeer.sshpeer._callstream = proto.sshrepocallstream
httppeer.httppeer._callstream = proto.httprepocallstream
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
# override some extensions' stuff as well
for name, module in extensions.extensions():
if name == 'purge':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'purge',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overridepurge)
hgext: add largefiles extension This code has a number of contributors and a complicated history prior to its introduction that can be seen by visiting: https://developers.kilnhg.com/Repo/Kiln/largefiles/largefiles http://hg.gerg.ca/hg-bfiles and looking at the included copyright notices and contributors list.
2011-09-24 19:35:45 +04:00
if name == 'rebase':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'rebase',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overriderebase)
largefiles: wrap "rebase.rebase" for functions using it directly Before this patch, largefiles extension wraps only "rebase" in the command table by "extensions.wrapcommand". But there are some functions using "rebase.rebase" directly. Without special care for them, largefiles extension can't work correctly with such functions. In addition to it, "special care" often becomes complicated and awkward. For example: - "unshelve" can't get correct result of "rebase.rebase", because of lack of special care - special care for "hg pull --rebase" causes issue3861 This patch wraps "rebase.rebase" for functions using it directly. For simplicity, this patch keeps 'special care for "hg pull --rebase"'. It is removed in the subsequent patch.
2014-11-05 17:24:47 +03:00
extensions.wrapfunction(module, 'rebase',
overrides.overriderebase)
largefiles: fix bad bug where transplanting a changeset with a largefile will result in an old largefile being comitted later on
2011-10-28 20:48:24 +04:00
if name == 'transplant':
extensions.wrapcommand(getattr(module, 'cmdtable'), 'transplant',
largefiles: remove use of underscores that breaks coding convention
2012-03-09 19:11:52 +04:00
overrides.overridetransplant)
Reference in New Issue Copy Permalink