Mercurial > hg
annotate hgext/largefiles/lfutil.py @ 48396:c0d88407b7d4
largefile: use the proper "mtime boundary" logic during fixup
This will prevent ambiguous cache entry to be used in racy situation. This fix
flakiness in test and some real live misbehavior.
Differential Revision: https://phab.mercurial-scm.org/D11800
author | Pierre-Yves David <pierre-yves.david@octobus.net> |
---|---|
date | Tue, 23 Nov 2021 18:13:33 +0100 |
parents | 322525db4c98 |
children | 6000f5b25c9b |
rev | line source |
---|---|
15168 | 1 # Copyright 2009-2010 Gregory P. Ward |
2 # Copyright 2009-2010 Intelerad Medical Systems Incorporated | |
3 # Copyright 2010-2011 Fog Creek Software | |
4 # Copyright 2010-2011 Unity Technologies | |
5 # | |
6 # This software may be used and distributed according to the terms of the | |
7 # GNU General Public License version 2 or any later version. | |
8 | |
9 '''largefiles utility code: must not import other modules in this package.''' | |
29309
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
10 from __future__ import absolute_import |
15168 | 11 |
43583
73e6d3346e4f
largefiles: move lfstatus context manager to lfutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43085
diff
changeset
|
12 import contextlib |
29309
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
13 import copy |
15168 | 14 import os |
15 import stat | |
29309
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
16 |
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
17 from mercurial.i18n import _ |
47012
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46895
diff
changeset
|
18 from mercurial.node import hex |
43085
eef9a2d67051
py3: manually import pycompat.open into files that need it
Gregory Szorc <gregory.szorc@gmail.com>
parents:
43077
diff
changeset
|
19 from mercurial.pycompat import open |
15168 | 20 |
29309
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
21 from mercurial import ( |
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
22 dirstate, |
30820
6a70cf94d1b5
py3: replace pycompat.getenv with encoding.environ.get
Pulkit Goyal <7895pulkit@gmail.com>
parents:
30664
diff
changeset
|
23 encoding, |
29309
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
24 error, |
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
25 httpconnection, |
29320
016a90152e9c
largefiles: rename match_ to matchmod import in lfutil
liscju <piotr.listkiewicz@gmail.com>
parents:
29309
diff
changeset
|
26 match as matchmod, |
30640
7a3e67bfa417
py3: replace os.name with pycompat.osname (part 2 of 2)
Pulkit Goyal <7895pulkit@gmail.com>
parents:
30181
diff
changeset
|
27 pycompat, |
47280
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47012
diff
changeset
|
28 requirements, |
29309
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
29 scmutil, |
33373
fb320398a21c
dirstate: expose a sparse matcher on dirstate (API)
Gregory Szorc <gregory.szorc@gmail.com>
parents:
32309
diff
changeset
|
30 sparse, |
29309
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
31 util, |
31247
04b4286278ec
vfs: use 'vfs' module directly in 'hgext.largefile'
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
31216
diff
changeset
|
32 vfs as vfsmod, |
29309
bfc1052570b6
py3: make largefiles/lfutil.py use absolute_import
liscju <piotr.listkiewicz@gmail.com>
parents:
28877
diff
changeset
|
33 ) |
44062
2d49482d0dd4
hgext: replace references to hashlib.sha1 with hashutil.sha1
Augie Fackler <augie@google.com>
parents:
43584
diff
changeset
|
34 from mercurial.utils import hashutil |
48382
991e6f728b50
status: adapt largefile to gather stats at lookup time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48169
diff
changeset
|
35 from mercurial.dirstateutils import timestamp |
15168 | 36 |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
37 shortname = b'.hglf' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
38 shortnameslash = shortname + b'/' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
39 longname = b'largefiles' |
15168 | 40 |
41 # -- Private worker functions ------------------------------------------ | |
42 | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
43 |
43583
73e6d3346e4f
largefiles: move lfstatus context manager to lfutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43085
diff
changeset
|
44 @contextlib.contextmanager |
43584
a02e4c12ae60
largefiles: allow "lfstatus" context manager to set value to False
Martin von Zweigbergk <martinvonz@google.com>
parents:
43583
diff
changeset
|
45 def lfstatus(repo, value=True): |
43583
73e6d3346e4f
largefiles: move lfstatus context manager to lfutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43085
diff
changeset
|
46 oldvalue = getattr(repo, 'lfstatus', False) |
43584
a02e4c12ae60
largefiles: allow "lfstatus" context manager to set value to False
Martin von Zweigbergk <martinvonz@google.com>
parents:
43583
diff
changeset
|
47 repo.lfstatus = value |
43583
73e6d3346e4f
largefiles: move lfstatus context manager to lfutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43085
diff
changeset
|
48 try: |
73e6d3346e4f
largefiles: move lfstatus context manager to lfutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43085
diff
changeset
|
49 yield |
73e6d3346e4f
largefiles: move lfstatus context manager to lfutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43085
diff
changeset
|
50 finally: |
73e6d3346e4f
largefiles: move lfstatus context manager to lfutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43085
diff
changeset
|
51 repo.lfstatus = oldvalue |
73e6d3346e4f
largefiles: move lfstatus context manager to lfutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43085
diff
changeset
|
52 |
73e6d3346e4f
largefiles: move lfstatus context manager to lfutil
Martin von Zweigbergk <martinvonz@google.com>
parents:
43085
diff
changeset
|
53 |
15227
a7686abf73a6
largefiles: factor out lfutil.getminsize()
Greg Ward <greg@gerg.ca>
parents:
15226
diff
changeset
|
54 def getminsize(ui, assumelfiles, opt, default=10): |
a7686abf73a6
largefiles: factor out lfutil.getminsize()
Greg Ward <greg@gerg.ca>
parents:
15226
diff
changeset
|
55 lfsize = opt |
a7686abf73a6
largefiles: factor out lfutil.getminsize()
Greg Ward <greg@gerg.ca>
parents:
15226
diff
changeset
|
56 if not lfsize and assumelfiles: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
57 lfsize = ui.config(longname, b'minsize', default=default) |
15227
a7686abf73a6
largefiles: factor out lfutil.getminsize()
Greg Ward <greg@gerg.ca>
parents:
15226
diff
changeset
|
58 if lfsize: |
a7686abf73a6
largefiles: factor out lfutil.getminsize()
Greg Ward <greg@gerg.ca>
parents:
15226
diff
changeset
|
59 try: |
15228
ee625de3541e
largefiles: allow minimum size to be a float
Greg Ward <greg@gerg.ca>
parents:
15227
diff
changeset
|
60 lfsize = float(lfsize) |
15227
a7686abf73a6
largefiles: factor out lfutil.getminsize()
Greg Ward <greg@gerg.ca>
parents:
15226
diff
changeset
|
61 except ValueError: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
62 raise error.Abort( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
63 _(b'largefiles: size must be number (not %s)\n') % lfsize |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
64 ) |
15227
a7686abf73a6
largefiles: factor out lfutil.getminsize()
Greg Ward <greg@gerg.ca>
parents:
15226
diff
changeset
|
65 if lfsize is None: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
66 raise error.Abort(_(b'minimum size for largefiles must be specified')) |
15227
a7686abf73a6
largefiles: factor out lfutil.getminsize()
Greg Ward <greg@gerg.ca>
parents:
15226
diff
changeset
|
67 return lfsize |
a7686abf73a6
largefiles: factor out lfutil.getminsize()
Greg Ward <greg@gerg.ca>
parents:
15226
diff
changeset
|
68 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
69 |
15168 | 70 def link(src, dest): |
28576
33bd95443e7f
largefiles: add some docstrings
Mads Kiilerich <madski@unity3d.com>
parents:
28575
diff
changeset
|
71 """Try to create hardlink - if that fails, efficiently make a copy.""" |
18998
d035c3902111
largefiles: refactoring - create destination dir in lfutil.link
Mads Kiilerich <madski@unity3d.com>
parents:
18980
diff
changeset
|
72 util.makedirs(os.path.dirname(dest)) |
15168 | 73 try: |
15206
f85c76b16f27
largefiles: fix commit of specified file on non-windows
Na'Tosha Bard <natosha@unity3d.com>
parents:
15188
diff
changeset
|
74 util.oslink(src, dest) |
15168 | 75 except OSError: |
15572
926bc23d0b6a
largefiles: copy files into .hg/largefiles atomically
Martin Geisler <mg@aragost.com>
parents:
15571
diff
changeset
|
76 # if hardlinks fail, fallback on atomic copy |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
77 with open(src, b'rb') as srcf, util.atomictempfile(dest) as dstf: |
33438 | 78 for chunk in util.filechunkiter(srcf): |
79 dstf.write(chunk) | |
15168 | 80 os.chmod(dest, os.stat(src).st_mode) |
81 | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
82 |
15316
c65f5b6e26d4
largefiles: rename functions and methods to match desired behavior
Benjamin Pollack <benjamin@bitquabit.com>
parents:
15304
diff
changeset
|
83 def usercachepath(ui, hash): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
84 """Return the correct location in the "global" largefiles cache for a file |
28574
7a4e1749cb07
largefiles: refactor usercachepath - extract user cache path function
Mads Kiilerich <madski@unity3d.com>
parents:
28560
diff
changeset
|
85 with the given hash. |
7a4e1749cb07
largefiles: refactor usercachepath - extract user cache path function
Mads Kiilerich <madski@unity3d.com>
parents:
28560
diff
changeset
|
86 This cache is used for sharing of largefiles across repositories - both |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
87 to preserve download bandwidth and storage space.""" |
28575
78e4e558fa74
largefiles: drop partial support for not having a user cache
Mads Kiilerich <madski@unity3d.com>
parents:
28574
diff
changeset
|
88 return os.path.join(_usercachedir(ui), hash) |
28574
7a4e1749cb07
largefiles: refactor usercachepath - extract user cache path function
Mads Kiilerich <madski@unity3d.com>
parents:
28560
diff
changeset
|
89 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
90 |
35279
be4481d6222e
largefiles: refactor _usercachedir() to allow reuse with lfs
Matt Harbison <matt_harbison@yahoo.com>
parents:
34757
diff
changeset
|
91 def _usercachedir(ui, name=longname): |
28574
7a4e1749cb07
largefiles: refactor usercachepath - extract user cache path function
Mads Kiilerich <madski@unity3d.com>
parents:
28560
diff
changeset
|
92 '''Return the location of the "global" largefiles cache.''' |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
93 path = ui.configpath(name, b'usercache') |
15168 | 94 if path: |
28574
7a4e1749cb07
largefiles: refactor usercachepath - extract user cache path function
Mads Kiilerich <madski@unity3d.com>
parents:
28560
diff
changeset
|
95 return path |
44379
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
96 |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
97 hint = None |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
98 |
34645 | 99 if pycompat.iswindows: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
100 appdata = encoding.environ.get( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
101 b'LOCALAPPDATA', encoding.environ.get(b'APPDATA') |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
102 ) |
28574
7a4e1749cb07
largefiles: refactor usercachepath - extract user cache path function
Mads Kiilerich <madski@unity3d.com>
parents:
28560
diff
changeset
|
103 if appdata: |
35279
be4481d6222e
largefiles: refactor _usercachedir() to allow reuse with lfs
Matt Harbison <matt_harbison@yahoo.com>
parents:
34757
diff
changeset
|
104 return os.path.join(appdata, name) |
44379
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
105 |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
106 hint = _(b"define %s or %s in the environment, or set %s.usercache") % ( |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
107 b"LOCALAPPDATA", |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
108 b"APPDATA", |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
109 name, |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
110 ) |
34647 | 111 elif pycompat.isdarwin: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
112 home = encoding.environ.get(b'HOME') |
28574
7a4e1749cb07
largefiles: refactor usercachepath - extract user cache path function
Mads Kiilerich <madski@unity3d.com>
parents:
28560
diff
changeset
|
113 if home: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
114 return os.path.join(home, b'Library', b'Caches', name) |
44379
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
115 |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
116 hint = _(b"define %s in the environment, or set %s.usercache") % ( |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
117 b"HOME", |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
118 name, |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
119 ) |
34646 | 120 elif pycompat.isposix: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
121 path = encoding.environ.get(b'XDG_CACHE_HOME') |
28574
7a4e1749cb07
largefiles: refactor usercachepath - extract user cache path function
Mads Kiilerich <madski@unity3d.com>
parents:
28560
diff
changeset
|
122 if path: |
35279
be4481d6222e
largefiles: refactor _usercachedir() to allow reuse with lfs
Matt Harbison <matt_harbison@yahoo.com>
parents:
34757
diff
changeset
|
123 return os.path.join(path, name) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
124 home = encoding.environ.get(b'HOME') |
28574
7a4e1749cb07
largefiles: refactor usercachepath - extract user cache path function
Mads Kiilerich <madski@unity3d.com>
parents:
28560
diff
changeset
|
125 if home: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
126 return os.path.join(home, b'.cache', name) |
44379
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
127 |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
128 hint = _(b"define %s or %s in the environment, or set %s.usercache") % ( |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
129 b"XDG_CACHE_HOME", |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
130 b"HOME", |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
131 name, |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
132 ) |
15168 | 133 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
134 raise error.Abort( |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
135 _(b'unknown operating system: %s\n') % pycompat.osname |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
136 ) |
44379
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
137 |
ca82929e433d
lfutil: provide a hint if the largefiles/lfs cache path cannot be determined
Matt Harbison <matt_harbison@yahoo.com>
parents:
44062
diff
changeset
|
138 raise error.Abort(_(b'unknown %s usercache location') % name, hint=hint) |
15168 | 139 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
140 |
15316
c65f5b6e26d4
largefiles: rename functions and methods to match desired behavior
Benjamin Pollack <benjamin@bitquabit.com>
parents:
15304
diff
changeset
|
141 def inusercache(ui, hash): |
15658
971c55ce03b8
largefiles: don't require a user cache (issue3088) (issue3155)
Kevin Gessner <kevin@fogcreek.com>
parents:
15572
diff
changeset
|
142 path = usercachepath(ui, hash) |
28575
78e4e558fa74
largefiles: drop partial support for not having a user cache
Mads Kiilerich <madski@unity3d.com>
parents:
28574
diff
changeset
|
143 return os.path.exists(path) |
15168 | 144 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
145 |
15168 | 146 def findfile(repo, hash): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
147 """Return store path of the largefile with the specified hash. |
28576
33bd95443e7f
largefiles: add some docstrings
Mads Kiilerich <madski@unity3d.com>
parents:
28575
diff
changeset
|
148 As a side effect, the file might be linked from user cache. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
149 Return None if the file can't be found locally.""" |
24631
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
150 path, exists = findstorepath(repo, hash) |
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
151 if exists: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
152 repo.ui.note(_(b'found %s in store\n') % hash) |
24631
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
153 return path |
15317
41f371150ccb
largefiles: make the store primary, and the user cache secondary
Benjamin Pollack <benjamin@bitquabit.com>
parents:
15316
diff
changeset
|
154 elif inusercache(repo.ui, hash): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
155 repo.ui.note(_(b'found %s in system cache\n') % hash) |
15408
db8b0ee74025
largefiles: ensure destination directory exists before findfile links to there
Hao Lian <hao@fogcreek.com>
parents:
15392
diff
changeset
|
156 path = storepath(repo, hash) |
db8b0ee74025
largefiles: ensure destination directory exists before findfile links to there
Hao Lian <hao@fogcreek.com>
parents:
15392
diff
changeset
|
157 link(usercachepath(repo.ui, hash), path) |
15913
c35dcde25174
largefiles: refactor lfutil.findfiles to be more logical
Na'Tosha Bard <natosha@unity3d.com>
parents:
15796
diff
changeset
|
158 return path |
c35dcde25174
largefiles: refactor lfutil.findfiles to be more logical
Na'Tosha Bard <natosha@unity3d.com>
parents:
15796
diff
changeset
|
159 return None |
15168 | 160 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
161 |
16247
d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
Na'Tosha Bard <natosha@unity3d.com>
parents:
16245
diff
changeset
|
162 class largefilesdirstate(dirstate.dirstate): |
15168 | 163 def __getitem__(self, key): |
16247
d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
Na'Tosha Bard <natosha@unity3d.com>
parents:
16245
diff
changeset
|
164 return super(largefilesdirstate, self).__getitem__(unixpath(key)) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
165 |
47593
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47545
diff
changeset
|
166 def set_tracked(self, f): |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47545
diff
changeset
|
167 return super(largefilesdirstate, self).set_tracked(unixpath(f)) |
f927ad5a4e2c
dirstate: add a `set_tracked` method for "hg add"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47545
diff
changeset
|
168 |
47599
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47593
diff
changeset
|
169 def set_untracked(self, f): |
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47593
diff
changeset
|
170 return super(largefilesdirstate, self).set_untracked(unixpath(f)) |
cce51119bfe6
dirstate: add a `set_untracked` method for "hg remove"-like usage
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47593
diff
changeset
|
171 |
47712
95b864a670df
largefile: respect the `normal` signature
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47700
diff
changeset
|
172 def normal(self, f, parentfiledata=None): |
95b864a670df
largefile: respect the `normal` signature
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47700
diff
changeset
|
173 # not sure if we should pass the `parentfiledata` down or throw it |
95b864a670df
largefile: respect the `normal` signature
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47700
diff
changeset
|
174 # away. So throwing it away to stay on the safe side. |
16247
d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
Na'Tosha Bard <natosha@unity3d.com>
parents:
16245
diff
changeset
|
175 return super(largefilesdirstate, self).normal(unixpath(f)) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
176 |
15168 | 177 def remove(self, f): |
16247
d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
Na'Tosha Bard <natosha@unity3d.com>
parents:
16245
diff
changeset
|
178 return super(largefilesdirstate, self).remove(unixpath(f)) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
179 |
15168 | 180 def add(self, f): |
16247
d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
Na'Tosha Bard <natosha@unity3d.com>
parents:
16245
diff
changeset
|
181 return super(largefilesdirstate, self).add(unixpath(f)) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
182 |
15168 | 183 def drop(self, f): |
16247
d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
Na'Tosha Bard <natosha@unity3d.com>
parents:
16245
diff
changeset
|
184 return super(largefilesdirstate, self).drop(unixpath(f)) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
185 |
15168 | 186 def forget(self, f): |
16247
d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
Na'Tosha Bard <natosha@unity3d.com>
parents:
16245
diff
changeset
|
187 return super(largefilesdirstate, self).forget(unixpath(f)) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
188 |
15793
3ef07ecdb0d5
largefiles: correctly handle dirstate status when rebasing
Na'Tosha Bard <natosha@unity3d.com>
parents:
15700
diff
changeset
|
189 def normallookup(self, f): |
16247
d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
Na'Tosha Bard <natosha@unity3d.com>
parents:
16245
diff
changeset
|
190 return super(largefilesdirstate, self).normallookup(unixpath(f)) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
191 |
21085
66c6da0bc7e2
largefiles: fix profile of unused largefilesdirstate._ignore
Mads Kiilerich <madski@unity3d.com>
parents:
21042
diff
changeset
|
192 def _ignore(self, f): |
18148
bf6252d12c34
largefiles: simplify lfdirstate ignore handling - it is only for tracking .hglf
Mads Kiilerich <madski@unity3d.com>
parents:
18147
diff
changeset
|
193 return False |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
194 |
48168
df3021c1f093
largefiles: pass current transaction to `lfdirstate.write()`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
48144
diff
changeset
|
195 def write(self, tr): |
26749
4a82cb5c1dc8
dirstate: show develwarn for write() invocation without transaction
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26627
diff
changeset
|
196 # (1) disable PENDING mode always |
4a82cb5c1dc8
dirstate: show develwarn for write() invocation without transaction
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26627
diff
changeset
|
197 # (lfdirstate isn't yet managed as a part of the transaction) |
4a82cb5c1dc8
dirstate: show develwarn for write() invocation without transaction
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26627
diff
changeset
|
198 # (2) avoid develwarn 'use dirstate.write with ....' |
48169
1e98f9b5bc71
largefiles: add tr backup for largefilesdirstate
Pulkit Goyal <7895pulkit@gmail.com>
parents:
48168
diff
changeset
|
199 if tr: |
1e98f9b5bc71
largefiles: add tr backup for largefilesdirstate
Pulkit Goyal <7895pulkit@gmail.com>
parents:
48168
diff
changeset
|
200 tr.addbackup(b'largefiles/dirstate', location=b'plain') |
26749
4a82cb5c1dc8
dirstate: show develwarn for write() invocation without transaction
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
26627
diff
changeset
|
201 super(largefilesdirstate, self).write(None) |
15168 | 202 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
203 |
17659
ae57920ac188
largefiles: enable islfilesrepo() prior to a commit (issue3541)
Matt Harbison <matt_harbison@yahoo.com>
parents:
17270
diff
changeset
|
204 def openlfdirstate(ui, repo, create=True): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
205 """ |
15252
6e809bb4f969
largefiles: improve comments, internal docstrings
Greg Ward <greg@gerg.ca>
parents:
15228
diff
changeset
|
206 Return a dirstate object that tracks largefiles: i.e. its root is |
6e809bb4f969
largefiles: improve comments, internal docstrings
Greg Ward <greg@gerg.ca>
parents:
15228
diff
changeset
|
207 the repo root, but it is saved in .hg/largefiles/dirstate. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
208 """ |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
209 vfs = repo.vfs |
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
210 lfstoredir = longname |
31247
04b4286278ec
vfs: use 'vfs' module directly in 'hgext.largefile'
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
31216
diff
changeset
|
211 opener = vfsmod.vfs(vfs.join(lfstoredir)) |
47280
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47012
diff
changeset
|
212 use_dirstate_v2 = requirements.DIRSTATE_V2_REQUIREMENT in repo.requirements |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
213 lfdirstate = largefilesdirstate( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
214 opener, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
215 ui, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
216 repo.root, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
217 repo.dirstate._validate, |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
218 lambda: sparse.matcher(repo), |
46780
6266d19556ad
node: introduce nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46113
diff
changeset
|
219 repo.nodeconstants, |
47280
1766130fe9ba
dirstate-v2: Change the on-disk format when the requirement is enabled
Simon Sapin <simon.sapin@octobus.net>
parents:
47012
diff
changeset
|
220 use_dirstate_v2, |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
221 ) |
15168 | 222 |
15252
6e809bb4f969
largefiles: improve comments, internal docstrings
Greg Ward <greg@gerg.ca>
parents:
15228
diff
changeset
|
223 # If the largefiles dirstate does not exist, populate and create |
6e809bb4f969
largefiles: improve comments, internal docstrings
Greg Ward <greg@gerg.ca>
parents:
15228
diff
changeset
|
224 # it. This ensures that we create it on the first meaningful |
15794
0d91211dd12f
largefiles: fix inappropriate locking (issue3182)
Levi Bard <levi@unity3d.com>
parents:
15793
diff
changeset
|
225 # largefiles operation in a new clone. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
226 if create and not vfs.exists(vfs.join(lfstoredir, b'dirstate')): |
15168 | 227 matcher = getstandinmatcher(repo) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
228 standins = repo.dirstate.walk( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
229 matcher, subrepos=[], unknown=False, ignored=False |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
230 ) |
21917
ac3b3a2d976d
largefiles: avoid unnecessary creation of .hg/largefiles when opening lfdirstate
Matt Harbison <matt_harbison@yahoo.com>
parents:
21085
diff
changeset
|
231 |
ac3b3a2d976d
largefiles: avoid unnecessary creation of .hg/largefiles when opening lfdirstate
Matt Harbison <matt_harbison@yahoo.com>
parents:
21085
diff
changeset
|
232 if len(standins) > 0: |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
233 vfs.makedirs(lfstoredir) |
21917
ac3b3a2d976d
largefiles: avoid unnecessary creation of .hg/largefiles when opening lfdirstate
Matt Harbison <matt_harbison@yahoo.com>
parents:
21085
diff
changeset
|
234 |
47723
0ed2f74f6e3a
largefile: replace the `normallookup` call when creating a new lfdirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47716
diff
changeset
|
235 with lfdirstate.parentchange(): |
0ed2f74f6e3a
largefile: replace the `normallookup` call when creating a new lfdirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47716
diff
changeset
|
236 for standin in standins: |
0ed2f74f6e3a
largefile: replace the `normallookup` call when creating a new lfdirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47716
diff
changeset
|
237 lfile = splitstandin(standin) |
0ed2f74f6e3a
largefile: replace the `normallookup` call when creating a new lfdirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47716
diff
changeset
|
238 lfdirstate.update_file( |
0ed2f74f6e3a
largefile: replace the `normallookup` call when creating a new lfdirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47716
diff
changeset
|
239 lfile, p1_tracked=True, wc_tracked=True, possibly_dirty=True |
0ed2f74f6e3a
largefile: replace the `normallookup` call when creating a new lfdirstate
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47716
diff
changeset
|
240 ) |
15168 | 241 return lfdirstate |
242 | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
243 |
23039
1350b9170089
largefiles: remove confusing rev parameter for lfdirstatestatus
Mads Kiilerich <madski@unity3d.com>
parents:
22919
diff
changeset
|
244 def lfdirstatestatus(lfdirstate, repo): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
245 pctx = repo[b'.'] |
41676
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41397
diff
changeset
|
246 match = matchmod.always() |
48390
322525db4c98
status: use filesystem time boundary to invalidate racy mtime
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48382
diff
changeset
|
247 unsure, s, mtime_boundary = lfdirstate.status( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
248 match, subrepos=[], ignored=False, clean=False, unknown=False |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
249 ) |
22919
1982bdb7e2cc
largefiles: access status fields by name rather than index
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22912
diff
changeset
|
250 modified, clean = s.modified, s.clean |
48382
991e6f728b50
status: adapt largefile to gather stats at lookup time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48169
diff
changeset
|
251 wctx = repo[None] |
15794
0d91211dd12f
largefiles: fix inappropriate locking (issue3182)
Levi Bard <levi@unity3d.com>
parents:
15793
diff
changeset
|
252 for lfile in unsure: |
18299
a7a88a458a4c
largefiles: fix revert removing a largefile from a merge
Mads Kiilerich <madski@unity3d.com>
parents:
18154
diff
changeset
|
253 try: |
31657
641f3a6098d0
largefiles: rename local variable appropriately
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31652
diff
changeset
|
254 fctx = pctx[standin(lfile)] |
18299
a7a88a458a4c
largefiles: fix revert removing a largefile from a merge
Mads Kiilerich <madski@unity3d.com>
parents:
18154
diff
changeset
|
255 except LookupError: |
a7a88a458a4c
largefiles: fix revert removing a largefile from a merge
Mads Kiilerich <madski@unity3d.com>
parents:
18154
diff
changeset
|
256 fctx = None |
31740
a40e979b9d97
largefiles: use readasstandin() to read hex hash directly from filectx
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31739
diff
changeset
|
257 if not fctx or readasstandin(fctx) != hashfile(repo.wjoin(lfile)): |
15794
0d91211dd12f
largefiles: fix inappropriate locking (issue3182)
Levi Bard <levi@unity3d.com>
parents:
15793
diff
changeset
|
258 modified.append(lfile) |
0d91211dd12f
largefiles: fix inappropriate locking (issue3182)
Levi Bard <levi@unity3d.com>
parents:
15793
diff
changeset
|
259 else: |
0d91211dd12f
largefiles: fix inappropriate locking (issue3182)
Levi Bard <levi@unity3d.com>
parents:
15793
diff
changeset
|
260 clean.append(lfile) |
48382
991e6f728b50
status: adapt largefile to gather stats at lookup time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48169
diff
changeset
|
261 st = wctx[lfile].lstat() |
991e6f728b50
status: adapt largefile to gather stats at lookup time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48169
diff
changeset
|
262 mode = st.st_mode |
991e6f728b50
status: adapt largefile to gather stats at lookup time
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48169
diff
changeset
|
263 size = st.st_size |
48396
c0d88407b7d4
largefile: use the proper "mtime boundary" logic during fixup
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48390
diff
changeset
|
264 mtime = timestamp.reliable_mtime_of(st, mtime_boundary) |
c0d88407b7d4
largefile: use the proper "mtime boundary" logic during fixup
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48390
diff
changeset
|
265 if mtime is not None: |
c0d88407b7d4
largefile: use the proper "mtime boundary" logic during fixup
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48390
diff
changeset
|
266 cache_data = (mode, size, mtime) |
c0d88407b7d4
largefile: use the proper "mtime boundary" logic during fixup
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48390
diff
changeset
|
267 lfdirstate.set_clean(lfile, cache_data) |
22912
3b8e6c095239
lfutil: avoid creating unnecessary copy of status tuple
Martin von Zweigbergk <martinvonz@gmail.com>
parents:
22911
diff
changeset
|
268 return s |
15168 | 269 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
270 |
15168 | 271 def listlfiles(repo, rev=None, matcher=None): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
272 """return a list of largefiles in the working copy or the |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
273 specified changeset""" |
15168 | 274 |
275 if matcher is None: | |
276 matcher = getstandinmatcher(repo) | |
277 | |
278 # ignore unknown files in working directory | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
279 return [ |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
280 splitstandin(f) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
281 for f in repo[rev].walk(matcher) |
48106
82e142b9ad18
dirstate-item: use item's property instead of `state` in largefile
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47755
diff
changeset
|
282 if rev is not None or repo.dirstate.get_entry(f).any_tracked |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
283 ] |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
284 |
15168 | 285 |
24631
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
286 def instore(repo, hash, forcelocal=False): |
29419
01c0324acfec
largefiles: fix misleading comments in lfutil instore and storepath
liscju <piotr.listkiewicz@gmail.com>
parents:
29349
diff
changeset
|
287 '''Return true if a largefile with the given hash exists in the store''' |
24631
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
288 return os.path.exists(storepath(repo, hash, forcelocal)) |
15168 | 289 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
290 |
24631
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
291 def storepath(repo, hash, forcelocal=False): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
292 """Return the correct location in the repository largefiles store for a |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
293 file with the given hash.""" |
24631
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
294 if not forcelocal and repo.shared(): |
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
295 return repo.vfs.reljoin(repo.sharedpath, longname, hash) |
31332
a5ae1d79e271
largefiles: directly use repo.vfs.join
Pierre-Yves David <pierre-yves.david@ens-lyon.org>
parents:
31247
diff
changeset
|
296 return repo.vfs.join(longname, hash) |
15168 | 297 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
298 |
24629
8dc2533f03ef
largefiles: introduce lfutil.findstorepath()
Matt Harbison <matt_harbison@yahoo.com>
parents:
24627
diff
changeset
|
299 def findstorepath(repo, hash): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
300 """Search through the local store path(s) to find the file for the given |
24629
8dc2533f03ef
largefiles: introduce lfutil.findstorepath()
Matt Harbison <matt_harbison@yahoo.com>
parents:
24627
diff
changeset
|
301 hash. If the file is not found, its path in the primary store is returned. |
8dc2533f03ef
largefiles: introduce lfutil.findstorepath()
Matt Harbison <matt_harbison@yahoo.com>
parents:
24627
diff
changeset
|
302 The return value is a tuple of (path, exists(path)). |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
303 """ |
24631
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
304 # For shared repos, the primary store is in the share source. But for |
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
305 # backward compatibility, force a lookup in the local store if it wasn't |
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
306 # found in the share source. |
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
307 path = storepath(repo, hash, False) |
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
308 |
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
309 if instore(repo, hash): |
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
310 return (path, True) |
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
311 elif repo.shared() and instore(repo, hash, True): |
29329
f359cdc91e21
largefiles: fix support for local largefiles while using share extension
Henrik Stuart <henriks@unity3d.com>
parents:
28877
diff
changeset
|
312 return storepath(repo, hash, True), True |
24631
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
313 |
2a3f24786d09
largefiles: use the share source as the primary local store (issue4471)
Matt Harbison <matt_harbison@yahoo.com>
parents:
24629
diff
changeset
|
314 return (path, False) |
24629
8dc2533f03ef
largefiles: introduce lfutil.findstorepath()
Matt Harbison <matt_harbison@yahoo.com>
parents:
24627
diff
changeset
|
315 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
316 |
15168 | 317 def copyfromcache(repo, hash, filename): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
318 """Copy the specified largefile from the repo or system cache to |
15252
6e809bb4f969
largefiles: improve comments, internal docstrings
Greg Ward <greg@gerg.ca>
parents:
15228
diff
changeset
|
319 filename in the repository. Return true on success or false if the |
6e809bb4f969
largefiles: improve comments, internal docstrings
Greg Ward <greg@gerg.ca>
parents:
15228
diff
changeset
|
320 file was not found in either cache (which should not happened: |
6e809bb4f969
largefiles: improve comments, internal docstrings
Greg Ward <greg@gerg.ca>
parents:
15228
diff
changeset
|
321 this is meant to be called only after ensuring that the needed |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
322 largefile exists in the cache).""" |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
323 wvfs = repo.wvfs |
15168 | 324 path = findfile(repo, hash) |
325 if path is None: | |
326 return False | |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
327 wvfs.makedirs(wvfs.dirname(wvfs.join(filename))) |
15570
0f208626d503
largefiles: add comment about non-atomic working directory
Martin Geisler <mg@aragost.com>
parents:
15553
diff
changeset
|
328 # The write may fail before the file is fully written, but we |
0f208626d503
largefiles: add comment about non-atomic working directory
Martin Geisler <mg@aragost.com>
parents:
15553
diff
changeset
|
329 # don't use atomic writes in the working copy. |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
330 with open(path, b'rb') as srcfd, wvfs(filename, b'wb') as destfd: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
331 gothash = copyandhash(util.filechunkiter(srcfd), destfd) |
26823
45e8bd2f36f0
largefiles: check hash of files in the store before copying to working dir
Mads Kiilerich <madski@unity3d.com>
parents:
26817
diff
changeset
|
332 if gothash != hash: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
333 repo.ui.warn( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
334 _(b'%s: data corruption in %s with hash %s\n') |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
335 % (filename, path, gothash) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
336 ) |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
337 wvfs.unlink(filename) |
26823
45e8bd2f36f0
largefiles: check hash of files in the store before copying to working dir
Mads Kiilerich <madski@unity3d.com>
parents:
26817
diff
changeset
|
338 return False |
15168 | 339 return True |
340 | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
341 |
31738
068b06b43cdf
largefiles: make copytostore() accept only changectx as the 2nd argument (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31737
diff
changeset
|
342 def copytostore(repo, ctx, file, fstandin): |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
343 wvfs = repo.wvfs |
31738
068b06b43cdf
largefiles: make copytostore() accept only changectx as the 2nd argument (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31737
diff
changeset
|
344 hash = readasstandin(ctx[fstandin]) |
15316
c65f5b6e26d4
largefiles: rename functions and methods to match desired behavior
Benjamin Pollack <benjamin@bitquabit.com>
parents:
15304
diff
changeset
|
345 if instore(repo, hash): |
15168 | 346 return |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
347 if wvfs.exists(file): |
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
348 copytostoreabsolute(repo, wvfs.join(file), hash) |
27903
512a814c5595
largefiles: fix commit of missing largefiles
Mads Kiilerich <madski@unity3d.com>
parents:
26823
diff
changeset
|
349 else: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
350 repo.ui.warn( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
351 _(b"%s: largefile %s not available from local store\n") |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
352 % (file, hash) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
353 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
354 |
15168 | 355 |
15796
3e5b6045ccfc
largefiles: factor out a copyalltostore() function
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
15794
diff
changeset
|
356 def copyalltostore(repo, node): |
3e5b6045ccfc
largefiles: factor out a copyalltostore() function
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
15794
diff
changeset
|
357 '''Copy all largefiles in a given revision to the store''' |
3e5b6045ccfc
largefiles: factor out a copyalltostore() function
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
15794
diff
changeset
|
358 |
3e5b6045ccfc
largefiles: factor out a copyalltostore() function
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
15794
diff
changeset
|
359 ctx = repo[node] |
3e5b6045ccfc
largefiles: factor out a copyalltostore() function
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
15794
diff
changeset
|
360 for filename in ctx.files(): |
31613
5c1d3f1b8f44
largefiles: omit redundant isstandin() before splitstandin()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31332
diff
changeset
|
361 realfile = splitstandin(filename) |
5c1d3f1b8f44
largefiles: omit redundant isstandin() before splitstandin()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31332
diff
changeset
|
362 if realfile is not None and filename in ctx.manifest(): |
31736
dd2079fae003
largefiles: add copytostore() fstandin argument to replace readstandin() (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31735
diff
changeset
|
363 copytostore(repo, ctx, realfile, filename) |
15796
3e5b6045ccfc
largefiles: factor out a copyalltostore() function
Dan Villiom Podlaski Christiansen <danchr@gmail.com>
parents:
15794
diff
changeset
|
364 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
365 |
15316
c65f5b6e26d4
largefiles: rename functions and methods to match desired behavior
Benjamin Pollack <benjamin@bitquabit.com>
parents:
15304
diff
changeset
|
366 def copytostoreabsolute(repo, file, hash): |
c65f5b6e26d4
largefiles: rename functions and methods to match desired behavior
Benjamin Pollack <benjamin@bitquabit.com>
parents:
15304
diff
changeset
|
367 if inusercache(repo.ui, hash): |
c65f5b6e26d4
largefiles: rename functions and methods to match desired behavior
Benjamin Pollack <benjamin@bitquabit.com>
parents:
15304
diff
changeset
|
368 link(usercachepath(repo.ui, hash), storepath(repo, hash)) |
23276
4be754832829
largefiles: move "copyalltostore" invocation into "markcommitted"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23274
diff
changeset
|
369 else: |
18998
d035c3902111
largefiles: refactoring - create destination dir in lfutil.link
Mads Kiilerich <madski@unity3d.com>
parents:
18980
diff
changeset
|
370 util.makedirs(os.path.dirname(storepath(repo, hash))) |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
371 with open(file, b'rb') as srcf: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
372 with util.atomictempfile( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
373 storepath(repo, hash), createmode=repo.store.createmode |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
374 ) as dstf: |
30142
3dcaf1c4e90d
largefiles: use context for file closing
Mads Kiilerich <madski@unity3d.com>
parents:
29644
diff
changeset
|
375 for chunk in util.filechunkiter(srcf): |
3dcaf1c4e90d
largefiles: use context for file closing
Mads Kiilerich <madski@unity3d.com>
parents:
29644
diff
changeset
|
376 dstf.write(chunk) |
15316
c65f5b6e26d4
largefiles: rename functions and methods to match desired behavior
Benjamin Pollack <benjamin@bitquabit.com>
parents:
15304
diff
changeset
|
377 linktousercache(repo, hash) |
15168 | 378 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
379 |
15316
c65f5b6e26d4
largefiles: rename functions and methods to match desired behavior
Benjamin Pollack <benjamin@bitquabit.com>
parents:
15304
diff
changeset
|
380 def linktousercache(repo, hash): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
381 """Link / copy the largefile with the specified hash from the store |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
382 to the cache.""" |
15658
971c55ce03b8
largefiles: don't require a user cache (issue3088) (issue3155)
Kevin Gessner <kevin@fogcreek.com>
parents:
15572
diff
changeset
|
383 path = usercachepath(repo.ui, hash) |
28575
78e4e558fa74
largefiles: drop partial support for not having a user cache
Mads Kiilerich <madski@unity3d.com>
parents:
28574
diff
changeset
|
384 link(storepath(repo, hash), path) |
15168 | 385 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
386 |
25292
31d543cd7062
largefiles: pass in whole matcher to getstandinmatcher()
Martin von Zweigbergk <martinvonz@google.com>
parents:
25291
diff
changeset
|
387 def getstandinmatcher(repo, rmatcher=None): |
31d543cd7062
largefiles: pass in whole matcher to getstandinmatcher()
Martin von Zweigbergk <martinvonz@google.com>
parents:
25291
diff
changeset
|
388 '''Return a match object that applies rmatcher to the standin directory''' |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
389 wvfs = repo.wvfs |
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
390 standindir = shortname |
25470
378a8e700e02
largefiles: use the optional badfn argument when building a matcher
Matt Harbison <matt_harbison@yahoo.com>
parents:
25293
diff
changeset
|
391 |
378a8e700e02
largefiles: use the optional badfn argument when building a matcher
Matt Harbison <matt_harbison@yahoo.com>
parents:
25293
diff
changeset
|
392 # no warnings about missing files or directories |
378a8e700e02
largefiles: use the optional badfn argument when building a matcher
Matt Harbison <matt_harbison@yahoo.com>
parents:
25293
diff
changeset
|
393 badfn = lambda f, msg: None |
378a8e700e02
largefiles: use the optional badfn argument when building a matcher
Matt Harbison <matt_harbison@yahoo.com>
parents:
25293
diff
changeset
|
394 |
25293
ab618e52788a
largefiles: avoid match.files() in conditions
Martin von Zweigbergk <martinvonz@google.com>
parents:
25292
diff
changeset
|
395 if rmatcher and not rmatcher.always(): |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
396 pats = [wvfs.join(standindir, pat) for pat in rmatcher.files()] |
26025
ba8089433090
largefiles: ensure lfutil.getstandinmatcher() only matches standins
Matt Harbison <matt_harbison@yahoo.com>
parents:
25470
diff
changeset
|
397 if not pats: |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
398 pats = [wvfs.join(standindir)] |
25470
378a8e700e02
largefiles: use the optional badfn argument when building a matcher
Matt Harbison <matt_harbison@yahoo.com>
parents:
25293
diff
changeset
|
399 match = scmutil.match(repo[None], pats, badfn=badfn) |
18724
894a5897a9dd
largefiles: getstandinmatcher should not depend on existence of directories
Mads Kiilerich <madski@unity3d.com>
parents:
18490
diff
changeset
|
400 else: |
15168 | 401 # no patterns: relative to repo root |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
402 match = scmutil.match(repo[None], [wvfs.join(standindir)], badfn=badfn) |
15168 | 403 return match |
404 | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
405 |
15168 | 406 def composestandinmatcher(repo, rmatcher): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
407 """Return a matcher that accepts standins corresponding to the |
15252
6e809bb4f969
largefiles: improve comments, internal docstrings
Greg Ward <greg@gerg.ca>
parents:
15228
diff
changeset
|
408 files accepted by rmatcher. Pass the list of files in the matcher |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
409 as the paths specified by the user.""" |
25292
31d543cd7062
largefiles: pass in whole matcher to getstandinmatcher()
Martin von Zweigbergk <martinvonz@google.com>
parents:
25291
diff
changeset
|
410 smatcher = getstandinmatcher(repo, rmatcher) |
15168 | 411 isstandin = smatcher.matchfn |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
412 |
16247
d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
Na'Tosha Bard <natosha@unity3d.com>
parents:
16245
diff
changeset
|
413 def composedmatchfn(f): |
15168 | 414 return isstandin(f) and rmatcher.matchfn(splitstandin(f)) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
415 |
16247
d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
Na'Tosha Bard <natosha@unity3d.com>
parents:
16245
diff
changeset
|
416 smatcher.matchfn = composedmatchfn |
15168 | 417 |
418 return smatcher | |
419 | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
420 |
15168 | 421 def standin(filename): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
422 """Return the repo-relative path to the standin for the specified big |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
423 file.""" |
15168 | 424 # Notes: |
17425
e95ec38f86b0
fix wording and not-completely-trivial spelling errors and bad docstrings
Mads Kiilerich <mads@kiilerich.com>
parents:
17270
diff
changeset
|
425 # 1) Some callers want an absolute path, but for instance addlargefiles |
18154
93c697d9c158
largefiles: remove trivial portability wrappers
Mads Kiilerich <madski@unity3d.com>
parents:
18153
diff
changeset
|
426 # needs it repo-relative so it can be passed to repo[None].add(). So |
93c697d9c158
largefiles: remove trivial portability wrappers
Mads Kiilerich <madski@unity3d.com>
parents:
18153
diff
changeset
|
427 # leave it up to the caller to use repo.wjoin() to get an absolute path. |
15168 | 428 # 2) Join with '/' because that's what dirstate always uses, even on |
429 # Windows. Change existing separator to '/' first in case we are | |
430 # passed filenames from an external source (like the command line). | |
18151
90ad387d9245
largefiles: use constant for '.hglf/'
Mads Kiilerich <madski@unity3d.com>
parents:
18150
diff
changeset
|
431 return shortnameslash + util.pconvert(filename) |
15168 | 432 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
433 |
15168 | 434 def isstandin(filename): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
435 """Return true if filename is a big file standin. filename must be |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
436 in Mercurial's internal form (slash-separated).""" |
18151
90ad387d9245
largefiles: use constant for '.hglf/'
Mads Kiilerich <madski@unity3d.com>
parents:
18150
diff
changeset
|
437 return filename.startswith(shortnameslash) |
15168 | 438 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
439 |
15168 | 440 def splitstandin(filename): |
441 # Split on / because that's what dirstate always uses, even on Windows. | |
442 # Change local separator to / first just in case we are passed filenames | |
443 # from an external source (like the command line). | |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
444 bits = util.pconvert(filename).split(b'/', 1) |
15168 | 445 if len(bits) == 2 and bits[0] == shortname: |
446 return bits[1] | |
447 else: | |
448 return None | |
449 | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
450 |
31659
0eec36112e58
largefiles: add lfile argument to updatestandin() for efficiency (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31657
diff
changeset
|
451 def updatestandin(repo, lfile, standin): |
0eec36112e58
largefiles: add lfile argument to updatestandin() for efficiency (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31657
diff
changeset
|
452 """Re-calculate hash value of lfile and write it into standin |
0eec36112e58
largefiles: add lfile argument to updatestandin() for efficiency (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31657
diff
changeset
|
453 |
0eec36112e58
largefiles: add lfile argument to updatestandin() for efficiency (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31657
diff
changeset
|
454 This assumes that "lfutil.standin(lfile) == standin", for efficiency. |
0eec36112e58
largefiles: add lfile argument to updatestandin() for efficiency (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31657
diff
changeset
|
455 """ |
31615
f0f316cb8259
largefiles: omit redundant splitstandin() invocations
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31613
diff
changeset
|
456 file = repo.wjoin(lfile) |
f0f316cb8259
largefiles: omit redundant splitstandin() invocations
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31613
diff
changeset
|
457 if repo.wvfs.exists(lfile): |
15168 | 458 hash = hashfile(file) |
459 executable = getexecutable(file) | |
460 writestandin(repo, standin, hash, executable) | |
27947
571ba161f6be
largefiles: prevent committing a missing largefile
Matt Harbison <matt_harbison@yahoo.com>
parents:
27942
diff
changeset
|
461 else: |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
462 raise error.Abort(_(b'%s: file not found!') % lfile) |
15168 | 463 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
464 |
31734
44ff5e4ffc8c
largefiles: introduce readasstandin() to read hex hash from given filectx
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31659
diff
changeset
|
465 def readasstandin(fctx): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
466 """read hex hash from given filectx of standin file |
31734
44ff5e4ffc8c
largefiles: introduce readasstandin() to read hex hash from given filectx
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31659
diff
changeset
|
467 |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
468 This encapsulates how "standin" data is stored into storage layer.""" |
31734
44ff5e4ffc8c
largefiles: introduce readasstandin() to read hex hash from given filectx
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31659
diff
changeset
|
469 return fctx.data().strip() |
44ff5e4ffc8c
largefiles: introduce readasstandin() to read hex hash from given filectx
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31659
diff
changeset
|
470 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
471 |
15168 | 472 def writestandin(repo, standin, hash, executable): |
15252
6e809bb4f969
largefiles: improve comments, internal docstrings
Greg Ward <greg@gerg.ca>
parents:
15228
diff
changeset
|
473 '''write hash to <repo.root>/<standin>''' |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
474 repo.wwrite(standin, hash + b'\n', executable and b'x' or b'') |
15168 | 475 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
476 |
15168 | 477 def copyandhash(instream, outfile): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
478 """Read bytes from instream (iterable) and write them to outfile, |
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
479 computing the SHA-1 hash of the data along the way. Return the hash.""" |
44062
2d49482d0dd4
hgext: replace references to hashlib.sha1 with hashutil.sha1
Augie Fackler <augie@google.com>
parents:
43584
diff
changeset
|
480 hasher = hashutil.sha1(b'') |
15168 | 481 for data in instream: |
482 hasher.update(data) | |
483 outfile.write(data) | |
36112
6426878f7f0f
py3: use hex(hasher.digest())
Gregory Szorc <gregory.szorc@gmail.com>
parents:
35279
diff
changeset
|
484 return hex(hasher.digest()) |
15168 | 485 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
486 |
15168 | 487 def hashfile(file): |
488 if not os.path.exists(file): | |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
489 return b'' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
490 with open(file, b'rb') as fd: |
31652
d5cbbee542eb
largefiles: reuse hexsha1() to centralize hash calculation logic into it
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31618
diff
changeset
|
491 return hexsha1(fd) |
15168 | 492 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
493 |
15168 | 494 def getexecutable(filename): |
495 mode = os.stat(filename).st_mode | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
496 return ( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
497 (mode & stat.S_IXUSR) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
498 and (mode & stat.S_IXGRP) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
499 and (mode & stat.S_IXOTH) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
500 ) |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
501 |
15168 | 502 |
503 def urljoin(first, second, *arg): | |
504 def join(left, right): | |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
505 if not left.endswith(b'/'): |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
506 left += b'/' |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
507 if right.startswith(b'/'): |
15168 | 508 right = right[1:] |
509 return left + right | |
510 | |
511 url = join(first, second) | |
512 for a in arg: | |
513 url = join(url, a) | |
514 return url | |
515 | |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
516 |
31652
d5cbbee542eb
largefiles: reuse hexsha1() to centralize hash calculation logic into it
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31618
diff
changeset
|
517 def hexsha1(fileobj): |
15168 | 518 """hexsha1 returns the hex-encoded sha1 sum of the data in the file-like |
519 object data""" | |
44062
2d49482d0dd4
hgext: replace references to hashlib.sha1 with hashutil.sha1
Augie Fackler <augie@google.com>
parents:
43584
diff
changeset
|
520 h = hashutil.sha1() |
31652
d5cbbee542eb
largefiles: reuse hexsha1() to centralize hash calculation logic into it
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31618
diff
changeset
|
521 for chunk in util.filechunkiter(fileobj): |
15168 | 522 h.update(chunk) |
36112
6426878f7f0f
py3: use hex(hasher.digest())
Gregory Szorc <gregory.szorc@gmail.com>
parents:
35279
diff
changeset
|
523 return hex(h.digest()) |
15168 | 524 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
525 |
15168 | 526 def httpsendfile(ui, filename): |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
527 return httpconnection.httpsendfile(ui, filename, b'rb') |
15168 | 528 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
529 |
15168 | 530 def unixpath(path): |
15252
6e809bb4f969
largefiles: improve comments, internal docstrings
Greg Ward <greg@gerg.ca>
parents:
15228
diff
changeset
|
531 '''Return a version of path normalized for use with the lfdirstate.''' |
16066
6a42846cf769
i18n: use util.pconvert() instead of 'str.replace()' for problematic encoding
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
15915
diff
changeset
|
532 return util.pconvert(os.path.normpath(path)) |
15168 | 533 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
534 |
15168 | 535 def islfilesrepo(repo): |
28576
33bd95443e7f
largefiles: add some docstrings
Mads Kiilerich <madski@unity3d.com>
parents:
28575
diff
changeset
|
536 '''Return true if the repo is a largefile repo.''' |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
537 if b'largefiles' in repo.requirements and any( |
46895
6085b7f1536d
store: also return some information about the type of file `walk` found
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
46780
diff
changeset
|
538 shortnameslash in f[1] for f in repo.store.datafiles() |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
539 ): |
17659
ae57920ac188
largefiles: enable islfilesrepo() prior to a commit (issue3541)
Matt Harbison <matt_harbison@yahoo.com>
parents:
17270
diff
changeset
|
540 return True |
ae57920ac188
largefiles: enable islfilesrepo() prior to a commit (issue3541)
Matt Harbison <matt_harbison@yahoo.com>
parents:
17270
diff
changeset
|
541 |
25149
3f0744eeaeaf
cleanup: use __builtins__.any instead of util.any
Augie Fackler <augie@google.com>
parents:
24631
diff
changeset
|
542 return any(openlfdirstate(repo.ui, repo, False)) |
15168 | 543 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
544 |
15333
f37b71fec602
largefiles: py2.4 doesn't have BaseException
Matt Mackall <mpm@selenic.com>
parents:
15320
diff
changeset
|
545 class storeprotonotcapable(Exception): |
15168 | 546 def __init__(self, storetypes): |
547 self.storetypes = storetypes | |
16103
3e1efb458e8b
largefiles: only cache largefiles in new heads
Na'Tosha Bard <natosha@unity3d.com>
parents:
16066
diff
changeset
|
548 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
549 |
16120
47ee41fcf42b
largefiles: optimize update speed by only updating changed largefiles
Na'Tosha Bard <natosha@unity3d.com>
parents:
16103
diff
changeset
|
550 def getstandinsstate(repo): |
47ee41fcf42b
largefiles: optimize update speed by only updating changed largefiles
Na'Tosha Bard <natosha@unity3d.com>
parents:
16103
diff
changeset
|
551 standins = [] |
47ee41fcf42b
largefiles: optimize update speed by only updating changed largefiles
Na'Tosha Bard <natosha@unity3d.com>
parents:
16103
diff
changeset
|
552 matcher = getstandinmatcher(repo) |
31735
3e37b479ce2f
largefiles: replace readstandin() by readasstandin()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31734
diff
changeset
|
553 wctx = repo[None] |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
554 for standin in repo.dirstate.walk( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
555 matcher, subrepos=[], unknown=False, ignored=False |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
556 ): |
16120
47ee41fcf42b
largefiles: optimize update speed by only updating changed largefiles
Na'Tosha Bard <natosha@unity3d.com>
parents:
16103
diff
changeset
|
557 lfile = splitstandin(standin) |
18300
745bc16ccef2
largefiles: fix update from a merge with removed files
Mads Kiilerich <madski@unity3d.com>
parents:
18299
diff
changeset
|
558 try: |
31735
3e37b479ce2f
largefiles: replace readstandin() by readasstandin()
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31734
diff
changeset
|
559 hash = readasstandin(wctx[standin]) |
18300
745bc16ccef2
largefiles: fix update from a merge with removed files
Mads Kiilerich <madski@unity3d.com>
parents:
18299
diff
changeset
|
560 except IOError: |
745bc16ccef2
largefiles: fix update from a merge with removed files
Mads Kiilerich <madski@unity3d.com>
parents:
18299
diff
changeset
|
561 hash = None |
745bc16ccef2
largefiles: fix update from a merge with removed files
Mads Kiilerich <madski@unity3d.com>
parents:
18299
diff
changeset
|
562 standins.append((lfile, hash)) |
16120
47ee41fcf42b
largefiles: optimize update speed by only updating changed largefiles
Na'Tosha Bard <natosha@unity3d.com>
parents:
16103
diff
changeset
|
563 return standins |
16245
a18ad914aa21
largefiles: move calculation of largefiles for updating to utility function
Na'Tosha Bard <natosha@unity3d.com>
parents:
16166
diff
changeset
|
564 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
565 |
22095
cb62d77c7a01
largefiles: factor out synchronization of lfdirstate for future use
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21917
diff
changeset
|
566 def synclfdirstate(repo, lfdirstate, lfile, normallookup): |
cb62d77c7a01
largefiles: factor out synchronization of lfdirstate for future use
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21917
diff
changeset
|
567 lfstandin = standin(lfile) |
47699
034979d24c7b
largefile: rearrange conditionnal in `synclfdirstate`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47656
diff
changeset
|
568 if lfstandin not in repo.dirstate: |
47749
068e09499d4e
largefile: use `update_file` instead of `drop` in `synclfdirstate`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47725
diff
changeset
|
569 lfdirstate.update_file(lfile, p1_tracked=False, wc_tracked=False) |
47699
034979d24c7b
largefile: rearrange conditionnal in `synclfdirstate`
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47656
diff
changeset
|
570 else: |
48144
6f54afb094bd
dirstate: align the dirstate's API to the lower level ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48106
diff
changeset
|
571 entry = repo.dirstate.get_entry(lfstandin) |
6f54afb094bd
dirstate: align the dirstate's API to the lower level ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48106
diff
changeset
|
572 lfdirstate.update_file( |
6f54afb094bd
dirstate: align the dirstate's API to the lower level ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48106
diff
changeset
|
573 lfile, |
6f54afb094bd
dirstate: align the dirstate's API to the lower level ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48106
diff
changeset
|
574 wc_tracked=entry.tracked, |
6f54afb094bd
dirstate: align the dirstate's API to the lower level ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48106
diff
changeset
|
575 p1_tracked=entry.p1_tracked, |
6f54afb094bd
dirstate: align the dirstate's API to the lower level ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48106
diff
changeset
|
576 p2_info=entry.p2_info, |
6f54afb094bd
dirstate: align the dirstate's API to the lower level ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48106
diff
changeset
|
577 possibly_dirty=True, |
6f54afb094bd
dirstate: align the dirstate's API to the lower level ones
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48106
diff
changeset
|
578 ) |
22095
cb62d77c7a01
largefiles: factor out synchronization of lfdirstate for future use
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
21917
diff
changeset
|
579 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
580 |
23184
3100d1cbce32
largefiles: factor out procedures to update lfdirstate for post-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23039
diff
changeset
|
581 def markcommitted(orig, ctx, node): |
24336
c9f4ef967a1d
largefiles: replace 'ctx._repo' with 'ctx.repo()'
Matt Harbison <matt_harbison@yahoo.com>
parents:
24158
diff
changeset
|
582 repo = ctx.repo() |
23184
3100d1cbce32
largefiles: factor out procedures to update lfdirstate for post-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23039
diff
changeset
|
583 |
47656
b1b6d0cad455
largefile: use `parentchange` markcommitted
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47647
diff
changeset
|
584 lfdirstate = openlfdirstate(repo.ui, repo) |
b1b6d0cad455
largefile: use `parentchange` markcommitted
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47647
diff
changeset
|
585 with lfdirstate.parentchange(): |
47647
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
586 orig(node) |
23184
3100d1cbce32
largefiles: factor out procedures to update lfdirstate for post-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23039
diff
changeset
|
587 |
47647
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
588 # ATTENTION: "ctx.files()" may differ from "repo[node].files()" |
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
589 # because files coming from the 2nd parent are omitted in the latter. |
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
590 # |
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
591 # The former should be used to get targets of "synclfdirstate", |
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
592 # because such files: |
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
593 # - are marked as "a" by "patch.patch()" (e.g. via transplant), and |
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
594 # - have to be marked as "n" after commit, but |
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
595 # - aren't listed in "repo[node].files()" |
23273
236c978bceca
largefiles: avoid redundant "updatelfiles" invocation in "overridetransplant"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23188
diff
changeset
|
596 |
47647
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
597 for f in ctx.files(): |
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
598 lfile = splitstandin(f) |
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
599 if lfile is not None: |
f16958beb27b
largefile: synchronise the dirstate within a `parentchange` context
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47599
diff
changeset
|
600 synclfdirstate(repo, lfdirstate, lfile, False) |
48168
df3021c1f093
largefiles: pass current transaction to `lfdirstate.write()`
Pulkit Goyal <7895pulkit@gmail.com>
parents:
48144
diff
changeset
|
601 lfdirstate.write(repo.currenttransaction()) |
23184
3100d1cbce32
largefiles: factor out procedures to update lfdirstate for post-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23039
diff
changeset
|
602 |
23276
4be754832829
largefiles: move "copyalltostore" invocation into "markcommitted"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23274
diff
changeset
|
603 # As part of committing, copy all of the largefiles into the cache. |
31616
10561eb97c7f
largefiles: call readstandin() with changectx itself instead of rev or node
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31615
diff
changeset
|
604 # |
10561eb97c7f
largefiles: call readstandin() with changectx itself instead of rev or node
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31615
diff
changeset
|
605 # Using "node" instead of "ctx" implies additional "repo[node]" |
10561eb97c7f
largefiles: call readstandin() with changectx itself instead of rev or node
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31615
diff
changeset
|
606 # lookup while copyalltostore(), but can omit redundant check for |
10561eb97c7f
largefiles: call readstandin() with changectx itself instead of rev or node
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31615
diff
changeset
|
607 # files comming from the 2nd parent, which should exist in store |
10561eb97c7f
largefiles: call readstandin() with changectx itself instead of rev or node
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31615
diff
changeset
|
608 # at merging. |
23276
4be754832829
largefiles: move "copyalltostore" invocation into "markcommitted"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23274
diff
changeset
|
609 copyalltostore(repo, node) |
4be754832829
largefiles: move "copyalltostore" invocation into "markcommitted"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23274
diff
changeset
|
610 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
611 |
16245
a18ad914aa21
largefiles: move calculation of largefiles for updating to utility function
Na'Tosha Bard <natosha@unity3d.com>
parents:
16166
diff
changeset
|
612 def getlfilestoupdate(oldstandins, newstandins): |
a18ad914aa21
largefiles: move calculation of largefiles for updating to utility function
Na'Tosha Bard <natosha@unity3d.com>
parents:
16166
diff
changeset
|
613 changedstandins = set(oldstandins).symmetric_difference(set(newstandins)) |
a18ad914aa21
largefiles: move calculation of largefiles for updating to utility function
Na'Tosha Bard <natosha@unity3d.com>
parents:
16166
diff
changeset
|
614 filelist = [] |
a18ad914aa21
largefiles: move calculation of largefiles for updating to utility function
Na'Tosha Bard <natosha@unity3d.com>
parents:
16166
diff
changeset
|
615 for f in changedstandins: |
a18ad914aa21
largefiles: move calculation of largefiles for updating to utility function
Na'Tosha Bard <natosha@unity3d.com>
parents:
16166
diff
changeset
|
616 if f[0] not in filelist: |
a18ad914aa21
largefiles: move calculation of largefiles for updating to utility function
Na'Tosha Bard <natosha@unity3d.com>
parents:
16166
diff
changeset
|
617 filelist.append(f[0]) |
a18ad914aa21
largefiles: move calculation of largefiles for updating to utility function
Na'Tosha Bard <natosha@unity3d.com>
parents:
16166
diff
changeset
|
618 return filelist |
21042
32b3331f18eb
largefiles: centralize the logic to get outgoing largefiles
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19089
diff
changeset
|
619 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
620 |
21042
32b3331f18eb
largefiles: centralize the logic to get outgoing largefiles
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
19089
diff
changeset
|
621 def getlfilestoupload(repo, missing, addfunc): |
39390
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
622 makeprogress = repo.ui.makeprogress |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
623 with makeprogress( |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
624 _(b'finding outgoing largefiles'), |
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
625 unit=_(b'revisions'), |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
626 total=len(missing), |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
627 ) as progress: |
39390
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
628 for i, n in enumerate(missing): |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
629 progress.update(i) |
47012
d55b71393907
node: replace nullid and friends with nodeconstants class
Joerg Sonnenberger <joerg@bec.de>
parents:
46895
diff
changeset
|
630 parents = [p for p in repo[n].parents() if p != repo.nullid] |
23657
95f238cafb32
largefiles: ensure that the standin files are available in getlfilestoupload()
Matt Harbison <matt_harbison@yahoo.com>
parents:
23543
diff
changeset
|
631 |
43584
a02e4c12ae60
largefiles: allow "lfstatus" context manager to set value to False
Martin von Zweigbergk <martinvonz@google.com>
parents:
43583
diff
changeset
|
632 with lfstatus(repo, value=False): |
39390
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
633 ctx = repo[n] |
23657
95f238cafb32
largefiles: ensure that the standin files are available in getlfilestoupload()
Matt Harbison <matt_harbison@yahoo.com>
parents:
23543
diff
changeset
|
634 |
39390
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
635 files = set(ctx.files()) |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
636 if len(parents) == 2: |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
637 mc = ctx.manifest() |
41397
0bd56c291359
cleanup: use p1() and p2() instead of parents()[0] and parents()[1]
Martin von Zweigbergk <martinvonz@google.com>
parents:
39390
diff
changeset
|
638 mp1 = ctx.p1().manifest() |
0bd56c291359
cleanup: use p1() and p2() instead of parents()[0] and parents()[1]
Martin von Zweigbergk <martinvonz@google.com>
parents:
39390
diff
changeset
|
639 mp2 = ctx.p2().manifest() |
39390
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
640 for f in mp1: |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
641 if f not in mc: |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
642 files.add(f) |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
643 for f in mp2: |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
644 if f not in mc: |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
645 files.add(f) |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
646 for f in mc: |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
647 if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None): |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
648 files.add(f) |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
649 for fn in files: |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
650 if isstandin(fn) and fn in ctx: |
a65ad9b22a00
largefiles: use a context manager to control the progress bar lifetime
Matt Harbison <matt_harbison@yahoo.com>
parents:
38407
diff
changeset
|
651 addfunc(fn, readasstandin(ctx[fn])) |
23185
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
652 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
653 |
23185
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
654 def updatestandinsbymatch(repo, match): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
655 """Update standins in the working directory according to specified match |
23185
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
656 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
657 This returns (possibly modified) ``match`` object to be used for |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
658 subsequent commit process. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
659 """ |
23185
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
660 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
661 ui = repo.ui |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
662 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
663 # Case 1: user calls commit with no specific files or |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
664 # include/exclude patterns: refresh and commit all files that |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
665 # are "dirty". |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
666 if match is None or match.always(): |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
667 # Spend a bit of time here to get a list of files we know |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
668 # are modified so we can compare only against those. |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
669 # It can cost a lot of time (several seconds) |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
670 # otherwise to update all standins if the largefiles are |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
671 # large. |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
672 lfdirstate = openlfdirstate(ui, repo) |
41676
0531dff73d0b
match: delete unused root and cwd arguments from {always,never,exact}() (API)
Martin von Zweigbergk <martinvonz@google.com>
parents:
41397
diff
changeset
|
673 dirtymatch = matchmod.always() |
48390
322525db4c98
status: use filesystem time boundary to invalidate racy mtime
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
48382
diff
changeset
|
674 unsure, s, mtime_boundary = lfdirstate.status( |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
675 dirtymatch, subrepos=[], ignored=False, clean=False, unknown=False |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
676 ) |
23185
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
677 modifiedfiles = unsure + s.modified + s.added + s.removed |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
678 lfiles = listlfiles(repo) |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
679 # this only loops through largefiles that exist (not |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
680 # removed/renamed) |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
681 for lfile in lfiles: |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
682 if lfile in modifiedfiles: |
31618
8228bc8fed8c
largefiles: avoid redundant standin() invocations
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31617
diff
changeset
|
683 fstandin = standin(lfile) |
8228bc8fed8c
largefiles: avoid redundant standin() invocations
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31617
diff
changeset
|
684 if repo.wvfs.exists(fstandin): |
23185
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
685 # this handles the case where a rebase is being |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
686 # performed and the working copy is not updated |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
687 # yet. |
28560
bfbd3f02b442
largefiles: replace invocation of os.path module by vfs in lfutil.py
liscju <piotr.listkiewicz@gmail.com>
parents:
28464
diff
changeset
|
688 if repo.wvfs.exists(lfile): |
31659
0eec36112e58
largefiles: add lfile argument to updatestandin() for efficiency (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31657
diff
changeset
|
689 updatestandin(repo, lfile, fstandin) |
23185
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
690 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
691 return match |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
692 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
693 lfiles = listlfiles(repo) |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
694 match._files = repo._subdirlfs(match.files(), lfiles) |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
695 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
696 # Case 2: user calls commit with specified patterns: refresh |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
697 # any matching big files. |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
698 smatcher = composestandinmatcher(repo, match) |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
699 standins = repo.dirstate.walk( |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
700 smatcher, subrepos=[], unknown=False, ignored=False |
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
701 ) |
23185
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
702 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
703 # No matching big files: get out of the way and pass control to |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
704 # the usual commit() method. |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
705 if not standins: |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
706 return match |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
707 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
708 # Refresh all matching big files. It's possible that the |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
709 # commit will end up failing, in which case the big files will |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
710 # stay refreshed. No harm done: the user modified them and |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
711 # asked to commit them, so sooner or later we're going to |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
712 # refresh the standins. Might as well leave them refreshed. |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
713 lfdirstate = openlfdirstate(ui, repo) |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
714 for fstandin in standins: |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
715 lfile = splitstandin(fstandin) |
48106
82e142b9ad18
dirstate-item: use item's property instead of `state` in largefile
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47755
diff
changeset
|
716 if lfdirstate.get_entry(lfile).tracked: |
31659
0eec36112e58
largefiles: add lfile argument to updatestandin() for efficiency (API)
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
31657
diff
changeset
|
717 updatestandin(repo, lfile, fstandin) |
23185
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
718 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
719 # Cook up a new matcher that only matches regular files or |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
720 # standins corresponding to the big files requested by the |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
721 # user. Have to modify _files to prevent commit() from |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
722 # complaining "not tracked" for big files. |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
723 match = copy.copy(match) |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
724 origmatchfn = match.matchfn |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
725 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
726 # Check both the list of largefiles and the list of |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
727 # standins because if a largefile was removed, it |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
728 # won't be in the list of largefiles at this point |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
729 match._files += sorted(standins) |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
730 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
731 actualfiles = [] |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
732 for f in match._files: |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
733 fstandin = standin(f) |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
734 |
26817
b68797f244e4
largefiles: fix explicit commit of normal/largefile switch
Mads Kiilerich <madski@unity3d.com>
parents:
26749
diff
changeset
|
735 # For largefiles, only one of the normal and standin should be |
27942
eb1135d5e688
largefiles: fix an explicit largefile commit after a remove (issue4969)
Matt Harbison <matt_harbison@yahoo.com>
parents:
27903
diff
changeset
|
736 # committed (except if one of them is a remove). In the case of a |
eb1135d5e688
largefiles: fix an explicit largefile commit after a remove (issue4969)
Matt Harbison <matt_harbison@yahoo.com>
parents:
27903
diff
changeset
|
737 # standin removal, drop the normal file if it is unknown to dirstate. |
26817
b68797f244e4
largefiles: fix explicit commit of normal/largefile switch
Mads Kiilerich <madski@unity3d.com>
parents:
26749
diff
changeset
|
738 # Thus, skip plain largefile names but keep the standin. |
27942
eb1135d5e688
largefiles: fix an explicit largefile commit after a remove (issue4969)
Matt Harbison <matt_harbison@yahoo.com>
parents:
27903
diff
changeset
|
739 if f in lfiles or fstandin in standins: |
48106
82e142b9ad18
dirstate-item: use item's property instead of `state` in largefile
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47755
diff
changeset
|
740 if not repo.dirstate.get_entry(fstandin).removed: |
82e142b9ad18
dirstate-item: use item's property instead of `state` in largefile
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47755
diff
changeset
|
741 if not repo.dirstate.get_entry(f).removed: |
27942
eb1135d5e688
largefiles: fix an explicit largefile commit after a remove (issue4969)
Matt Harbison <matt_harbison@yahoo.com>
parents:
27903
diff
changeset
|
742 continue |
48106
82e142b9ad18
dirstate-item: use item's property instead of `state` in largefile
Pierre-Yves David <pierre-yves.david@octobus.net>
parents:
47755
diff
changeset
|
743 elif not repo.dirstate.get_entry(f).any_tracked: |
27942
eb1135d5e688
largefiles: fix an explicit largefile commit after a remove (issue4969)
Matt Harbison <matt_harbison@yahoo.com>
parents:
27903
diff
changeset
|
744 continue |
23185
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
745 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
746 actualfiles.append(f) |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
747 match._files = actualfiles |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
748 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
749 def matchfn(f): |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
750 if origmatchfn(f): |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
751 return f not in lfiles |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
752 else: |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
753 return f in standins |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
754 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
755 match.matchfn = matchfn |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
756 |
9870173e0b48
largefiles: factor out procedures to update standins for pre-committing
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23184
diff
changeset
|
757 return match |
23187
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
758 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
759 |
23187
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
760 class automatedcommithook(object): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
761 """Stateful hook to update standins at the 1st commit of resuming |
23187
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
762 |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
763 For efficiency, updating standins in the working directory should |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
764 be avoided while automated committing (like rebase, transplant and |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
765 so on), because they should be updated before committing. |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
766 |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
767 But the 1st commit of resuming automated committing (e.g. ``rebase |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
768 --continue``) should update them, because largefiles may be |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
769 modified manually. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
770 """ |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
771 |
23187
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
772 def __init__(self, resuming): |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
773 self.resuming = resuming |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
774 |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
775 def __call__(self, repo, match): |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
776 if self.resuming: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
777 self.resuming = False # avoids updating at subsequent commits |
23187
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
778 return updatestandinsbymatch(repo, match) |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
779 else: |
f726b05ecfe6
largefiles: update standins only at the 1st commit of "hg rebase --continue"
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23185
diff
changeset
|
780 return match |
23188
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
781 |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
782 |
23188
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
783 def getstatuswriter(ui, repo, forcibly=None): |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
784 """Return the function to write largefiles specific status out |
23188
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
785 |
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
786 If ``forcibly`` is ``None``, this returns the last element of |
23543
4dd8a6a1240d
spelling: fixes from proofreading of spell checker issues
Mads Kiilerich <madski@unity3d.com>
parents:
23276
diff
changeset
|
787 ``repo._lfstatuswriters`` as "default" writer function. |
23188
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
788 |
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
789 Otherwise, this returns the function to always write out (or |
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
790 ignore if ``not forcibly``) status. |
45942
89a2afe31e82
formating: upgrade to black 20.8b1
Augie Fackler <raf@durin42.com>
parents:
44379
diff
changeset
|
791 """ |
43077
687b865b95ad
formatting: byteify all mercurial/ and hgext/ string literals
Augie Fackler <augie@google.com>
parents:
43076
diff
changeset
|
792 if forcibly is None and util.safehasattr(repo, b'_largefilesenabled'): |
23188
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
793 return repo._lfstatuswriters[-1] |
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
794 else: |
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
795 if forcibly: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
796 return ui.status # forcibly WRITE OUT |
23188
94ac64bcf6fe
largefiles: introduce "_lfstatuswriters" to customize status reporting
FUJIWARA Katsunori <foozy@lares.dti.ne.jp>
parents:
23187
diff
changeset
|
797 else: |
43076
2372284d9457
formatting: blacken the codebase
Augie Fackler <augie@google.com>
parents:
41759
diff
changeset
|
798 return lambda *msg, **opts: None # forcibly IGNORE |