Support possible_transports argument.
[jelmer/subvertpy.git] / fileids.py
1 # Copyright (C) 2006-2007 Jelmer Vernooij <jelmer@samba.org>
2
3 # This program is free software; you can redistribute it and/or modify
4 # it under the terms of the GNU General Public License as published by
5 # the Free Software Foundation; either version 2 of the License, or
6 # (at your option) any later version.
7
8 # This program is distributed in the hope that it will be useful,
9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 # GNU General Public License for more details.
12
13 # You should have received a copy of the GNU General Public License
14 # along with this program; if not, write to the Free Software
15 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16 """Generation of file-ids."""
17
18 from bzrlib import osutils, ui
19 from bzrlib.errors import NotBranchError, RevisionNotPresent
20 from bzrlib.knit import KnitVersionedFile
21 from bzrlib.revision import NULL_REVISION
22 from bzrlib.trace import mutter
23
24 import urllib
25
26 import sha
27
28 from revids import escape_svn_path
29
30 def generate_svn_file_id(uuid, revnum, branch, path):
31     """Create a file id identifying a Subversion file.
32
33     :param uuid: UUID of the repository
34     :param revnu: Revision number at which the file was introduced.
35     :param branch: Branch path of the branch in which the file was introduced.
36     :param path: Original path of the file within the branch
37     """
38     ret = "%d@%s:%s:%s" % (revnum, uuid, escape_svn_path(branch), escape_svn_path(path))
39     if len(ret) > 150:
40         ret = "%d@%s:%s;%s" % (revnum, uuid, 
41                             escape_svn_path(branch),
42                             sha.new(path.encode('utf-8')).hexdigest())
43     assert isinstance(ret, str)
44     return osutils.safe_file_id(ret)
45
46
47 def generate_file_id(repos, revid, path):
48     (branch, revnum, _) = repos.lookup_revision_id(revid)
49     return generate_svn_file_id(repos.uuid, revnum, branch, path)
50
51
52 def get_local_changes(paths, scheme, generate_revid, get_children=None):
53     new_paths = {}
54     for p in sorted(paths.keys()):
55         data = paths[p]
56         new_p = scheme.unprefix(p)[1]
57         if data[1] is not None:
58             try:
59                 (cbp, crp) = scheme.unprefix(data[1])
60
61                 # Branch copy
62                 if (crp == "" and new_p == ""):
63                     data = ('M', None, None)
64                 else:
65                     data = (data[0], crp, generate_revid(
66                                   data[2], cbp.encode("utf-8"), str(scheme)))
67             except NotBranchError:
68                 # Copied from outside of a known branch
69                 # Make it look like the files were added in this revision
70                 if get_children is not None:
71                     for c in get_children(data[1], data[2]):
72                         mutter('oops: %r child %r' % (data[1], c))
73                         new_paths[(new_p+"/"+c[len(data[1]):].strip("/")).strip("/")] = (data[0], None, -1)
74                 data = (data[0], None, -1)
75
76         new_paths[new_p] = data
77     return new_paths
78
79
80 FILEIDMAP_VERSION = 1
81
82 class FileIdMap(object):
83     """ File id store. 
84
85     Keeps a map
86
87     revnum -> branch -> path -> fileid
88     """
89     def __init__(self, repos, cache_transport):
90         self.repos = repos
91         self.idmap_knit = KnitVersionedFile("fileidmap-v%d" % FILEIDMAP_VERSION, cache_transport, create=True)
92
93     def save(self, revid, parent_revids, _map):
94         mutter('saving file id map for %r' % revid)
95                 
96         self.idmap_knit.add_lines_with_ghosts(revid, parent_revids, 
97                 ["%s\t%s\t%s\n" % (urllib.quote(filename), urllib.quote(_map[filename][0]), 
98                                         urllib.quote(_map[filename][1])) for filename in sorted(_map.keys())])
99
100     def load(self, revid):
101         map = {}
102         for line in self.idmap_knit.get_lines(revid):
103             (filename, id, create_revid) = line.rstrip("\n").split("\t", 3)
104             map[urllib.unquote(filename)] = (urllib.unquote(id), urllib.unquote(create_revid))
105             assert isinstance(map[urllib.unquote(filename)][0], str)
106
107         return map
108
109     def apply_changes(self, uuid, revnum, branch, global_changes, 
110                       renames, scheme, find_children=None):
111         """Change file id map to incorporate specified changes.
112
113         :param uuid: UUID of repository changes happen in
114         :param revnum: Revno for revision in which changes happened
115         :param branch: Branch path where changes happened
116         :param global_changes: Dict with global changes that happened
117         :param renames: List of renames (known file ids for particular paths)
118         :param scheme: Branching scheme
119         """
120         changes = get_local_changes(global_changes, scheme,
121                     self.repos.generate_revision_id, find_children)
122         if find_children is not None:
123             def get_children(path, revid):
124                 (bp, revnum, scheme) = self.repos.lookup_revision_id(revid)
125                 for p in find_children(bp+"/"+path, revnum):
126                     yield scheme.unprefix(p)[1]
127         else:
128             get_children = None
129
130         revid = self.repos.generate_revision_id(revnum, branch, str(scheme))
131
132         def new_file_id(x):
133             return generate_file_id(self.repos, revid, x)
134          
135         idmap = self._apply_changes(new_file_id, changes, get_children)
136         idmap.update(renames)
137         return idmap
138
139     def get_map(self, uuid, revnum, branch, renames_cb, scheme):
140         """Make sure the map is up to date until revnum."""
141         # First, find the last cached map
142         todo = []
143         next_parent_revs = []
144         if revnum == 0:
145             assert branch == ""
146             return {"": (generate_svn_file_id(uuid, revnum, branch, ""), 
147               self.repos.generate_revision_id(revnum, branch, str(scheme)))}
148
149         # No history -> empty map
150         for (bp, paths, rev) in self.repos.follow_branch_history(branch, 
151                                              revnum, scheme):
152             revid = self.repos.generate_revision_id(rev, bp.encode("utf-8"), 
153                                                     str(scheme))
154             try:
155                 map = self.load(revid)
156                 # found the nearest cached map
157                 next_parent_revs = [revid]
158                 break
159             except RevisionNotPresent:
160                 todo.append((revid, paths))
161    
162         # target revision was present
163         if len(todo) == 0:
164             return map
165
166         if len(next_parent_revs) == 0:
167             if scheme.is_branch(""):
168                 map = {"": (generate_svn_file_id(uuid, 0, "", ""), NULL_REVISION)}
169             else:
170                 map = {}
171
172         pb = ui.ui_factory.nested_progress_bar()
173
174         try:
175             i = 1
176             for (revid, global_changes) in reversed(todo):
177                 expensive = False
178                 def log_find_children(path, revnum):
179                     expensive = True
180                     return self.repos._log.find_children(path, revnum)
181                 changes = get_local_changes(global_changes, scheme,
182                                             self.repos.generate_revision_id, 
183                                             log_find_children)
184                 pb.update('generating file id map', i, len(todo))
185
186                 def find_children(path, revid):
187                     (bp, revnum, scheme) = self.repos.lookup_revision_id(revid)
188                     for p in log_find_children(bp+"/"+path, revnum):
189                         yield scheme.unprefix(p)[1]
190
191                 parent_revs = next_parent_revs
192
193                 def new_file_id(x):
194                     return generate_file_id(self.repos, revid, x)
195                 
196                 revmap = self._apply_changes(new_file_id, changes, find_children)
197                 revmap.update(renames_cb(revid))
198
199                 for p in changes:
200                     if changes[p][0] == 'M' and not revmap.has_key(p):
201                         revmap[p] = map[p][0]
202
203                 map.update(dict([(x, (str(revmap[x]), revid)) for x in revmap]))
204
205                 # Mark all parent paths as changed
206                 for p in revmap:
207                     parts = p.split("/")
208                     for j in range(1, len(parts)+1):
209                         parent = "/".join(parts[0:len(parts)-j])
210                         assert map.has_key(parent), "Parent item %s of %s doesn't exist in map" % (parent, p)
211                         if map[parent][1] == revid:
212                             break
213                         map[parent] = map[parent][0], revid
214                         
215                 saved = False
216                 if i % 500 == 0 or expensive:
217                     self.save(revid, parent_revs, map)
218                     saved = True
219                 next_parent_revs = [revid]
220                 i += 1
221         finally:
222             pb.finished()
223         if not saved:
224             self.save(revid, parent_revs, map)
225         return map
226
227
228 class SimpleFileIdMap(FileIdMap):
229     @staticmethod
230     def _apply_changes(new_file_id, changes, find_children=None):
231         map = {}
232         for p in sorted(changes.keys()):
233             data = changes[p]
234
235             if data[0] in ('A', 'R'):
236                 map[p] = new_file_id(p)
237
238                 if data[1] is not None:
239                     mutter('%r copied from %r:%s' % (p, data[1], data[2]))
240                     if find_children is not None:
241                         for c in find_children(data[1], data[2]):
242                             path = c.replace(data[1], p+"/", 1).replace("//", "/")
243                             map[path] = new_file_id(path)
244                             mutter('added mapping %r -> %r' % (path, map[path]))
245
246         return map