Show More
The requested changes are too big and content was truncated. Show full diff
@@ -1,1746 +1,1749 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 |
|
2 | |||
3 | # Copyright (C) 2014-2018 RhodeCode GmbH |
|
3 | # Copyright (C) 2014-2018 RhodeCode GmbH | |
4 | # |
|
4 | # | |
5 | # This program is free software: you can redistribute it and/or modify |
|
5 | # This program is free software: you can redistribute it and/or modify | |
6 | # it under the terms of the GNU Affero General Public License, version 3 |
|
6 | # it under the terms of the GNU Affero General Public License, version 3 | |
7 | # (only), as published by the Free Software Foundation. |
|
7 | # (only), as published by the Free Software Foundation. | |
8 | # |
|
8 | # | |
9 | # This program is distributed in the hope that it will be useful, |
|
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. |
|
12 | # GNU General Public License for more details. | |
13 | # |
|
13 | # | |
14 | # You should have received a copy of the GNU Affero General Public License |
|
14 | # You should have received a copy of the GNU Affero General Public License | |
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
16 | # |
|
16 | # | |
17 | # This program is dual-licensed. If you wish to learn more about the |
|
17 | # This program is dual-licensed. If you wish to learn more about the | |
18 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
18 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
20 |
|
20 | |||
21 | """ |
|
21 | """ | |
22 | Base module for all VCS systems |
|
22 | Base module for all VCS systems | |
23 | """ |
|
23 | """ | |
24 |
|
24 | |||
25 | import collections |
|
25 | import collections | |
26 | import datetime |
|
26 | import datetime | |
27 | import fnmatch |
|
27 | import fnmatch | |
28 | import itertools |
|
28 | import itertools | |
29 | import logging |
|
29 | import logging | |
30 | import os |
|
30 | import os | |
31 | import re |
|
31 | import re | |
32 | import time |
|
32 | import time | |
33 | import warnings |
|
33 | import warnings | |
34 | import shutil |
|
34 | import shutil | |
35 |
|
35 | |||
36 | from zope.cachedescriptors.property import Lazy as LazyProperty |
|
36 | from zope.cachedescriptors.property import Lazy as LazyProperty | |
37 |
|
37 | |||
38 | from rhodecode.lib.utils2 import safe_str, safe_unicode |
|
38 | from rhodecode.lib.utils2 import safe_str, safe_unicode | |
39 | from rhodecode.lib.vcs import connection |
|
39 | from rhodecode.lib.vcs import connection | |
40 | from rhodecode.lib.vcs.utils import author_name, author_email |
|
40 | from rhodecode.lib.vcs.utils import author_name, author_email | |
41 | from rhodecode.lib.vcs.conf import settings |
|
41 | from rhodecode.lib.vcs.conf import settings | |
42 | from rhodecode.lib.vcs.exceptions import ( |
|
42 | from rhodecode.lib.vcs.exceptions import ( | |
43 | CommitError, EmptyRepositoryError, NodeAlreadyAddedError, |
|
43 | CommitError, EmptyRepositoryError, NodeAlreadyAddedError, | |
44 | NodeAlreadyChangedError, NodeAlreadyExistsError, NodeAlreadyRemovedError, |
|
44 | NodeAlreadyChangedError, NodeAlreadyExistsError, NodeAlreadyRemovedError, | |
45 | NodeDoesNotExistError, NodeNotChangedError, VCSError, |
|
45 | NodeDoesNotExistError, NodeNotChangedError, VCSError, | |
46 | ImproperArchiveTypeError, BranchDoesNotExistError, CommitDoesNotExistError, |
|
46 | ImproperArchiveTypeError, BranchDoesNotExistError, CommitDoesNotExistError, | |
47 | RepositoryError) |
|
47 | RepositoryError) | |
48 |
|
48 | |||
49 |
|
49 | |||
50 | log = logging.getLogger(__name__) |
|
50 | log = logging.getLogger(__name__) | |
51 |
|
51 | |||
52 |
|
52 | |||
53 | FILEMODE_DEFAULT = 0100644 |
|
53 | FILEMODE_DEFAULT = 0100644 | |
54 | FILEMODE_EXECUTABLE = 0100755 |
|
54 | FILEMODE_EXECUTABLE = 0100755 | |
55 |
|
55 | |||
56 | Reference = collections.namedtuple('Reference', ('type', 'name', 'commit_id')) |
|
56 | Reference = collections.namedtuple('Reference', ('type', 'name', 'commit_id')) | |
57 | MergeResponse = collections.namedtuple( |
|
57 | MergeResponse = collections.namedtuple( | |
58 | 'MergeResponse', |
|
58 | 'MergeResponse', | |
59 | ('possible', 'executed', 'merge_ref', 'failure_reason')) |
|
59 | ('possible', 'executed', 'merge_ref', 'failure_reason')) | |
60 |
|
60 | |||
61 |
|
61 | |||
62 | class MergeFailureReason(object): |
|
62 | class MergeFailureReason(object): | |
63 | """ |
|
63 | """ | |
64 | Enumeration with all the reasons why the server side merge could fail. |
|
64 | Enumeration with all the reasons why the server side merge could fail. | |
65 |
|
65 | |||
66 | DO NOT change the number of the reasons, as they may be stored in the |
|
66 | DO NOT change the number of the reasons, as they may be stored in the | |
67 | database. |
|
67 | database. | |
68 |
|
68 | |||
69 | Changing the name of a reason is acceptable and encouraged to deprecate old |
|
69 | Changing the name of a reason is acceptable and encouraged to deprecate old | |
70 | reasons. |
|
70 | reasons. | |
71 | """ |
|
71 | """ | |
72 |
|
72 | |||
73 | # Everything went well. |
|
73 | # Everything went well. | |
74 | NONE = 0 |
|
74 | NONE = 0 | |
75 |
|
75 | |||
76 | # An unexpected exception was raised. Check the logs for more details. |
|
76 | # An unexpected exception was raised. Check the logs for more details. | |
77 | UNKNOWN = 1 |
|
77 | UNKNOWN = 1 | |
78 |
|
78 | |||
79 | # The merge was not successful, there are conflicts. |
|
79 | # The merge was not successful, there are conflicts. | |
80 | MERGE_FAILED = 2 |
|
80 | MERGE_FAILED = 2 | |
81 |
|
81 | |||
82 | # The merge succeeded but we could not push it to the target repository. |
|
82 | # The merge succeeded but we could not push it to the target repository. | |
83 | PUSH_FAILED = 3 |
|
83 | PUSH_FAILED = 3 | |
84 |
|
84 | |||
85 | # The specified target is not a head in the target repository. |
|
85 | # The specified target is not a head in the target repository. | |
86 | TARGET_IS_NOT_HEAD = 4 |
|
86 | TARGET_IS_NOT_HEAD = 4 | |
87 |
|
87 | |||
88 | # The source repository contains more branches than the target. Pushing |
|
88 | # The source repository contains more branches than the target. Pushing | |
89 | # the merge will create additional branches in the target. |
|
89 | # the merge will create additional branches in the target. | |
90 | HG_SOURCE_HAS_MORE_BRANCHES = 5 |
|
90 | HG_SOURCE_HAS_MORE_BRANCHES = 5 | |
91 |
|
91 | |||
92 | # The target reference has multiple heads. That does not allow to correctly |
|
92 | # The target reference has multiple heads. That does not allow to correctly | |
93 | # identify the target location. This could only happen for mercurial |
|
93 | # identify the target location. This could only happen for mercurial | |
94 | # branches. |
|
94 | # branches. | |
95 | HG_TARGET_HAS_MULTIPLE_HEADS = 6 |
|
95 | HG_TARGET_HAS_MULTIPLE_HEADS = 6 | |
96 |
|
96 | |||
97 | # The target repository is locked |
|
97 | # The target repository is locked | |
98 | TARGET_IS_LOCKED = 7 |
|
98 | TARGET_IS_LOCKED = 7 | |
99 |
|
99 | |||
100 | # Deprecated, use MISSING_TARGET_REF or MISSING_SOURCE_REF instead. |
|
100 | # Deprecated, use MISSING_TARGET_REF or MISSING_SOURCE_REF instead. | |
101 | # A involved commit could not be found. |
|
101 | # A involved commit could not be found. | |
102 | _DEPRECATED_MISSING_COMMIT = 8 |
|
102 | _DEPRECATED_MISSING_COMMIT = 8 | |
103 |
|
103 | |||
104 | # The target repo reference is missing. |
|
104 | # The target repo reference is missing. | |
105 | MISSING_TARGET_REF = 9 |
|
105 | MISSING_TARGET_REF = 9 | |
106 |
|
106 | |||
107 | # The source repo reference is missing. |
|
107 | # The source repo reference is missing. | |
108 | MISSING_SOURCE_REF = 10 |
|
108 | MISSING_SOURCE_REF = 10 | |
109 |
|
109 | |||
110 | # The merge was not successful, there are conflicts related to sub |
|
110 | # The merge was not successful, there are conflicts related to sub | |
111 | # repositories. |
|
111 | # repositories. | |
112 | SUBREPO_MERGE_FAILED = 11 |
|
112 | SUBREPO_MERGE_FAILED = 11 | |
113 |
|
113 | |||
114 |
|
114 | |||
115 | class UpdateFailureReason(object): |
|
115 | class UpdateFailureReason(object): | |
116 | """ |
|
116 | """ | |
117 | Enumeration with all the reasons why the pull request update could fail. |
|
117 | Enumeration with all the reasons why the pull request update could fail. | |
118 |
|
118 | |||
119 | DO NOT change the number of the reasons, as they may be stored in the |
|
119 | DO NOT change the number of the reasons, as they may be stored in the | |
120 | database. |
|
120 | database. | |
121 |
|
121 | |||
122 | Changing the name of a reason is acceptable and encouraged to deprecate old |
|
122 | Changing the name of a reason is acceptable and encouraged to deprecate old | |
123 | reasons. |
|
123 | reasons. | |
124 | """ |
|
124 | """ | |
125 |
|
125 | |||
126 | # Everything went well. |
|
126 | # Everything went well. | |
127 | NONE = 0 |
|
127 | NONE = 0 | |
128 |
|
128 | |||
129 | # An unexpected exception was raised. Check the logs for more details. |
|
129 | # An unexpected exception was raised. Check the logs for more details. | |
130 | UNKNOWN = 1 |
|
130 | UNKNOWN = 1 | |
131 |
|
131 | |||
132 | # The pull request is up to date. |
|
132 | # The pull request is up to date. | |
133 | NO_CHANGE = 2 |
|
133 | NO_CHANGE = 2 | |
134 |
|
134 | |||
135 | # The pull request has a reference type that is not supported for update. |
|
135 | # The pull request has a reference type that is not supported for update. | |
136 | WRONG_REF_TYPE = 3 |
|
136 | WRONG_REF_TYPE = 3 | |
137 |
|
137 | |||
138 | # Update failed because the target reference is missing. |
|
138 | # Update failed because the target reference is missing. | |
139 | MISSING_TARGET_REF = 4 |
|
139 | MISSING_TARGET_REF = 4 | |
140 |
|
140 | |||
141 | # Update failed because the source reference is missing. |
|
141 | # Update failed because the source reference is missing. | |
142 | MISSING_SOURCE_REF = 5 |
|
142 | MISSING_SOURCE_REF = 5 | |
143 |
|
143 | |||
144 |
|
144 | |||
145 | class BaseRepository(object): |
|
145 | class BaseRepository(object): | |
146 | """ |
|
146 | """ | |
147 | Base Repository for final backends |
|
147 | Base Repository for final backends | |
148 |
|
148 | |||
149 | .. attribute:: DEFAULT_BRANCH_NAME |
|
149 | .. attribute:: DEFAULT_BRANCH_NAME | |
150 |
|
150 | |||
151 | name of default branch (i.e. "trunk" for svn, "master" for git etc. |
|
151 | name of default branch (i.e. "trunk" for svn, "master" for git etc. | |
152 |
|
152 | |||
153 | .. attribute:: commit_ids |
|
153 | .. attribute:: commit_ids | |
154 |
|
154 | |||
155 | list of all available commit ids, in ascending order |
|
155 | list of all available commit ids, in ascending order | |
156 |
|
156 | |||
157 | .. attribute:: path |
|
157 | .. attribute:: path | |
158 |
|
158 | |||
159 | absolute path to the repository |
|
159 | absolute path to the repository | |
160 |
|
160 | |||
161 | .. attribute:: bookmarks |
|
161 | .. attribute:: bookmarks | |
162 |
|
162 | |||
163 | Mapping from name to :term:`Commit ID` of the bookmark. Empty in case |
|
163 | Mapping from name to :term:`Commit ID` of the bookmark. Empty in case | |
164 | there are no bookmarks or the backend implementation does not support |
|
164 | there are no bookmarks or the backend implementation does not support | |
165 | bookmarks. |
|
165 | bookmarks. | |
166 |
|
166 | |||
167 | .. attribute:: tags |
|
167 | .. attribute:: tags | |
168 |
|
168 | |||
169 | Mapping from name to :term:`Commit ID` of the tag. |
|
169 | Mapping from name to :term:`Commit ID` of the tag. | |
170 |
|
170 | |||
171 | """ |
|
171 | """ | |
172 |
|
172 | |||
173 | DEFAULT_BRANCH_NAME = None |
|
173 | DEFAULT_BRANCH_NAME = None | |
174 | DEFAULT_CONTACT = u"Unknown" |
|
174 | DEFAULT_CONTACT = u"Unknown" | |
175 | DEFAULT_DESCRIPTION = u"unknown" |
|
175 | DEFAULT_DESCRIPTION = u"unknown" | |
176 | EMPTY_COMMIT_ID = '0' * 40 |
|
176 | EMPTY_COMMIT_ID = '0' * 40 | |
177 |
|
177 | |||
178 | path = None |
|
178 | path = None | |
179 | _remote = None |
|
|||
180 |
|
179 | |||
181 | def __init__(self, repo_path, config=None, create=False, **kwargs): |
|
180 | def __init__(self, repo_path, config=None, create=False, **kwargs): | |
182 | """ |
|
181 | """ | |
183 | Initializes repository. Raises RepositoryError if repository could |
|
182 | Initializes repository. Raises RepositoryError if repository could | |
184 | not be find at the given ``repo_path`` or directory at ``repo_path`` |
|
183 | not be find at the given ``repo_path`` or directory at ``repo_path`` | |
185 | exists and ``create`` is set to True. |
|
184 | exists and ``create`` is set to True. | |
186 |
|
185 | |||
187 | :param repo_path: local path of the repository |
|
186 | :param repo_path: local path of the repository | |
188 | :param config: repository configuration |
|
187 | :param config: repository configuration | |
189 | :param create=False: if set to True, would try to create repository. |
|
188 | :param create=False: if set to True, would try to create repository. | |
190 | :param src_url=None: if set, should be proper url from which repository |
|
189 | :param src_url=None: if set, should be proper url from which repository | |
191 | would be cloned; requires ``create`` parameter to be set to True - |
|
190 | would be cloned; requires ``create`` parameter to be set to True - | |
192 | raises RepositoryError if src_url is set and create evaluates to |
|
191 | raises RepositoryError if src_url is set and create evaluates to | |
193 | False |
|
192 | False | |
194 | """ |
|
193 | """ | |
195 | raise NotImplementedError |
|
194 | raise NotImplementedError | |
196 |
|
195 | |||
197 | def __repr__(self): |
|
196 | def __repr__(self): | |
198 | return '<%s at %s>' % (self.__class__.__name__, self.path) |
|
197 | return '<%s at %s>' % (self.__class__.__name__, self.path) | |
199 |
|
198 | |||
200 | def __len__(self): |
|
199 | def __len__(self): | |
201 | return self.count() |
|
200 | return self.count() | |
202 |
|
201 | |||
203 | def __eq__(self, other): |
|
202 | def __eq__(self, other): | |
204 | same_instance = isinstance(other, self.__class__) |
|
203 | same_instance = isinstance(other, self.__class__) | |
205 | return same_instance and other.path == self.path |
|
204 | return same_instance and other.path == self.path | |
206 |
|
205 | |||
207 | def __ne__(self, other): |
|
206 | def __ne__(self, other): | |
208 | return not self.__eq__(other) |
|
207 | return not self.__eq__(other) | |
209 |
|
208 | |||
210 | def get_create_shadow_cache_pr_path(self, db_repo): |
|
209 | def get_create_shadow_cache_pr_path(self, db_repo): | |
211 | path = db_repo.cached_diffs_dir |
|
210 | path = db_repo.cached_diffs_dir | |
212 | if not os.path.exists(path): |
|
211 | if not os.path.exists(path): | |
213 | os.makedirs(path, 0755) |
|
212 | os.makedirs(path, 0755) | |
214 | return path |
|
213 | return path | |
215 |
|
214 | |||
216 | @classmethod |
|
215 | @classmethod | |
217 | def get_default_config(cls, default=None): |
|
216 | def get_default_config(cls, default=None): | |
218 | config = Config() |
|
217 | config = Config() | |
219 | if default and isinstance(default, list): |
|
218 | if default and isinstance(default, list): | |
220 | for section, key, val in default: |
|
219 | for section, key, val in default: | |
221 | config.set(section, key, val) |
|
220 | config.set(section, key, val) | |
222 | return config |
|
221 | return config | |
223 |
|
222 | |||
224 | @LazyProperty |
|
223 | @LazyProperty | |
|
224 | def _remote(self): | |||
|
225 | raise NotImplementedError | |||
|
226 | ||||
|
227 | @LazyProperty | |||
225 | def EMPTY_COMMIT(self): |
|
228 | def EMPTY_COMMIT(self): | |
226 | return EmptyCommit(self.EMPTY_COMMIT_ID) |
|
229 | return EmptyCommit(self.EMPTY_COMMIT_ID) | |
227 |
|
230 | |||
228 | @LazyProperty |
|
231 | @LazyProperty | |
229 | def alias(self): |
|
232 | def alias(self): | |
230 | for k, v in settings.BACKENDS.items(): |
|
233 | for k, v in settings.BACKENDS.items(): | |
231 | if v.split('.')[-1] == str(self.__class__.__name__): |
|
234 | if v.split('.')[-1] == str(self.__class__.__name__): | |
232 | return k |
|
235 | return k | |
233 |
|
236 | |||
234 | @LazyProperty |
|
237 | @LazyProperty | |
235 | def name(self): |
|
238 | def name(self): | |
236 | return safe_unicode(os.path.basename(self.path)) |
|
239 | return safe_unicode(os.path.basename(self.path)) | |
237 |
|
240 | |||
238 | @LazyProperty |
|
241 | @LazyProperty | |
239 | def description(self): |
|
242 | def description(self): | |
240 | raise NotImplementedError |
|
243 | raise NotImplementedError | |
241 |
|
244 | |||
242 | def refs(self): |
|
245 | def refs(self): | |
243 | """ |
|
246 | """ | |
244 | returns a `dict` with branches, bookmarks, tags, and closed_branches |
|
247 | returns a `dict` with branches, bookmarks, tags, and closed_branches | |
245 | for this repository |
|
248 | for this repository | |
246 | """ |
|
249 | """ | |
247 | return dict( |
|
250 | return dict( | |
248 | branches=self.branches, |
|
251 | branches=self.branches, | |
249 | branches_closed=self.branches_closed, |
|
252 | branches_closed=self.branches_closed, | |
250 | tags=self.tags, |
|
253 | tags=self.tags, | |
251 | bookmarks=self.bookmarks |
|
254 | bookmarks=self.bookmarks | |
252 | ) |
|
255 | ) | |
253 |
|
256 | |||
254 | @LazyProperty |
|
257 | @LazyProperty | |
255 | def branches(self): |
|
258 | def branches(self): | |
256 | """ |
|
259 | """ | |
257 | A `dict` which maps branch names to commit ids. |
|
260 | A `dict` which maps branch names to commit ids. | |
258 | """ |
|
261 | """ | |
259 | raise NotImplementedError |
|
262 | raise NotImplementedError | |
260 |
|
263 | |||
261 | @LazyProperty |
|
264 | @LazyProperty | |
262 | def branches_closed(self): |
|
265 | def branches_closed(self): | |
263 | """ |
|
266 | """ | |
264 | A `dict` which maps tags names to commit ids. |
|
267 | A `dict` which maps tags names to commit ids. | |
265 | """ |
|
268 | """ | |
266 | raise NotImplementedError |
|
269 | raise NotImplementedError | |
267 |
|
270 | |||
268 | @LazyProperty |
|
271 | @LazyProperty | |
269 | def bookmarks(self): |
|
272 | def bookmarks(self): | |
270 | """ |
|
273 | """ | |
271 | A `dict` which maps tags names to commit ids. |
|
274 | A `dict` which maps tags names to commit ids. | |
272 | """ |
|
275 | """ | |
273 | raise NotImplementedError |
|
276 | raise NotImplementedError | |
274 |
|
277 | |||
275 | @LazyProperty |
|
278 | @LazyProperty | |
276 | def tags(self): |
|
279 | def tags(self): | |
277 | """ |
|
280 | """ | |
278 | A `dict` which maps tags names to commit ids. |
|
281 | A `dict` which maps tags names to commit ids. | |
279 | """ |
|
282 | """ | |
280 | raise NotImplementedError |
|
283 | raise NotImplementedError | |
281 |
|
284 | |||
282 | @LazyProperty |
|
285 | @LazyProperty | |
283 | def size(self): |
|
286 | def size(self): | |
284 | """ |
|
287 | """ | |
285 | Returns combined size in bytes for all repository files |
|
288 | Returns combined size in bytes for all repository files | |
286 | """ |
|
289 | """ | |
287 | tip = self.get_commit() |
|
290 | tip = self.get_commit() | |
288 | return tip.size |
|
291 | return tip.size | |
289 |
|
292 | |||
290 | def size_at_commit(self, commit_id): |
|
293 | def size_at_commit(self, commit_id): | |
291 | commit = self.get_commit(commit_id) |
|
294 | commit = self.get_commit(commit_id) | |
292 | return commit.size |
|
295 | return commit.size | |
293 |
|
296 | |||
294 | def is_empty(self): |
|
297 | def is_empty(self): | |
295 | return not bool(self.commit_ids) |
|
298 | return not bool(self.commit_ids) | |
296 |
|
299 | |||
297 | @staticmethod |
|
300 | @staticmethod | |
298 | def check_url(url, config): |
|
301 | def check_url(url, config): | |
299 | """ |
|
302 | """ | |
300 | Function will check given url and try to verify if it's a valid |
|
303 | Function will check given url and try to verify if it's a valid | |
301 | link. |
|
304 | link. | |
302 | """ |
|
305 | """ | |
303 | raise NotImplementedError |
|
306 | raise NotImplementedError | |
304 |
|
307 | |||
305 | @staticmethod |
|
308 | @staticmethod | |
306 | def is_valid_repository(path): |
|
309 | def is_valid_repository(path): | |
307 | """ |
|
310 | """ | |
308 | Check if given `path` contains a valid repository of this backend |
|
311 | Check if given `path` contains a valid repository of this backend | |
309 | """ |
|
312 | """ | |
310 | raise NotImplementedError |
|
313 | raise NotImplementedError | |
311 |
|
314 | |||
312 | # ========================================================================== |
|
315 | # ========================================================================== | |
313 | # COMMITS |
|
316 | # COMMITS | |
314 | # ========================================================================== |
|
317 | # ========================================================================== | |
315 |
|
318 | |||
316 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): |
|
319 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): | |
317 | """ |
|
320 | """ | |
318 | Returns instance of `BaseCommit` class. If `commit_id` and `commit_idx` |
|
321 | Returns instance of `BaseCommit` class. If `commit_id` and `commit_idx` | |
319 | are both None, most recent commit is returned. |
|
322 | are both None, most recent commit is returned. | |
320 |
|
323 | |||
321 | :param pre_load: Optional. List of commit attributes to load. |
|
324 | :param pre_load: Optional. List of commit attributes to load. | |
322 |
|
325 | |||
323 | :raises ``EmptyRepositoryError``: if there are no commits |
|
326 | :raises ``EmptyRepositoryError``: if there are no commits | |
324 | """ |
|
327 | """ | |
325 | raise NotImplementedError |
|
328 | raise NotImplementedError | |
326 |
|
329 | |||
327 | def __iter__(self): |
|
330 | def __iter__(self): | |
328 | for commit_id in self.commit_ids: |
|
331 | for commit_id in self.commit_ids: | |
329 | yield self.get_commit(commit_id=commit_id) |
|
332 | yield self.get_commit(commit_id=commit_id) | |
330 |
|
333 | |||
331 | def get_commits( |
|
334 | def get_commits( | |
332 | self, start_id=None, end_id=None, start_date=None, end_date=None, |
|
335 | self, start_id=None, end_id=None, start_date=None, end_date=None, | |
333 | branch_name=None, show_hidden=False, pre_load=None): |
|
336 | branch_name=None, show_hidden=False, pre_load=None): | |
334 | """ |
|
337 | """ | |
335 | Returns iterator of `BaseCommit` objects from start to end |
|
338 | Returns iterator of `BaseCommit` objects from start to end | |
336 | not inclusive. This should behave just like a list, ie. end is not |
|
339 | not inclusive. This should behave just like a list, ie. end is not | |
337 | inclusive. |
|
340 | inclusive. | |
338 |
|
341 | |||
339 | :param start_id: None or str, must be a valid commit id |
|
342 | :param start_id: None or str, must be a valid commit id | |
340 | :param end_id: None or str, must be a valid commit id |
|
343 | :param end_id: None or str, must be a valid commit id | |
341 | :param start_date: |
|
344 | :param start_date: | |
342 | :param end_date: |
|
345 | :param end_date: | |
343 | :param branch_name: |
|
346 | :param branch_name: | |
344 | :param show_hidden: |
|
347 | :param show_hidden: | |
345 | :param pre_load: |
|
348 | :param pre_load: | |
346 | """ |
|
349 | """ | |
347 | raise NotImplementedError |
|
350 | raise NotImplementedError | |
348 |
|
351 | |||
349 | def __getitem__(self, key): |
|
352 | def __getitem__(self, key): | |
350 | """ |
|
353 | """ | |
351 | Allows index based access to the commit objects of this repository. |
|
354 | Allows index based access to the commit objects of this repository. | |
352 | """ |
|
355 | """ | |
353 | pre_load = ["author", "branch", "date", "message", "parents"] |
|
356 | pre_load = ["author", "branch", "date", "message", "parents"] | |
354 | if isinstance(key, slice): |
|
357 | if isinstance(key, slice): | |
355 | return self._get_range(key, pre_load) |
|
358 | return self._get_range(key, pre_load) | |
356 | return self.get_commit(commit_idx=key, pre_load=pre_load) |
|
359 | return self.get_commit(commit_idx=key, pre_load=pre_load) | |
357 |
|
360 | |||
358 | def _get_range(self, slice_obj, pre_load): |
|
361 | def _get_range(self, slice_obj, pre_load): | |
359 | for commit_id in self.commit_ids.__getitem__(slice_obj): |
|
362 | for commit_id in self.commit_ids.__getitem__(slice_obj): | |
360 | yield self.get_commit(commit_id=commit_id, pre_load=pre_load) |
|
363 | yield self.get_commit(commit_id=commit_id, pre_load=pre_load) | |
361 |
|
364 | |||
362 | def count(self): |
|
365 | def count(self): | |
363 | return len(self.commit_ids) |
|
366 | return len(self.commit_ids) | |
364 |
|
367 | |||
365 | def tag(self, name, user, commit_id=None, message=None, date=None, **opts): |
|
368 | def tag(self, name, user, commit_id=None, message=None, date=None, **opts): | |
366 | """ |
|
369 | """ | |
367 | Creates and returns a tag for the given ``commit_id``. |
|
370 | Creates and returns a tag for the given ``commit_id``. | |
368 |
|
371 | |||
369 | :param name: name for new tag |
|
372 | :param name: name for new tag | |
370 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" |
|
373 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" | |
371 | :param commit_id: commit id for which new tag would be created |
|
374 | :param commit_id: commit id for which new tag would be created | |
372 | :param message: message of the tag's commit |
|
375 | :param message: message of the tag's commit | |
373 | :param date: date of tag's commit |
|
376 | :param date: date of tag's commit | |
374 |
|
377 | |||
375 | :raises TagAlreadyExistError: if tag with same name already exists |
|
378 | :raises TagAlreadyExistError: if tag with same name already exists | |
376 | """ |
|
379 | """ | |
377 | raise NotImplementedError |
|
380 | raise NotImplementedError | |
378 |
|
381 | |||
379 | def remove_tag(self, name, user, message=None, date=None): |
|
382 | def remove_tag(self, name, user, message=None, date=None): | |
380 | """ |
|
383 | """ | |
381 | Removes tag with the given ``name``. |
|
384 | Removes tag with the given ``name``. | |
382 |
|
385 | |||
383 | :param name: name of the tag to be removed |
|
386 | :param name: name of the tag to be removed | |
384 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" |
|
387 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" | |
385 | :param message: message of the tag's removal commit |
|
388 | :param message: message of the tag's removal commit | |
386 | :param date: date of tag's removal commit |
|
389 | :param date: date of tag's removal commit | |
387 |
|
390 | |||
388 | :raises TagDoesNotExistError: if tag with given name does not exists |
|
391 | :raises TagDoesNotExistError: if tag with given name does not exists | |
389 | """ |
|
392 | """ | |
390 | raise NotImplementedError |
|
393 | raise NotImplementedError | |
391 |
|
394 | |||
392 | def get_diff( |
|
395 | def get_diff( | |
393 | self, commit1, commit2, path=None, ignore_whitespace=False, |
|
396 | self, commit1, commit2, path=None, ignore_whitespace=False, | |
394 | context=3, path1=None): |
|
397 | context=3, path1=None): | |
395 | """ |
|
398 | """ | |
396 | Returns (git like) *diff*, as plain text. Shows changes introduced by |
|
399 | Returns (git like) *diff*, as plain text. Shows changes introduced by | |
397 | `commit2` since `commit1`. |
|
400 | `commit2` since `commit1`. | |
398 |
|
401 | |||
399 | :param commit1: Entry point from which diff is shown. Can be |
|
402 | :param commit1: Entry point from which diff is shown. Can be | |
400 | ``self.EMPTY_COMMIT`` - in this case, patch showing all |
|
403 | ``self.EMPTY_COMMIT`` - in this case, patch showing all | |
401 | the changes since empty state of the repository until `commit2` |
|
404 | the changes since empty state of the repository until `commit2` | |
402 | :param commit2: Until which commit changes should be shown. |
|
405 | :param commit2: Until which commit changes should be shown. | |
403 | :param path: Can be set to a path of a file to create a diff of that |
|
406 | :param path: Can be set to a path of a file to create a diff of that | |
404 | file. If `path1` is also set, this value is only associated to |
|
407 | file. If `path1` is also set, this value is only associated to | |
405 | `commit2`. |
|
408 | `commit2`. | |
406 | :param ignore_whitespace: If set to ``True``, would not show whitespace |
|
409 | :param ignore_whitespace: If set to ``True``, would not show whitespace | |
407 | changes. Defaults to ``False``. |
|
410 | changes. Defaults to ``False``. | |
408 | :param context: How many lines before/after changed lines should be |
|
411 | :param context: How many lines before/after changed lines should be | |
409 | shown. Defaults to ``3``. |
|
412 | shown. Defaults to ``3``. | |
410 | :param path1: Can be set to a path to associate with `commit1`. This |
|
413 | :param path1: Can be set to a path to associate with `commit1`. This | |
411 | parameter works only for backends which support diff generation for |
|
414 | parameter works only for backends which support diff generation for | |
412 | different paths. Other backends will raise a `ValueError` if `path1` |
|
415 | different paths. Other backends will raise a `ValueError` if `path1` | |
413 | is set and has a different value than `path`. |
|
416 | is set and has a different value than `path`. | |
414 | :param file_path: filter this diff by given path pattern |
|
417 | :param file_path: filter this diff by given path pattern | |
415 | """ |
|
418 | """ | |
416 | raise NotImplementedError |
|
419 | raise NotImplementedError | |
417 |
|
420 | |||
418 | def strip(self, commit_id, branch=None): |
|
421 | def strip(self, commit_id, branch=None): | |
419 | """ |
|
422 | """ | |
420 | Strip given commit_id from the repository |
|
423 | Strip given commit_id from the repository | |
421 | """ |
|
424 | """ | |
422 | raise NotImplementedError |
|
425 | raise NotImplementedError | |
423 |
|
426 | |||
424 | def get_common_ancestor(self, commit_id1, commit_id2, repo2): |
|
427 | def get_common_ancestor(self, commit_id1, commit_id2, repo2): | |
425 | """ |
|
428 | """ | |
426 | Return a latest common ancestor commit if one exists for this repo |
|
429 | Return a latest common ancestor commit if one exists for this repo | |
427 | `commit_id1` vs `commit_id2` from `repo2`. |
|
430 | `commit_id1` vs `commit_id2` from `repo2`. | |
428 |
|
431 | |||
429 | :param commit_id1: Commit it from this repository to use as a |
|
432 | :param commit_id1: Commit it from this repository to use as a | |
430 | target for the comparison. |
|
433 | target for the comparison. | |
431 | :param commit_id2: Source commit id to use for comparison. |
|
434 | :param commit_id2: Source commit id to use for comparison. | |
432 | :param repo2: Source repository to use for comparison. |
|
435 | :param repo2: Source repository to use for comparison. | |
433 | """ |
|
436 | """ | |
434 | raise NotImplementedError |
|
437 | raise NotImplementedError | |
435 |
|
438 | |||
436 | def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None): |
|
439 | def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None): | |
437 | """ |
|
440 | """ | |
438 | Compare this repository's revision `commit_id1` with `commit_id2`. |
|
441 | Compare this repository's revision `commit_id1` with `commit_id2`. | |
439 |
|
442 | |||
440 | Returns a tuple(commits, ancestor) that would be merged from |
|
443 | Returns a tuple(commits, ancestor) that would be merged from | |
441 | `commit_id2`. Doing a normal compare (``merge=False``), ``None`` |
|
444 | `commit_id2`. Doing a normal compare (``merge=False``), ``None`` | |
442 | will be returned as ancestor. |
|
445 | will be returned as ancestor. | |
443 |
|
446 | |||
444 | :param commit_id1: Commit it from this repository to use as a |
|
447 | :param commit_id1: Commit it from this repository to use as a | |
445 | target for the comparison. |
|
448 | target for the comparison. | |
446 | :param commit_id2: Source commit id to use for comparison. |
|
449 | :param commit_id2: Source commit id to use for comparison. | |
447 | :param repo2: Source repository to use for comparison. |
|
450 | :param repo2: Source repository to use for comparison. | |
448 | :param merge: If set to ``True`` will do a merge compare which also |
|
451 | :param merge: If set to ``True`` will do a merge compare which also | |
449 | returns the common ancestor. |
|
452 | returns the common ancestor. | |
450 | :param pre_load: Optional. List of commit attributes to load. |
|
453 | :param pre_load: Optional. List of commit attributes to load. | |
451 | """ |
|
454 | """ | |
452 | raise NotImplementedError |
|
455 | raise NotImplementedError | |
453 |
|
456 | |||
454 | def merge(self, repo_id, workspace_id, target_ref, source_repo, source_ref, |
|
457 | def merge(self, repo_id, workspace_id, target_ref, source_repo, source_ref, | |
455 | user_name='', user_email='', message='', dry_run=False, |
|
458 | user_name='', user_email='', message='', dry_run=False, | |
456 | use_rebase=False, close_branch=False): |
|
459 | use_rebase=False, close_branch=False): | |
457 | """ |
|
460 | """ | |
458 | Merge the revisions specified in `source_ref` from `source_repo` |
|
461 | Merge the revisions specified in `source_ref` from `source_repo` | |
459 | onto the `target_ref` of this repository. |
|
462 | onto the `target_ref` of this repository. | |
460 |
|
463 | |||
461 | `source_ref` and `target_ref` are named tupls with the following |
|
464 | `source_ref` and `target_ref` are named tupls with the following | |
462 | fields `type`, `name` and `commit_id`. |
|
465 | fields `type`, `name` and `commit_id`. | |
463 |
|
466 | |||
464 | Returns a MergeResponse named tuple with the following fields |
|
467 | Returns a MergeResponse named tuple with the following fields | |
465 | 'possible', 'executed', 'source_commit', 'target_commit', |
|
468 | 'possible', 'executed', 'source_commit', 'target_commit', | |
466 | 'merge_commit'. |
|
469 | 'merge_commit'. | |
467 |
|
470 | |||
468 | :param repo_id: `repo_id` target repo id. |
|
471 | :param repo_id: `repo_id` target repo id. | |
469 | :param workspace_id: `workspace_id` unique identifier. |
|
472 | :param workspace_id: `workspace_id` unique identifier. | |
470 | :param target_ref: `target_ref` points to the commit on top of which |
|
473 | :param target_ref: `target_ref` points to the commit on top of which | |
471 | the `source_ref` should be merged. |
|
474 | the `source_ref` should be merged. | |
472 | :param source_repo: The repository that contains the commits to be |
|
475 | :param source_repo: The repository that contains the commits to be | |
473 | merged. |
|
476 | merged. | |
474 | :param source_ref: `source_ref` points to the topmost commit from |
|
477 | :param source_ref: `source_ref` points to the topmost commit from | |
475 | the `source_repo` which should be merged. |
|
478 | the `source_repo` which should be merged. | |
476 | :param user_name: Merge commit `user_name`. |
|
479 | :param user_name: Merge commit `user_name`. | |
477 | :param user_email: Merge commit `user_email`. |
|
480 | :param user_email: Merge commit `user_email`. | |
478 | :param message: Merge commit `message`. |
|
481 | :param message: Merge commit `message`. | |
479 | :param dry_run: If `True` the merge will not take place. |
|
482 | :param dry_run: If `True` the merge will not take place. | |
480 | :param use_rebase: If `True` commits from the source will be rebased |
|
483 | :param use_rebase: If `True` commits from the source will be rebased | |
481 | on top of the target instead of being merged. |
|
484 | on top of the target instead of being merged. | |
482 | :param close_branch: If `True` branch will be close before merging it |
|
485 | :param close_branch: If `True` branch will be close before merging it | |
483 | """ |
|
486 | """ | |
484 | if dry_run: |
|
487 | if dry_run: | |
485 | message = message or 'dry_run_merge_message' |
|
488 | message = message or 'dry_run_merge_message' | |
486 | user_email = user_email or 'dry-run-merge@rhodecode.com' |
|
489 | user_email = user_email or 'dry-run-merge@rhodecode.com' | |
487 | user_name = user_name or 'Dry-Run User' |
|
490 | user_name = user_name or 'Dry-Run User' | |
488 | else: |
|
491 | else: | |
489 | if not user_name: |
|
492 | if not user_name: | |
490 | raise ValueError('user_name cannot be empty') |
|
493 | raise ValueError('user_name cannot be empty') | |
491 | if not user_email: |
|
494 | if not user_email: | |
492 | raise ValueError('user_email cannot be empty') |
|
495 | raise ValueError('user_email cannot be empty') | |
493 | if not message: |
|
496 | if not message: | |
494 | raise ValueError('message cannot be empty') |
|
497 | raise ValueError('message cannot be empty') | |
495 |
|
498 | |||
496 | try: |
|
499 | try: | |
497 | return self._merge_repo( |
|
500 | return self._merge_repo( | |
498 | repo_id, workspace_id, target_ref, source_repo, |
|
501 | repo_id, workspace_id, target_ref, source_repo, | |
499 | source_ref, message, user_name, user_email, dry_run=dry_run, |
|
502 | source_ref, message, user_name, user_email, dry_run=dry_run, | |
500 | use_rebase=use_rebase, close_branch=close_branch) |
|
503 | use_rebase=use_rebase, close_branch=close_branch) | |
501 | except RepositoryError: |
|
504 | except RepositoryError: | |
502 | log.exception( |
|
505 | log.exception( | |
503 | 'Unexpected failure when running merge, dry-run=%s', |
|
506 | 'Unexpected failure when running merge, dry-run=%s', | |
504 | dry_run) |
|
507 | dry_run) | |
505 | return MergeResponse( |
|
508 | return MergeResponse( | |
506 | False, False, None, MergeFailureReason.UNKNOWN) |
|
509 | False, False, None, MergeFailureReason.UNKNOWN) | |
507 |
|
510 | |||
508 | def _merge_repo(self, repo_id, workspace_id, target_ref, |
|
511 | def _merge_repo(self, repo_id, workspace_id, target_ref, | |
509 | source_repo, source_ref, merge_message, |
|
512 | source_repo, source_ref, merge_message, | |
510 | merger_name, merger_email, dry_run=False, |
|
513 | merger_name, merger_email, dry_run=False, | |
511 | use_rebase=False, close_branch=False): |
|
514 | use_rebase=False, close_branch=False): | |
512 | """Internal implementation of merge.""" |
|
515 | """Internal implementation of merge.""" | |
513 | raise NotImplementedError |
|
516 | raise NotImplementedError | |
514 |
|
517 | |||
515 | def _maybe_prepare_merge_workspace( |
|
518 | def _maybe_prepare_merge_workspace( | |
516 | self, repo_id, workspace_id, target_ref, source_ref): |
|
519 | self, repo_id, workspace_id, target_ref, source_ref): | |
517 | """ |
|
520 | """ | |
518 | Create the merge workspace. |
|
521 | Create the merge workspace. | |
519 |
|
522 | |||
520 | :param workspace_id: `workspace_id` unique identifier. |
|
523 | :param workspace_id: `workspace_id` unique identifier. | |
521 | """ |
|
524 | """ | |
522 | raise NotImplementedError |
|
525 | raise NotImplementedError | |
523 |
|
526 | |||
524 | def _get_legacy_shadow_repository_path(self, workspace_id): |
|
527 | def _get_legacy_shadow_repository_path(self, workspace_id): | |
525 | """ |
|
528 | """ | |
526 | Legacy version that was used before. We still need it for |
|
529 | Legacy version that was used before. We still need it for | |
527 | backward compat |
|
530 | backward compat | |
528 | """ |
|
531 | """ | |
529 | return os.path.join( |
|
532 | return os.path.join( | |
530 | os.path.dirname(self.path), |
|
533 | os.path.dirname(self.path), | |
531 | '.__shadow_%s_%s' % (os.path.basename(self.path), workspace_id)) |
|
534 | '.__shadow_%s_%s' % (os.path.basename(self.path), workspace_id)) | |
532 |
|
535 | |||
533 | def _get_shadow_repository_path(self, repo_id, workspace_id): |
|
536 | def _get_shadow_repository_path(self, repo_id, workspace_id): | |
534 | # The name of the shadow repository must start with '.', so it is |
|
537 | # The name of the shadow repository must start with '.', so it is | |
535 | # skipped by 'rhodecode.lib.utils.get_filesystem_repos'. |
|
538 | # skipped by 'rhodecode.lib.utils.get_filesystem_repos'. | |
536 | legacy_repository_path = self._get_legacy_shadow_repository_path(workspace_id) |
|
539 | legacy_repository_path = self._get_legacy_shadow_repository_path(workspace_id) | |
537 | if os.path.exists(legacy_repository_path): |
|
540 | if os.path.exists(legacy_repository_path): | |
538 | return legacy_repository_path |
|
541 | return legacy_repository_path | |
539 | else: |
|
542 | else: | |
540 | return os.path.join( |
|
543 | return os.path.join( | |
541 | os.path.dirname(self.path), |
|
544 | os.path.dirname(self.path), | |
542 | '.__shadow_repo_%s_%s' % (repo_id, workspace_id)) |
|
545 | '.__shadow_repo_%s_%s' % (repo_id, workspace_id)) | |
543 |
|
546 | |||
544 | def cleanup_merge_workspace(self, repo_id, workspace_id): |
|
547 | def cleanup_merge_workspace(self, repo_id, workspace_id): | |
545 | """ |
|
548 | """ | |
546 | Remove merge workspace. |
|
549 | Remove merge workspace. | |
547 |
|
550 | |||
548 | This function MUST not fail in case there is no workspace associated to |
|
551 | This function MUST not fail in case there is no workspace associated to | |
549 | the given `workspace_id`. |
|
552 | the given `workspace_id`. | |
550 |
|
553 | |||
551 | :param workspace_id: `workspace_id` unique identifier. |
|
554 | :param workspace_id: `workspace_id` unique identifier. | |
552 | """ |
|
555 | """ | |
553 | shadow_repository_path = self._get_shadow_repository_path(repo_id, workspace_id) |
|
556 | shadow_repository_path = self._get_shadow_repository_path(repo_id, workspace_id) | |
554 | shadow_repository_path_del = '{}.{}.delete'.format( |
|
557 | shadow_repository_path_del = '{}.{}.delete'.format( | |
555 | shadow_repository_path, time.time()) |
|
558 | shadow_repository_path, time.time()) | |
556 |
|
559 | |||
557 | # move the shadow repo, so it never conflicts with the one used. |
|
560 | # move the shadow repo, so it never conflicts with the one used. | |
558 | # we use this method because shutil.rmtree had some edge case problems |
|
561 | # we use this method because shutil.rmtree had some edge case problems | |
559 | # removing symlinked repositories |
|
562 | # removing symlinked repositories | |
560 | if not os.path.isdir(shadow_repository_path): |
|
563 | if not os.path.isdir(shadow_repository_path): | |
561 | return |
|
564 | return | |
562 |
|
565 | |||
563 | shutil.move(shadow_repository_path, shadow_repository_path_del) |
|
566 | shutil.move(shadow_repository_path, shadow_repository_path_del) | |
564 | try: |
|
567 | try: | |
565 | shutil.rmtree(shadow_repository_path_del, ignore_errors=False) |
|
568 | shutil.rmtree(shadow_repository_path_del, ignore_errors=False) | |
566 | except Exception: |
|
569 | except Exception: | |
567 | log.exception('Failed to gracefully remove shadow repo under %s', |
|
570 | log.exception('Failed to gracefully remove shadow repo under %s', | |
568 | shadow_repository_path_del) |
|
571 | shadow_repository_path_del) | |
569 | shutil.rmtree(shadow_repository_path_del, ignore_errors=True) |
|
572 | shutil.rmtree(shadow_repository_path_del, ignore_errors=True) | |
570 |
|
573 | |||
571 | # ========== # |
|
574 | # ========== # | |
572 | # COMMIT API # |
|
575 | # COMMIT API # | |
573 | # ========== # |
|
576 | # ========== # | |
574 |
|
577 | |||
575 | @LazyProperty |
|
578 | @LazyProperty | |
576 | def in_memory_commit(self): |
|
579 | def in_memory_commit(self): | |
577 | """ |
|
580 | """ | |
578 | Returns :class:`InMemoryCommit` object for this repository. |
|
581 | Returns :class:`InMemoryCommit` object for this repository. | |
579 | """ |
|
582 | """ | |
580 | raise NotImplementedError |
|
583 | raise NotImplementedError | |
581 |
|
584 | |||
582 | # ======================== # |
|
585 | # ======================== # | |
583 | # UTILITIES FOR SUBCLASSES # |
|
586 | # UTILITIES FOR SUBCLASSES # | |
584 | # ======================== # |
|
587 | # ======================== # | |
585 |
|
588 | |||
586 | def _validate_diff_commits(self, commit1, commit2): |
|
589 | def _validate_diff_commits(self, commit1, commit2): | |
587 | """ |
|
590 | """ | |
588 | Validates that the given commits are related to this repository. |
|
591 | Validates that the given commits are related to this repository. | |
589 |
|
592 | |||
590 | Intended as a utility for sub classes to have a consistent validation |
|
593 | Intended as a utility for sub classes to have a consistent validation | |
591 | of input parameters in methods like :meth:`get_diff`. |
|
594 | of input parameters in methods like :meth:`get_diff`. | |
592 | """ |
|
595 | """ | |
593 | self._validate_commit(commit1) |
|
596 | self._validate_commit(commit1) | |
594 | self._validate_commit(commit2) |
|
597 | self._validate_commit(commit2) | |
595 | if (isinstance(commit1, EmptyCommit) and |
|
598 | if (isinstance(commit1, EmptyCommit) and | |
596 | isinstance(commit2, EmptyCommit)): |
|
599 | isinstance(commit2, EmptyCommit)): | |
597 | raise ValueError("Cannot compare two empty commits") |
|
600 | raise ValueError("Cannot compare two empty commits") | |
598 |
|
601 | |||
599 | def _validate_commit(self, commit): |
|
602 | def _validate_commit(self, commit): | |
600 | if not isinstance(commit, BaseCommit): |
|
603 | if not isinstance(commit, BaseCommit): | |
601 | raise TypeError( |
|
604 | raise TypeError( | |
602 | "%s is not of type BaseCommit" % repr(commit)) |
|
605 | "%s is not of type BaseCommit" % repr(commit)) | |
603 | if commit.repository != self and not isinstance(commit, EmptyCommit): |
|
606 | if commit.repository != self and not isinstance(commit, EmptyCommit): | |
604 | raise ValueError( |
|
607 | raise ValueError( | |
605 | "Commit %s must be a valid commit from this repository %s, " |
|
608 | "Commit %s must be a valid commit from this repository %s, " | |
606 | "related to this repository instead %s." % |
|
609 | "related to this repository instead %s." % | |
607 | (commit, self, commit.repository)) |
|
610 | (commit, self, commit.repository)) | |
608 |
|
611 | |||
609 | def _validate_commit_id(self, commit_id): |
|
612 | def _validate_commit_id(self, commit_id): | |
610 | if not isinstance(commit_id, basestring): |
|
613 | if not isinstance(commit_id, basestring): | |
611 | raise TypeError("commit_id must be a string value") |
|
614 | raise TypeError("commit_id must be a string value") | |
612 |
|
615 | |||
613 | def _validate_commit_idx(self, commit_idx): |
|
616 | def _validate_commit_idx(self, commit_idx): | |
614 | if not isinstance(commit_idx, (int, long)): |
|
617 | if not isinstance(commit_idx, (int, long)): | |
615 | raise TypeError("commit_idx must be a numeric value") |
|
618 | raise TypeError("commit_idx must be a numeric value") | |
616 |
|
619 | |||
617 | def _validate_branch_name(self, branch_name): |
|
620 | def _validate_branch_name(self, branch_name): | |
618 | if branch_name and branch_name not in self.branches_all: |
|
621 | if branch_name and branch_name not in self.branches_all: | |
619 | msg = ("Branch %s not found in %s" % (branch_name, self)) |
|
622 | msg = ("Branch %s not found in %s" % (branch_name, self)) | |
620 | raise BranchDoesNotExistError(msg) |
|
623 | raise BranchDoesNotExistError(msg) | |
621 |
|
624 | |||
622 | # |
|
625 | # | |
623 | # Supporting deprecated API parts |
|
626 | # Supporting deprecated API parts | |
624 | # TODO: johbo: consider to move this into a mixin |
|
627 | # TODO: johbo: consider to move this into a mixin | |
625 | # |
|
628 | # | |
626 |
|
629 | |||
627 | @property |
|
630 | @property | |
628 | def EMPTY_CHANGESET(self): |
|
631 | def EMPTY_CHANGESET(self): | |
629 | warnings.warn( |
|
632 | warnings.warn( | |
630 | "Use EMPTY_COMMIT or EMPTY_COMMIT_ID instead", DeprecationWarning) |
|
633 | "Use EMPTY_COMMIT or EMPTY_COMMIT_ID instead", DeprecationWarning) | |
631 | return self.EMPTY_COMMIT_ID |
|
634 | return self.EMPTY_COMMIT_ID | |
632 |
|
635 | |||
633 | @property |
|
636 | @property | |
634 | def revisions(self): |
|
637 | def revisions(self): | |
635 | warnings.warn("Use commits attribute instead", DeprecationWarning) |
|
638 | warnings.warn("Use commits attribute instead", DeprecationWarning) | |
636 | return self.commit_ids |
|
639 | return self.commit_ids | |
637 |
|
640 | |||
638 | @revisions.setter |
|
641 | @revisions.setter | |
639 | def revisions(self, value): |
|
642 | def revisions(self, value): | |
640 | warnings.warn("Use commits attribute instead", DeprecationWarning) |
|
643 | warnings.warn("Use commits attribute instead", DeprecationWarning) | |
641 | self.commit_ids = value |
|
644 | self.commit_ids = value | |
642 |
|
645 | |||
643 | def get_changeset(self, revision=None, pre_load=None): |
|
646 | def get_changeset(self, revision=None, pre_load=None): | |
644 | warnings.warn("Use get_commit instead", DeprecationWarning) |
|
647 | warnings.warn("Use get_commit instead", DeprecationWarning) | |
645 | commit_id = None |
|
648 | commit_id = None | |
646 | commit_idx = None |
|
649 | commit_idx = None | |
647 | if isinstance(revision, basestring): |
|
650 | if isinstance(revision, basestring): | |
648 | commit_id = revision |
|
651 | commit_id = revision | |
649 | else: |
|
652 | else: | |
650 | commit_idx = revision |
|
653 | commit_idx = revision | |
651 | return self.get_commit( |
|
654 | return self.get_commit( | |
652 | commit_id=commit_id, commit_idx=commit_idx, pre_load=pre_load) |
|
655 | commit_id=commit_id, commit_idx=commit_idx, pre_load=pre_load) | |
653 |
|
656 | |||
654 | def get_changesets( |
|
657 | def get_changesets( | |
655 | self, start=None, end=None, start_date=None, end_date=None, |
|
658 | self, start=None, end=None, start_date=None, end_date=None, | |
656 | branch_name=None, pre_load=None): |
|
659 | branch_name=None, pre_load=None): | |
657 | warnings.warn("Use get_commits instead", DeprecationWarning) |
|
660 | warnings.warn("Use get_commits instead", DeprecationWarning) | |
658 | start_id = self._revision_to_commit(start) |
|
661 | start_id = self._revision_to_commit(start) | |
659 | end_id = self._revision_to_commit(end) |
|
662 | end_id = self._revision_to_commit(end) | |
660 | return self.get_commits( |
|
663 | return self.get_commits( | |
661 | start_id=start_id, end_id=end_id, start_date=start_date, |
|
664 | start_id=start_id, end_id=end_id, start_date=start_date, | |
662 | end_date=end_date, branch_name=branch_name, pre_load=pre_load) |
|
665 | end_date=end_date, branch_name=branch_name, pre_load=pre_load) | |
663 |
|
666 | |||
664 | def _revision_to_commit(self, revision): |
|
667 | def _revision_to_commit(self, revision): | |
665 | """ |
|
668 | """ | |
666 | Translates a revision to a commit_id |
|
669 | Translates a revision to a commit_id | |
667 |
|
670 | |||
668 | Helps to support the old changeset based API which allows to use |
|
671 | Helps to support the old changeset based API which allows to use | |
669 | commit ids and commit indices interchangeable. |
|
672 | commit ids and commit indices interchangeable. | |
670 | """ |
|
673 | """ | |
671 | if revision is None: |
|
674 | if revision is None: | |
672 | return revision |
|
675 | return revision | |
673 |
|
676 | |||
674 | if isinstance(revision, basestring): |
|
677 | if isinstance(revision, basestring): | |
675 | commit_id = revision |
|
678 | commit_id = revision | |
676 | else: |
|
679 | else: | |
677 | commit_id = self.commit_ids[revision] |
|
680 | commit_id = self.commit_ids[revision] | |
678 | return commit_id |
|
681 | return commit_id | |
679 |
|
682 | |||
680 | @property |
|
683 | @property | |
681 | def in_memory_changeset(self): |
|
684 | def in_memory_changeset(self): | |
682 | warnings.warn("Use in_memory_commit instead", DeprecationWarning) |
|
685 | warnings.warn("Use in_memory_commit instead", DeprecationWarning) | |
683 | return self.in_memory_commit |
|
686 | return self.in_memory_commit | |
684 |
|
687 | |||
685 | def get_path_permissions(self, username): |
|
688 | def get_path_permissions(self, username): | |
686 | """ |
|
689 | """ | |
687 | Returns a path permission checker or None if not supported |
|
690 | Returns a path permission checker or None if not supported | |
688 |
|
691 | |||
689 | :param username: session user name |
|
692 | :param username: session user name | |
690 | :return: an instance of BasePathPermissionChecker or None |
|
693 | :return: an instance of BasePathPermissionChecker or None | |
691 | """ |
|
694 | """ | |
692 | return None |
|
695 | return None | |
693 |
|
696 | |||
694 | def install_hooks(self, force=False): |
|
697 | def install_hooks(self, force=False): | |
695 | return self._remote.install_hooks(force) |
|
698 | return self._remote.install_hooks(force) | |
696 |
|
699 | |||
697 |
|
700 | |||
698 | class BaseCommit(object): |
|
701 | class BaseCommit(object): | |
699 | """ |
|
702 | """ | |
700 | Each backend should implement it's commit representation. |
|
703 | Each backend should implement it's commit representation. | |
701 |
|
704 | |||
702 | **Attributes** |
|
705 | **Attributes** | |
703 |
|
706 | |||
704 | ``repository`` |
|
707 | ``repository`` | |
705 | repository object within which commit exists |
|
708 | repository object within which commit exists | |
706 |
|
709 | |||
707 | ``id`` |
|
710 | ``id`` | |
708 | The commit id, may be ``raw_id`` or i.e. for mercurial's tip |
|
711 | The commit id, may be ``raw_id`` or i.e. for mercurial's tip | |
709 | just ``tip``. |
|
712 | just ``tip``. | |
710 |
|
713 | |||
711 | ``raw_id`` |
|
714 | ``raw_id`` | |
712 | raw commit representation (i.e. full 40 length sha for git |
|
715 | raw commit representation (i.e. full 40 length sha for git | |
713 | backend) |
|
716 | backend) | |
714 |
|
717 | |||
715 | ``short_id`` |
|
718 | ``short_id`` | |
716 | shortened (if apply) version of ``raw_id``; it would be simple |
|
719 | shortened (if apply) version of ``raw_id``; it would be simple | |
717 | shortcut for ``raw_id[:12]`` for git/mercurial backends or same |
|
720 | shortcut for ``raw_id[:12]`` for git/mercurial backends or same | |
718 | as ``raw_id`` for subversion |
|
721 | as ``raw_id`` for subversion | |
719 |
|
722 | |||
720 | ``idx`` |
|
723 | ``idx`` | |
721 | commit index |
|
724 | commit index | |
722 |
|
725 | |||
723 | ``files`` |
|
726 | ``files`` | |
724 | list of ``FileNode`` (``Node`` with NodeKind.FILE) objects |
|
727 | list of ``FileNode`` (``Node`` with NodeKind.FILE) objects | |
725 |
|
728 | |||
726 | ``dirs`` |
|
729 | ``dirs`` | |
727 | list of ``DirNode`` (``Node`` with NodeKind.DIR) objects |
|
730 | list of ``DirNode`` (``Node`` with NodeKind.DIR) objects | |
728 |
|
731 | |||
729 | ``nodes`` |
|
732 | ``nodes`` | |
730 | combined list of ``Node`` objects |
|
733 | combined list of ``Node`` objects | |
731 |
|
734 | |||
732 | ``author`` |
|
735 | ``author`` | |
733 | author of the commit, as unicode |
|
736 | author of the commit, as unicode | |
734 |
|
737 | |||
735 | ``message`` |
|
738 | ``message`` | |
736 | message of the commit, as unicode |
|
739 | message of the commit, as unicode | |
737 |
|
740 | |||
738 | ``parents`` |
|
741 | ``parents`` | |
739 | list of parent commits |
|
742 | list of parent commits | |
740 |
|
743 | |||
741 | """ |
|
744 | """ | |
742 |
|
745 | |||
743 | branch = None |
|
746 | branch = None | |
744 | """ |
|
747 | """ | |
745 | Depending on the backend this should be set to the branch name of the |
|
748 | Depending on the backend this should be set to the branch name of the | |
746 | commit. Backends not supporting branches on commits should leave this |
|
749 | commit. Backends not supporting branches on commits should leave this | |
747 | value as ``None``. |
|
750 | value as ``None``. | |
748 | """ |
|
751 | """ | |
749 |
|
752 | |||
750 | _ARCHIVE_PREFIX_TEMPLATE = b'{repo_name}-{short_id}' |
|
753 | _ARCHIVE_PREFIX_TEMPLATE = b'{repo_name}-{short_id}' | |
751 | """ |
|
754 | """ | |
752 | This template is used to generate a default prefix for repository archives |
|
755 | This template is used to generate a default prefix for repository archives | |
753 | if no prefix has been specified. |
|
756 | if no prefix has been specified. | |
754 | """ |
|
757 | """ | |
755 |
|
758 | |||
756 | def __str__(self): |
|
759 | def __str__(self): | |
757 | return '<%s at %s:%s>' % ( |
|
760 | return '<%s at %s:%s>' % ( | |
758 | self.__class__.__name__, self.idx, self.short_id) |
|
761 | self.__class__.__name__, self.idx, self.short_id) | |
759 |
|
762 | |||
760 | def __repr__(self): |
|
763 | def __repr__(self): | |
761 | return self.__str__() |
|
764 | return self.__str__() | |
762 |
|
765 | |||
763 | def __unicode__(self): |
|
766 | def __unicode__(self): | |
764 | return u'%s:%s' % (self.idx, self.short_id) |
|
767 | return u'%s:%s' % (self.idx, self.short_id) | |
765 |
|
768 | |||
766 | def __eq__(self, other): |
|
769 | def __eq__(self, other): | |
767 | same_instance = isinstance(other, self.__class__) |
|
770 | same_instance = isinstance(other, self.__class__) | |
768 | return same_instance and self.raw_id == other.raw_id |
|
771 | return same_instance and self.raw_id == other.raw_id | |
769 |
|
772 | |||
770 | def __json__(self): |
|
773 | def __json__(self): | |
771 | parents = [] |
|
774 | parents = [] | |
772 | try: |
|
775 | try: | |
773 | for parent in self.parents: |
|
776 | for parent in self.parents: | |
774 | parents.append({'raw_id': parent.raw_id}) |
|
777 | parents.append({'raw_id': parent.raw_id}) | |
775 | except NotImplementedError: |
|
778 | except NotImplementedError: | |
776 | # empty commit doesn't have parents implemented |
|
779 | # empty commit doesn't have parents implemented | |
777 | pass |
|
780 | pass | |
778 |
|
781 | |||
779 | return { |
|
782 | return { | |
780 | 'short_id': self.short_id, |
|
783 | 'short_id': self.short_id, | |
781 | 'raw_id': self.raw_id, |
|
784 | 'raw_id': self.raw_id, | |
782 | 'revision': self.idx, |
|
785 | 'revision': self.idx, | |
783 | 'message': self.message, |
|
786 | 'message': self.message, | |
784 | 'date': self.date, |
|
787 | 'date': self.date, | |
785 | 'author': self.author, |
|
788 | 'author': self.author, | |
786 | 'parents': parents, |
|
789 | 'parents': parents, | |
787 | 'branch': self.branch |
|
790 | 'branch': self.branch | |
788 | } |
|
791 | } | |
789 |
|
792 | |||
790 | def __getstate__(self): |
|
793 | def __getstate__(self): | |
791 | d = self.__dict__.copy() |
|
794 | d = self.__dict__.copy() | |
792 | d.pop('_remote', None) |
|
795 | d.pop('_remote', None) | |
793 | d.pop('repository', None) |
|
796 | d.pop('repository', None) | |
794 | return d |
|
797 | return d | |
795 |
|
798 | |||
796 | def _get_refs(self): |
|
799 | def _get_refs(self): | |
797 | return { |
|
800 | return { | |
798 | 'branches': [self.branch] if self.branch else [], |
|
801 | 'branches': [self.branch] if self.branch else [], | |
799 | 'bookmarks': getattr(self, 'bookmarks', []), |
|
802 | 'bookmarks': getattr(self, 'bookmarks', []), | |
800 | 'tags': self.tags |
|
803 | 'tags': self.tags | |
801 | } |
|
804 | } | |
802 |
|
805 | |||
803 | @LazyProperty |
|
806 | @LazyProperty | |
804 | def last(self): |
|
807 | def last(self): | |
805 | """ |
|
808 | """ | |
806 | ``True`` if this is last commit in repository, ``False`` |
|
809 | ``True`` if this is last commit in repository, ``False`` | |
807 | otherwise; trying to access this attribute while there is no |
|
810 | otherwise; trying to access this attribute while there is no | |
808 | commits would raise `EmptyRepositoryError` |
|
811 | commits would raise `EmptyRepositoryError` | |
809 | """ |
|
812 | """ | |
810 | if self.repository is None: |
|
813 | if self.repository is None: | |
811 | raise CommitError("Cannot check if it's most recent commit") |
|
814 | raise CommitError("Cannot check if it's most recent commit") | |
812 | return self.raw_id == self.repository.commit_ids[-1] |
|
815 | return self.raw_id == self.repository.commit_ids[-1] | |
813 |
|
816 | |||
814 | @LazyProperty |
|
817 | @LazyProperty | |
815 | def parents(self): |
|
818 | def parents(self): | |
816 | """ |
|
819 | """ | |
817 | Returns list of parent commits. |
|
820 | Returns list of parent commits. | |
818 | """ |
|
821 | """ | |
819 | raise NotImplementedError |
|
822 | raise NotImplementedError | |
820 |
|
823 | |||
821 | @property |
|
824 | @property | |
822 | def merge(self): |
|
825 | def merge(self): | |
823 | """ |
|
826 | """ | |
824 | Returns boolean if commit is a merge. |
|
827 | Returns boolean if commit is a merge. | |
825 | """ |
|
828 | """ | |
826 | return len(self.parents) > 1 |
|
829 | return len(self.parents) > 1 | |
827 |
|
830 | |||
828 | @LazyProperty |
|
831 | @LazyProperty | |
829 | def children(self): |
|
832 | def children(self): | |
830 | """ |
|
833 | """ | |
831 | Returns list of child commits. |
|
834 | Returns list of child commits. | |
832 | """ |
|
835 | """ | |
833 | raise NotImplementedError |
|
836 | raise NotImplementedError | |
834 |
|
837 | |||
835 | @LazyProperty |
|
838 | @LazyProperty | |
836 | def id(self): |
|
839 | def id(self): | |
837 | """ |
|
840 | """ | |
838 | Returns string identifying this commit. |
|
841 | Returns string identifying this commit. | |
839 | """ |
|
842 | """ | |
840 | raise NotImplementedError |
|
843 | raise NotImplementedError | |
841 |
|
844 | |||
842 | @LazyProperty |
|
845 | @LazyProperty | |
843 | def raw_id(self): |
|
846 | def raw_id(self): | |
844 | """ |
|
847 | """ | |
845 | Returns raw string identifying this commit. |
|
848 | Returns raw string identifying this commit. | |
846 | """ |
|
849 | """ | |
847 | raise NotImplementedError |
|
850 | raise NotImplementedError | |
848 |
|
851 | |||
849 | @LazyProperty |
|
852 | @LazyProperty | |
850 | def short_id(self): |
|
853 | def short_id(self): | |
851 | """ |
|
854 | """ | |
852 | Returns shortened version of ``raw_id`` attribute, as string, |
|
855 | Returns shortened version of ``raw_id`` attribute, as string, | |
853 | identifying this commit, useful for presentation to users. |
|
856 | identifying this commit, useful for presentation to users. | |
854 | """ |
|
857 | """ | |
855 | raise NotImplementedError |
|
858 | raise NotImplementedError | |
856 |
|
859 | |||
857 | @LazyProperty |
|
860 | @LazyProperty | |
858 | def idx(self): |
|
861 | def idx(self): | |
859 | """ |
|
862 | """ | |
860 | Returns integer identifying this commit. |
|
863 | Returns integer identifying this commit. | |
861 | """ |
|
864 | """ | |
862 | raise NotImplementedError |
|
865 | raise NotImplementedError | |
863 |
|
866 | |||
864 | @LazyProperty |
|
867 | @LazyProperty | |
865 | def committer(self): |
|
868 | def committer(self): | |
866 | """ |
|
869 | """ | |
867 | Returns committer for this commit |
|
870 | Returns committer for this commit | |
868 | """ |
|
871 | """ | |
869 | raise NotImplementedError |
|
872 | raise NotImplementedError | |
870 |
|
873 | |||
871 | @LazyProperty |
|
874 | @LazyProperty | |
872 | def committer_name(self): |
|
875 | def committer_name(self): | |
873 | """ |
|
876 | """ | |
874 | Returns committer name for this commit |
|
877 | Returns committer name for this commit | |
875 | """ |
|
878 | """ | |
876 |
|
879 | |||
877 | return author_name(self.committer) |
|
880 | return author_name(self.committer) | |
878 |
|
881 | |||
879 | @LazyProperty |
|
882 | @LazyProperty | |
880 | def committer_email(self): |
|
883 | def committer_email(self): | |
881 | """ |
|
884 | """ | |
882 | Returns committer email address for this commit |
|
885 | Returns committer email address for this commit | |
883 | """ |
|
886 | """ | |
884 |
|
887 | |||
885 | return author_email(self.committer) |
|
888 | return author_email(self.committer) | |
886 |
|
889 | |||
887 | @LazyProperty |
|
890 | @LazyProperty | |
888 | def author(self): |
|
891 | def author(self): | |
889 | """ |
|
892 | """ | |
890 | Returns author for this commit |
|
893 | Returns author for this commit | |
891 | """ |
|
894 | """ | |
892 |
|
895 | |||
893 | raise NotImplementedError |
|
896 | raise NotImplementedError | |
894 |
|
897 | |||
895 | @LazyProperty |
|
898 | @LazyProperty | |
896 | def author_name(self): |
|
899 | def author_name(self): | |
897 | """ |
|
900 | """ | |
898 | Returns author name for this commit |
|
901 | Returns author name for this commit | |
899 | """ |
|
902 | """ | |
900 |
|
903 | |||
901 | return author_name(self.author) |
|
904 | return author_name(self.author) | |
902 |
|
905 | |||
903 | @LazyProperty |
|
906 | @LazyProperty | |
904 | def author_email(self): |
|
907 | def author_email(self): | |
905 | """ |
|
908 | """ | |
906 | Returns author email address for this commit |
|
909 | Returns author email address for this commit | |
907 | """ |
|
910 | """ | |
908 |
|
911 | |||
909 | return author_email(self.author) |
|
912 | return author_email(self.author) | |
910 |
|
913 | |||
911 | def get_file_mode(self, path): |
|
914 | def get_file_mode(self, path): | |
912 | """ |
|
915 | """ | |
913 | Returns stat mode of the file at `path`. |
|
916 | Returns stat mode of the file at `path`. | |
914 | """ |
|
917 | """ | |
915 | raise NotImplementedError |
|
918 | raise NotImplementedError | |
916 |
|
919 | |||
917 | def is_link(self, path): |
|
920 | def is_link(self, path): | |
918 | """ |
|
921 | """ | |
919 | Returns ``True`` if given `path` is a symlink |
|
922 | Returns ``True`` if given `path` is a symlink | |
920 | """ |
|
923 | """ | |
921 | raise NotImplementedError |
|
924 | raise NotImplementedError | |
922 |
|
925 | |||
923 | def get_file_content(self, path): |
|
926 | def get_file_content(self, path): | |
924 | """ |
|
927 | """ | |
925 | Returns content of the file at the given `path`. |
|
928 | Returns content of the file at the given `path`. | |
926 | """ |
|
929 | """ | |
927 | raise NotImplementedError |
|
930 | raise NotImplementedError | |
928 |
|
931 | |||
929 | def get_file_size(self, path): |
|
932 | def get_file_size(self, path): | |
930 | """ |
|
933 | """ | |
931 | Returns size of the file at the given `path`. |
|
934 | Returns size of the file at the given `path`. | |
932 | """ |
|
935 | """ | |
933 | raise NotImplementedError |
|
936 | raise NotImplementedError | |
934 |
|
937 | |||
935 | def get_file_commit(self, path, pre_load=None): |
|
938 | def get_file_commit(self, path, pre_load=None): | |
936 | """ |
|
939 | """ | |
937 | Returns last commit of the file at the given `path`. |
|
940 | Returns last commit of the file at the given `path`. | |
938 |
|
941 | |||
939 | :param pre_load: Optional. List of commit attributes to load. |
|
942 | :param pre_load: Optional. List of commit attributes to load. | |
940 | """ |
|
943 | """ | |
941 | commits = self.get_file_history(path, limit=1, pre_load=pre_load) |
|
944 | commits = self.get_file_history(path, limit=1, pre_load=pre_load) | |
942 | if not commits: |
|
945 | if not commits: | |
943 | raise RepositoryError( |
|
946 | raise RepositoryError( | |
944 | 'Failed to fetch history for path {}. ' |
|
947 | 'Failed to fetch history for path {}. ' | |
945 | 'Please check if such path exists in your repository'.format( |
|
948 | 'Please check if such path exists in your repository'.format( | |
946 | path)) |
|
949 | path)) | |
947 | return commits[0] |
|
950 | return commits[0] | |
948 |
|
951 | |||
949 | def get_file_history(self, path, limit=None, pre_load=None): |
|
952 | def get_file_history(self, path, limit=None, pre_load=None): | |
950 | """ |
|
953 | """ | |
951 | Returns history of file as reversed list of :class:`BaseCommit` |
|
954 | Returns history of file as reversed list of :class:`BaseCommit` | |
952 | objects for which file at given `path` has been modified. |
|
955 | objects for which file at given `path` has been modified. | |
953 |
|
956 | |||
954 | :param limit: Optional. Allows to limit the size of the returned |
|
957 | :param limit: Optional. Allows to limit the size of the returned | |
955 | history. This is intended as a hint to the underlying backend, so |
|
958 | history. This is intended as a hint to the underlying backend, so | |
956 | that it can apply optimizations depending on the limit. |
|
959 | that it can apply optimizations depending on the limit. | |
957 | :param pre_load: Optional. List of commit attributes to load. |
|
960 | :param pre_load: Optional. List of commit attributes to load. | |
958 | """ |
|
961 | """ | |
959 | raise NotImplementedError |
|
962 | raise NotImplementedError | |
960 |
|
963 | |||
961 | def get_file_annotate(self, path, pre_load=None): |
|
964 | def get_file_annotate(self, path, pre_load=None): | |
962 | """ |
|
965 | """ | |
963 | Returns a generator of four element tuples with |
|
966 | Returns a generator of four element tuples with | |
964 | lineno, sha, commit lazy loader and line |
|
967 | lineno, sha, commit lazy loader and line | |
965 |
|
968 | |||
966 | :param pre_load: Optional. List of commit attributes to load. |
|
969 | :param pre_load: Optional. List of commit attributes to load. | |
967 | """ |
|
970 | """ | |
968 | raise NotImplementedError |
|
971 | raise NotImplementedError | |
969 |
|
972 | |||
970 | def get_nodes(self, path): |
|
973 | def get_nodes(self, path): | |
971 | """ |
|
974 | """ | |
972 | Returns combined ``DirNode`` and ``FileNode`` objects list representing |
|
975 | Returns combined ``DirNode`` and ``FileNode`` objects list representing | |
973 | state of commit at the given ``path``. |
|
976 | state of commit at the given ``path``. | |
974 |
|
977 | |||
975 | :raises ``CommitError``: if node at the given ``path`` is not |
|
978 | :raises ``CommitError``: if node at the given ``path`` is not | |
976 | instance of ``DirNode`` |
|
979 | instance of ``DirNode`` | |
977 | """ |
|
980 | """ | |
978 | raise NotImplementedError |
|
981 | raise NotImplementedError | |
979 |
|
982 | |||
980 | def get_node(self, path): |
|
983 | def get_node(self, path): | |
981 | """ |
|
984 | """ | |
982 | Returns ``Node`` object from the given ``path``. |
|
985 | Returns ``Node`` object from the given ``path``. | |
983 |
|
986 | |||
984 | :raises ``NodeDoesNotExistError``: if there is no node at the given |
|
987 | :raises ``NodeDoesNotExistError``: if there is no node at the given | |
985 | ``path`` |
|
988 | ``path`` | |
986 | """ |
|
989 | """ | |
987 | raise NotImplementedError |
|
990 | raise NotImplementedError | |
988 |
|
991 | |||
989 | def get_largefile_node(self, path): |
|
992 | def get_largefile_node(self, path): | |
990 | """ |
|
993 | """ | |
991 | Returns the path to largefile from Mercurial/Git-lfs storage. |
|
994 | Returns the path to largefile from Mercurial/Git-lfs storage. | |
992 | or None if it's not a largefile node |
|
995 | or None if it's not a largefile node | |
993 | """ |
|
996 | """ | |
994 | return None |
|
997 | return None | |
995 |
|
998 | |||
996 | def archive_repo(self, file_path, kind='tgz', subrepos=None, |
|
999 | def archive_repo(self, file_path, kind='tgz', subrepos=None, | |
997 | prefix=None, write_metadata=False, mtime=None): |
|
1000 | prefix=None, write_metadata=False, mtime=None): | |
998 | """ |
|
1001 | """ | |
999 | Creates an archive containing the contents of the repository. |
|
1002 | Creates an archive containing the contents of the repository. | |
1000 |
|
1003 | |||
1001 | :param file_path: path to the file which to create the archive. |
|
1004 | :param file_path: path to the file which to create the archive. | |
1002 | :param kind: one of following: ``"tbz2"``, ``"tgz"``, ``"zip"``. |
|
1005 | :param kind: one of following: ``"tbz2"``, ``"tgz"``, ``"zip"``. | |
1003 | :param prefix: name of root directory in archive. |
|
1006 | :param prefix: name of root directory in archive. | |
1004 | Default is repository name and commit's short_id joined with dash: |
|
1007 | Default is repository name and commit's short_id joined with dash: | |
1005 | ``"{repo_name}-{short_id}"``. |
|
1008 | ``"{repo_name}-{short_id}"``. | |
1006 | :param write_metadata: write a metadata file into archive. |
|
1009 | :param write_metadata: write a metadata file into archive. | |
1007 | :param mtime: custom modification time for archive creation, defaults |
|
1010 | :param mtime: custom modification time for archive creation, defaults | |
1008 | to time.time() if not given. |
|
1011 | to time.time() if not given. | |
1009 |
|
1012 | |||
1010 | :raise VCSError: If prefix has a problem. |
|
1013 | :raise VCSError: If prefix has a problem. | |
1011 | """ |
|
1014 | """ | |
1012 | allowed_kinds = settings.ARCHIVE_SPECS.keys() |
|
1015 | allowed_kinds = settings.ARCHIVE_SPECS.keys() | |
1013 | if kind not in allowed_kinds: |
|
1016 | if kind not in allowed_kinds: | |
1014 | raise ImproperArchiveTypeError( |
|
1017 | raise ImproperArchiveTypeError( | |
1015 | 'Archive kind (%s) not supported use one of %s' % |
|
1018 | 'Archive kind (%s) not supported use one of %s' % | |
1016 | (kind, allowed_kinds)) |
|
1019 | (kind, allowed_kinds)) | |
1017 |
|
1020 | |||
1018 | prefix = self._validate_archive_prefix(prefix) |
|
1021 | prefix = self._validate_archive_prefix(prefix) | |
1019 |
|
1022 | |||
1020 | mtime = mtime or time.mktime(self.date.timetuple()) |
|
1023 | mtime = mtime or time.mktime(self.date.timetuple()) | |
1021 |
|
1024 | |||
1022 | file_info = [] |
|
1025 | file_info = [] | |
1023 | cur_rev = self.repository.get_commit(commit_id=self.raw_id) |
|
1026 | cur_rev = self.repository.get_commit(commit_id=self.raw_id) | |
1024 | for _r, _d, files in cur_rev.walk('/'): |
|
1027 | for _r, _d, files in cur_rev.walk('/'): | |
1025 | for f in files: |
|
1028 | for f in files: | |
1026 | f_path = os.path.join(prefix, f.path) |
|
1029 | f_path = os.path.join(prefix, f.path) | |
1027 | file_info.append( |
|
1030 | file_info.append( | |
1028 | (f_path, f.mode, f.is_link(), f.raw_bytes)) |
|
1031 | (f_path, f.mode, f.is_link(), f.raw_bytes)) | |
1029 |
|
1032 | |||
1030 | if write_metadata: |
|
1033 | if write_metadata: | |
1031 | metadata = [ |
|
1034 | metadata = [ | |
1032 | ('repo_name', self.repository.name), |
|
1035 | ('repo_name', self.repository.name), | |
1033 | ('rev', self.raw_id), |
|
1036 | ('rev', self.raw_id), | |
1034 | ('create_time', mtime), |
|
1037 | ('create_time', mtime), | |
1035 | ('branch', self.branch), |
|
1038 | ('branch', self.branch), | |
1036 | ('tags', ','.join(self.tags)), |
|
1039 | ('tags', ','.join(self.tags)), | |
1037 | ] |
|
1040 | ] | |
1038 | meta = ["%s:%s" % (f_name, value) for f_name, value in metadata] |
|
1041 | meta = ["%s:%s" % (f_name, value) for f_name, value in metadata] | |
1039 | file_info.append(('.archival.txt', 0644, False, '\n'.join(meta))) |
|
1042 | file_info.append(('.archival.txt', 0644, False, '\n'.join(meta))) | |
1040 |
|
1043 | |||
1041 | connection.Hg.archive_repo(file_path, mtime, file_info, kind) |
|
1044 | connection.Hg.archive_repo(file_path, mtime, file_info, kind) | |
1042 |
|
1045 | |||
1043 | def _validate_archive_prefix(self, prefix): |
|
1046 | def _validate_archive_prefix(self, prefix): | |
1044 | if prefix is None: |
|
1047 | if prefix is None: | |
1045 | prefix = self._ARCHIVE_PREFIX_TEMPLATE.format( |
|
1048 | prefix = self._ARCHIVE_PREFIX_TEMPLATE.format( | |
1046 | repo_name=safe_str(self.repository.name), |
|
1049 | repo_name=safe_str(self.repository.name), | |
1047 | short_id=self.short_id) |
|
1050 | short_id=self.short_id) | |
1048 | elif not isinstance(prefix, str): |
|
1051 | elif not isinstance(prefix, str): | |
1049 | raise ValueError("prefix not a bytes object: %s" % repr(prefix)) |
|
1052 | raise ValueError("prefix not a bytes object: %s" % repr(prefix)) | |
1050 | elif prefix.startswith('/'): |
|
1053 | elif prefix.startswith('/'): | |
1051 | raise VCSError("Prefix cannot start with leading slash") |
|
1054 | raise VCSError("Prefix cannot start with leading slash") | |
1052 | elif prefix.strip() == '': |
|
1055 | elif prefix.strip() == '': | |
1053 | raise VCSError("Prefix cannot be empty") |
|
1056 | raise VCSError("Prefix cannot be empty") | |
1054 | return prefix |
|
1057 | return prefix | |
1055 |
|
1058 | |||
1056 | @LazyProperty |
|
1059 | @LazyProperty | |
1057 | def root(self): |
|
1060 | def root(self): | |
1058 | """ |
|
1061 | """ | |
1059 | Returns ``RootNode`` object for this commit. |
|
1062 | Returns ``RootNode`` object for this commit. | |
1060 | """ |
|
1063 | """ | |
1061 | return self.get_node('') |
|
1064 | return self.get_node('') | |
1062 |
|
1065 | |||
1063 | def next(self, branch=None): |
|
1066 | def next(self, branch=None): | |
1064 | """ |
|
1067 | """ | |
1065 | Returns next commit from current, if branch is gives it will return |
|
1068 | Returns next commit from current, if branch is gives it will return | |
1066 | next commit belonging to this branch |
|
1069 | next commit belonging to this branch | |
1067 |
|
1070 | |||
1068 | :param branch: show commits within the given named branch |
|
1071 | :param branch: show commits within the given named branch | |
1069 | """ |
|
1072 | """ | |
1070 | indexes = xrange(self.idx + 1, self.repository.count()) |
|
1073 | indexes = xrange(self.idx + 1, self.repository.count()) | |
1071 | return self._find_next(indexes, branch) |
|
1074 | return self._find_next(indexes, branch) | |
1072 |
|
1075 | |||
1073 | def prev(self, branch=None): |
|
1076 | def prev(self, branch=None): | |
1074 | """ |
|
1077 | """ | |
1075 | Returns previous commit from current, if branch is gives it will |
|
1078 | Returns previous commit from current, if branch is gives it will | |
1076 | return previous commit belonging to this branch |
|
1079 | return previous commit belonging to this branch | |
1077 |
|
1080 | |||
1078 | :param branch: show commit within the given named branch |
|
1081 | :param branch: show commit within the given named branch | |
1079 | """ |
|
1082 | """ | |
1080 | indexes = xrange(self.idx - 1, -1, -1) |
|
1083 | indexes = xrange(self.idx - 1, -1, -1) | |
1081 | return self._find_next(indexes, branch) |
|
1084 | return self._find_next(indexes, branch) | |
1082 |
|
1085 | |||
1083 | def _find_next(self, indexes, branch=None): |
|
1086 | def _find_next(self, indexes, branch=None): | |
1084 | if branch and self.branch != branch: |
|
1087 | if branch and self.branch != branch: | |
1085 | raise VCSError('Branch option used on commit not belonging ' |
|
1088 | raise VCSError('Branch option used on commit not belonging ' | |
1086 | 'to that branch') |
|
1089 | 'to that branch') | |
1087 |
|
1090 | |||
1088 | for next_idx in indexes: |
|
1091 | for next_idx in indexes: | |
1089 | commit = self.repository.get_commit(commit_idx=next_idx) |
|
1092 | commit = self.repository.get_commit(commit_idx=next_idx) | |
1090 | if branch and branch != commit.branch: |
|
1093 | if branch and branch != commit.branch: | |
1091 | continue |
|
1094 | continue | |
1092 | return commit |
|
1095 | return commit | |
1093 | raise CommitDoesNotExistError |
|
1096 | raise CommitDoesNotExistError | |
1094 |
|
1097 | |||
1095 | def diff(self, ignore_whitespace=True, context=3): |
|
1098 | def diff(self, ignore_whitespace=True, context=3): | |
1096 | """ |
|
1099 | """ | |
1097 | Returns a `Diff` object representing the change made by this commit. |
|
1100 | Returns a `Diff` object representing the change made by this commit. | |
1098 | """ |
|
1101 | """ | |
1099 | parent = ( |
|
1102 | parent = ( | |
1100 | self.parents[0] if self.parents else self.repository.EMPTY_COMMIT) |
|
1103 | self.parents[0] if self.parents else self.repository.EMPTY_COMMIT) | |
1101 | diff = self.repository.get_diff( |
|
1104 | diff = self.repository.get_diff( | |
1102 | parent, self, |
|
1105 | parent, self, | |
1103 | ignore_whitespace=ignore_whitespace, |
|
1106 | ignore_whitespace=ignore_whitespace, | |
1104 | context=context) |
|
1107 | context=context) | |
1105 | return diff |
|
1108 | return diff | |
1106 |
|
1109 | |||
1107 | @LazyProperty |
|
1110 | @LazyProperty | |
1108 | def added(self): |
|
1111 | def added(self): | |
1109 | """ |
|
1112 | """ | |
1110 | Returns list of added ``FileNode`` objects. |
|
1113 | Returns list of added ``FileNode`` objects. | |
1111 | """ |
|
1114 | """ | |
1112 | raise NotImplementedError |
|
1115 | raise NotImplementedError | |
1113 |
|
1116 | |||
1114 | @LazyProperty |
|
1117 | @LazyProperty | |
1115 | def changed(self): |
|
1118 | def changed(self): | |
1116 | """ |
|
1119 | """ | |
1117 | Returns list of modified ``FileNode`` objects. |
|
1120 | Returns list of modified ``FileNode`` objects. | |
1118 | """ |
|
1121 | """ | |
1119 | raise NotImplementedError |
|
1122 | raise NotImplementedError | |
1120 |
|
1123 | |||
1121 | @LazyProperty |
|
1124 | @LazyProperty | |
1122 | def removed(self): |
|
1125 | def removed(self): | |
1123 | """ |
|
1126 | """ | |
1124 | Returns list of removed ``FileNode`` objects. |
|
1127 | Returns list of removed ``FileNode`` objects. | |
1125 | """ |
|
1128 | """ | |
1126 | raise NotImplementedError |
|
1129 | raise NotImplementedError | |
1127 |
|
1130 | |||
1128 | @LazyProperty |
|
1131 | @LazyProperty | |
1129 | def size(self): |
|
1132 | def size(self): | |
1130 | """ |
|
1133 | """ | |
1131 | Returns total number of bytes from contents of all filenodes. |
|
1134 | Returns total number of bytes from contents of all filenodes. | |
1132 | """ |
|
1135 | """ | |
1133 | return sum((node.size for node in self.get_filenodes_generator())) |
|
1136 | return sum((node.size for node in self.get_filenodes_generator())) | |
1134 |
|
1137 | |||
1135 | def walk(self, topurl=''): |
|
1138 | def walk(self, topurl=''): | |
1136 | """ |
|
1139 | """ | |
1137 | Similar to os.walk method. Insted of filesystem it walks through |
|
1140 | Similar to os.walk method. Insted of filesystem it walks through | |
1138 | commit starting at given ``topurl``. Returns generator of tuples |
|
1141 | commit starting at given ``topurl``. Returns generator of tuples | |
1139 | (topnode, dirnodes, filenodes). |
|
1142 | (topnode, dirnodes, filenodes). | |
1140 | """ |
|
1143 | """ | |
1141 | topnode = self.get_node(topurl) |
|
1144 | topnode = self.get_node(topurl) | |
1142 | if not topnode.is_dir(): |
|
1145 | if not topnode.is_dir(): | |
1143 | return |
|
1146 | return | |
1144 | yield (topnode, topnode.dirs, topnode.files) |
|
1147 | yield (topnode, topnode.dirs, topnode.files) | |
1145 | for dirnode in topnode.dirs: |
|
1148 | for dirnode in topnode.dirs: | |
1146 | for tup in self.walk(dirnode.path): |
|
1149 | for tup in self.walk(dirnode.path): | |
1147 | yield tup |
|
1150 | yield tup | |
1148 |
|
1151 | |||
1149 | def get_filenodes_generator(self): |
|
1152 | def get_filenodes_generator(self): | |
1150 | """ |
|
1153 | """ | |
1151 | Returns generator that yields *all* file nodes. |
|
1154 | Returns generator that yields *all* file nodes. | |
1152 | """ |
|
1155 | """ | |
1153 | for topnode, dirs, files in self.walk(): |
|
1156 | for topnode, dirs, files in self.walk(): | |
1154 | for node in files: |
|
1157 | for node in files: | |
1155 | yield node |
|
1158 | yield node | |
1156 |
|
1159 | |||
1157 | # |
|
1160 | # | |
1158 | # Utilities for sub classes to support consistent behavior |
|
1161 | # Utilities for sub classes to support consistent behavior | |
1159 | # |
|
1162 | # | |
1160 |
|
1163 | |||
1161 | def no_node_at_path(self, path): |
|
1164 | def no_node_at_path(self, path): | |
1162 | return NodeDoesNotExistError( |
|
1165 | return NodeDoesNotExistError( | |
1163 | u"There is no file nor directory at the given path: " |
|
1166 | u"There is no file nor directory at the given path: " | |
1164 | u"`%s` at commit %s" % (safe_unicode(path), self.short_id)) |
|
1167 | u"`%s` at commit %s" % (safe_unicode(path), self.short_id)) | |
1165 |
|
1168 | |||
1166 | def _fix_path(self, path): |
|
1169 | def _fix_path(self, path): | |
1167 | """ |
|
1170 | """ | |
1168 | Paths are stored without trailing slash so we need to get rid off it if |
|
1171 | Paths are stored without trailing slash so we need to get rid off it if | |
1169 | needed. |
|
1172 | needed. | |
1170 | """ |
|
1173 | """ | |
1171 | return path.rstrip('/') |
|
1174 | return path.rstrip('/') | |
1172 |
|
1175 | |||
1173 | # |
|
1176 | # | |
1174 | # Deprecated API based on changesets |
|
1177 | # Deprecated API based on changesets | |
1175 | # |
|
1178 | # | |
1176 |
|
1179 | |||
1177 | @property |
|
1180 | @property | |
1178 | def revision(self): |
|
1181 | def revision(self): | |
1179 | warnings.warn("Use idx instead", DeprecationWarning) |
|
1182 | warnings.warn("Use idx instead", DeprecationWarning) | |
1180 | return self.idx |
|
1183 | return self.idx | |
1181 |
|
1184 | |||
1182 | @revision.setter |
|
1185 | @revision.setter | |
1183 | def revision(self, value): |
|
1186 | def revision(self, value): | |
1184 | warnings.warn("Use idx instead", DeprecationWarning) |
|
1187 | warnings.warn("Use idx instead", DeprecationWarning) | |
1185 | self.idx = value |
|
1188 | self.idx = value | |
1186 |
|
1189 | |||
1187 | def get_file_changeset(self, path): |
|
1190 | def get_file_changeset(self, path): | |
1188 | warnings.warn("Use get_file_commit instead", DeprecationWarning) |
|
1191 | warnings.warn("Use get_file_commit instead", DeprecationWarning) | |
1189 | return self.get_file_commit(path) |
|
1192 | return self.get_file_commit(path) | |
1190 |
|
1193 | |||
1191 |
|
1194 | |||
1192 | class BaseChangesetClass(type): |
|
1195 | class BaseChangesetClass(type): | |
1193 |
|
1196 | |||
1194 | def __instancecheck__(self, instance): |
|
1197 | def __instancecheck__(self, instance): | |
1195 | return isinstance(instance, BaseCommit) |
|
1198 | return isinstance(instance, BaseCommit) | |
1196 |
|
1199 | |||
1197 |
|
1200 | |||
1198 | class BaseChangeset(BaseCommit): |
|
1201 | class BaseChangeset(BaseCommit): | |
1199 |
|
1202 | |||
1200 | __metaclass__ = BaseChangesetClass |
|
1203 | __metaclass__ = BaseChangesetClass | |
1201 |
|
1204 | |||
1202 | def __new__(cls, *args, **kwargs): |
|
1205 | def __new__(cls, *args, **kwargs): | |
1203 | warnings.warn( |
|
1206 | warnings.warn( | |
1204 | "Use BaseCommit instead of BaseChangeset", DeprecationWarning) |
|
1207 | "Use BaseCommit instead of BaseChangeset", DeprecationWarning) | |
1205 | return super(BaseChangeset, cls).__new__(cls, *args, **kwargs) |
|
1208 | return super(BaseChangeset, cls).__new__(cls, *args, **kwargs) | |
1206 |
|
1209 | |||
1207 |
|
1210 | |||
1208 | class BaseInMemoryCommit(object): |
|
1211 | class BaseInMemoryCommit(object): | |
1209 | """ |
|
1212 | """ | |
1210 | Represents differences between repository's state (most recent head) and |
|
1213 | Represents differences between repository's state (most recent head) and | |
1211 | changes made *in place*. |
|
1214 | changes made *in place*. | |
1212 |
|
1215 | |||
1213 | **Attributes** |
|
1216 | **Attributes** | |
1214 |
|
1217 | |||
1215 | ``repository`` |
|
1218 | ``repository`` | |
1216 | repository object for this in-memory-commit |
|
1219 | repository object for this in-memory-commit | |
1217 |
|
1220 | |||
1218 | ``added`` |
|
1221 | ``added`` | |
1219 | list of ``FileNode`` objects marked as *added* |
|
1222 | list of ``FileNode`` objects marked as *added* | |
1220 |
|
1223 | |||
1221 | ``changed`` |
|
1224 | ``changed`` | |
1222 | list of ``FileNode`` objects marked as *changed* |
|
1225 | list of ``FileNode`` objects marked as *changed* | |
1223 |
|
1226 | |||
1224 | ``removed`` |
|
1227 | ``removed`` | |
1225 | list of ``FileNode`` or ``RemovedFileNode`` objects marked to be |
|
1228 | list of ``FileNode`` or ``RemovedFileNode`` objects marked to be | |
1226 | *removed* |
|
1229 | *removed* | |
1227 |
|
1230 | |||
1228 | ``parents`` |
|
1231 | ``parents`` | |
1229 | list of :class:`BaseCommit` instances representing parents of |
|
1232 | list of :class:`BaseCommit` instances representing parents of | |
1230 | in-memory commit. Should always be 2-element sequence. |
|
1233 | in-memory commit. Should always be 2-element sequence. | |
1231 |
|
1234 | |||
1232 | """ |
|
1235 | """ | |
1233 |
|
1236 | |||
1234 | def __init__(self, repository): |
|
1237 | def __init__(self, repository): | |
1235 | self.repository = repository |
|
1238 | self.repository = repository | |
1236 | self.added = [] |
|
1239 | self.added = [] | |
1237 | self.changed = [] |
|
1240 | self.changed = [] | |
1238 | self.removed = [] |
|
1241 | self.removed = [] | |
1239 | self.parents = [] |
|
1242 | self.parents = [] | |
1240 |
|
1243 | |||
1241 | def add(self, *filenodes): |
|
1244 | def add(self, *filenodes): | |
1242 | """ |
|
1245 | """ | |
1243 | Marks given ``FileNode`` objects as *to be committed*. |
|
1246 | Marks given ``FileNode`` objects as *to be committed*. | |
1244 |
|
1247 | |||
1245 | :raises ``NodeAlreadyExistsError``: if node with same path exists at |
|
1248 | :raises ``NodeAlreadyExistsError``: if node with same path exists at | |
1246 | latest commit |
|
1249 | latest commit | |
1247 | :raises ``NodeAlreadyAddedError``: if node with same path is already |
|
1250 | :raises ``NodeAlreadyAddedError``: if node with same path is already | |
1248 | marked as *added* |
|
1251 | marked as *added* | |
1249 | """ |
|
1252 | """ | |
1250 | # Check if not already marked as *added* first |
|
1253 | # Check if not already marked as *added* first | |
1251 | for node in filenodes: |
|
1254 | for node in filenodes: | |
1252 | if node.path in (n.path for n in self.added): |
|
1255 | if node.path in (n.path for n in self.added): | |
1253 | raise NodeAlreadyAddedError( |
|
1256 | raise NodeAlreadyAddedError( | |
1254 | "Such FileNode %s is already marked for addition" |
|
1257 | "Such FileNode %s is already marked for addition" | |
1255 | % node.path) |
|
1258 | % node.path) | |
1256 | for node in filenodes: |
|
1259 | for node in filenodes: | |
1257 | self.added.append(node) |
|
1260 | self.added.append(node) | |
1258 |
|
1261 | |||
1259 | def change(self, *filenodes): |
|
1262 | def change(self, *filenodes): | |
1260 | """ |
|
1263 | """ | |
1261 | Marks given ``FileNode`` objects to be *changed* in next commit. |
|
1264 | Marks given ``FileNode`` objects to be *changed* in next commit. | |
1262 |
|
1265 | |||
1263 | :raises ``EmptyRepositoryError``: if there are no commits yet |
|
1266 | :raises ``EmptyRepositoryError``: if there are no commits yet | |
1264 | :raises ``NodeAlreadyExistsError``: if node with same path is already |
|
1267 | :raises ``NodeAlreadyExistsError``: if node with same path is already | |
1265 | marked to be *changed* |
|
1268 | marked to be *changed* | |
1266 | :raises ``NodeAlreadyRemovedError``: if node with same path is already |
|
1269 | :raises ``NodeAlreadyRemovedError``: if node with same path is already | |
1267 | marked to be *removed* |
|
1270 | marked to be *removed* | |
1268 | :raises ``NodeDoesNotExistError``: if node doesn't exist in latest |
|
1271 | :raises ``NodeDoesNotExistError``: if node doesn't exist in latest | |
1269 | commit |
|
1272 | commit | |
1270 | :raises ``NodeNotChangedError``: if node hasn't really be changed |
|
1273 | :raises ``NodeNotChangedError``: if node hasn't really be changed | |
1271 | """ |
|
1274 | """ | |
1272 | for node in filenodes: |
|
1275 | for node in filenodes: | |
1273 | if node.path in (n.path for n in self.removed): |
|
1276 | if node.path in (n.path for n in self.removed): | |
1274 | raise NodeAlreadyRemovedError( |
|
1277 | raise NodeAlreadyRemovedError( | |
1275 | "Node at %s is already marked as removed" % node.path) |
|
1278 | "Node at %s is already marked as removed" % node.path) | |
1276 | try: |
|
1279 | try: | |
1277 | self.repository.get_commit() |
|
1280 | self.repository.get_commit() | |
1278 | except EmptyRepositoryError: |
|
1281 | except EmptyRepositoryError: | |
1279 | raise EmptyRepositoryError( |
|
1282 | raise EmptyRepositoryError( | |
1280 | "Nothing to change - try to *add* new nodes rather than " |
|
1283 | "Nothing to change - try to *add* new nodes rather than " | |
1281 | "changing them") |
|
1284 | "changing them") | |
1282 | for node in filenodes: |
|
1285 | for node in filenodes: | |
1283 | if node.path in (n.path for n in self.changed): |
|
1286 | if node.path in (n.path for n in self.changed): | |
1284 | raise NodeAlreadyChangedError( |
|
1287 | raise NodeAlreadyChangedError( | |
1285 | "Node at '%s' is already marked as changed" % node.path) |
|
1288 | "Node at '%s' is already marked as changed" % node.path) | |
1286 | self.changed.append(node) |
|
1289 | self.changed.append(node) | |
1287 |
|
1290 | |||
1288 | def remove(self, *filenodes): |
|
1291 | def remove(self, *filenodes): | |
1289 | """ |
|
1292 | """ | |
1290 | Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be |
|
1293 | Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be | |
1291 | *removed* in next commit. |
|
1294 | *removed* in next commit. | |
1292 |
|
1295 | |||
1293 | :raises ``NodeAlreadyRemovedError``: if node has been already marked to |
|
1296 | :raises ``NodeAlreadyRemovedError``: if node has been already marked to | |
1294 | be *removed* |
|
1297 | be *removed* | |
1295 | :raises ``NodeAlreadyChangedError``: if node has been already marked to |
|
1298 | :raises ``NodeAlreadyChangedError``: if node has been already marked to | |
1296 | be *changed* |
|
1299 | be *changed* | |
1297 | """ |
|
1300 | """ | |
1298 | for node in filenodes: |
|
1301 | for node in filenodes: | |
1299 | if node.path in (n.path for n in self.removed): |
|
1302 | if node.path in (n.path for n in self.removed): | |
1300 | raise NodeAlreadyRemovedError( |
|
1303 | raise NodeAlreadyRemovedError( | |
1301 | "Node is already marked to for removal at %s" % node.path) |
|
1304 | "Node is already marked to for removal at %s" % node.path) | |
1302 | if node.path in (n.path for n in self.changed): |
|
1305 | if node.path in (n.path for n in self.changed): | |
1303 | raise NodeAlreadyChangedError( |
|
1306 | raise NodeAlreadyChangedError( | |
1304 | "Node is already marked to be changed at %s" % node.path) |
|
1307 | "Node is already marked to be changed at %s" % node.path) | |
1305 | # We only mark node as *removed* - real removal is done by |
|
1308 | # We only mark node as *removed* - real removal is done by | |
1306 | # commit method |
|
1309 | # commit method | |
1307 | self.removed.append(node) |
|
1310 | self.removed.append(node) | |
1308 |
|
1311 | |||
1309 | def reset(self): |
|
1312 | def reset(self): | |
1310 | """ |
|
1313 | """ | |
1311 | Resets this instance to initial state (cleans ``added``, ``changed`` |
|
1314 | Resets this instance to initial state (cleans ``added``, ``changed`` | |
1312 | and ``removed`` lists). |
|
1315 | and ``removed`` lists). | |
1313 | """ |
|
1316 | """ | |
1314 | self.added = [] |
|
1317 | self.added = [] | |
1315 | self.changed = [] |
|
1318 | self.changed = [] | |
1316 | self.removed = [] |
|
1319 | self.removed = [] | |
1317 | self.parents = [] |
|
1320 | self.parents = [] | |
1318 |
|
1321 | |||
1319 | def get_ipaths(self): |
|
1322 | def get_ipaths(self): | |
1320 | """ |
|
1323 | """ | |
1321 | Returns generator of paths from nodes marked as added, changed or |
|
1324 | Returns generator of paths from nodes marked as added, changed or | |
1322 | removed. |
|
1325 | removed. | |
1323 | """ |
|
1326 | """ | |
1324 | for node in itertools.chain(self.added, self.changed, self.removed): |
|
1327 | for node in itertools.chain(self.added, self.changed, self.removed): | |
1325 | yield node.path |
|
1328 | yield node.path | |
1326 |
|
1329 | |||
1327 | def get_paths(self): |
|
1330 | def get_paths(self): | |
1328 | """ |
|
1331 | """ | |
1329 | Returns list of paths from nodes marked as added, changed or removed. |
|
1332 | Returns list of paths from nodes marked as added, changed or removed. | |
1330 | """ |
|
1333 | """ | |
1331 | return list(self.get_ipaths()) |
|
1334 | return list(self.get_ipaths()) | |
1332 |
|
1335 | |||
1333 | def check_integrity(self, parents=None): |
|
1336 | def check_integrity(self, parents=None): | |
1334 | """ |
|
1337 | """ | |
1335 | Checks in-memory commit's integrity. Also, sets parents if not |
|
1338 | Checks in-memory commit's integrity. Also, sets parents if not | |
1336 | already set. |
|
1339 | already set. | |
1337 |
|
1340 | |||
1338 | :raises CommitError: if any error occurs (i.e. |
|
1341 | :raises CommitError: if any error occurs (i.e. | |
1339 | ``NodeDoesNotExistError``). |
|
1342 | ``NodeDoesNotExistError``). | |
1340 | """ |
|
1343 | """ | |
1341 | if not self.parents: |
|
1344 | if not self.parents: | |
1342 | parents = parents or [] |
|
1345 | parents = parents or [] | |
1343 | if len(parents) == 0: |
|
1346 | if len(parents) == 0: | |
1344 | try: |
|
1347 | try: | |
1345 | parents = [self.repository.get_commit(), None] |
|
1348 | parents = [self.repository.get_commit(), None] | |
1346 | except EmptyRepositoryError: |
|
1349 | except EmptyRepositoryError: | |
1347 | parents = [None, None] |
|
1350 | parents = [None, None] | |
1348 | elif len(parents) == 1: |
|
1351 | elif len(parents) == 1: | |
1349 | parents += [None] |
|
1352 | parents += [None] | |
1350 | self.parents = parents |
|
1353 | self.parents = parents | |
1351 |
|
1354 | |||
1352 | # Local parents, only if not None |
|
1355 | # Local parents, only if not None | |
1353 | parents = [p for p in self.parents if p] |
|
1356 | parents = [p for p in self.parents if p] | |
1354 |
|
1357 | |||
1355 | # Check nodes marked as added |
|
1358 | # Check nodes marked as added | |
1356 | for p in parents: |
|
1359 | for p in parents: | |
1357 | for node in self.added: |
|
1360 | for node in self.added: | |
1358 | try: |
|
1361 | try: | |
1359 | p.get_node(node.path) |
|
1362 | p.get_node(node.path) | |
1360 | except NodeDoesNotExistError: |
|
1363 | except NodeDoesNotExistError: | |
1361 | pass |
|
1364 | pass | |
1362 | else: |
|
1365 | else: | |
1363 | raise NodeAlreadyExistsError( |
|
1366 | raise NodeAlreadyExistsError( | |
1364 | "Node `%s` already exists at %s" % (node.path, p)) |
|
1367 | "Node `%s` already exists at %s" % (node.path, p)) | |
1365 |
|
1368 | |||
1366 | # Check nodes marked as changed |
|
1369 | # Check nodes marked as changed | |
1367 | missing = set(self.changed) |
|
1370 | missing = set(self.changed) | |
1368 | not_changed = set(self.changed) |
|
1371 | not_changed = set(self.changed) | |
1369 | if self.changed and not parents: |
|
1372 | if self.changed and not parents: | |
1370 | raise NodeDoesNotExistError(str(self.changed[0].path)) |
|
1373 | raise NodeDoesNotExistError(str(self.changed[0].path)) | |
1371 | for p in parents: |
|
1374 | for p in parents: | |
1372 | for node in self.changed: |
|
1375 | for node in self.changed: | |
1373 | try: |
|
1376 | try: | |
1374 | old = p.get_node(node.path) |
|
1377 | old = p.get_node(node.path) | |
1375 | missing.remove(node) |
|
1378 | missing.remove(node) | |
1376 | # if content actually changed, remove node from not_changed |
|
1379 | # if content actually changed, remove node from not_changed | |
1377 | if old.content != node.content: |
|
1380 | if old.content != node.content: | |
1378 | not_changed.remove(node) |
|
1381 | not_changed.remove(node) | |
1379 | except NodeDoesNotExistError: |
|
1382 | except NodeDoesNotExistError: | |
1380 | pass |
|
1383 | pass | |
1381 | if self.changed and missing: |
|
1384 | if self.changed and missing: | |
1382 | raise NodeDoesNotExistError( |
|
1385 | raise NodeDoesNotExistError( | |
1383 | "Node `%s` marked as modified but missing in parents: %s" |
|
1386 | "Node `%s` marked as modified but missing in parents: %s" | |
1384 | % (node.path, parents)) |
|
1387 | % (node.path, parents)) | |
1385 |
|
1388 | |||
1386 | if self.changed and not_changed: |
|
1389 | if self.changed and not_changed: | |
1387 | raise NodeNotChangedError( |
|
1390 | raise NodeNotChangedError( | |
1388 | "Node `%s` wasn't actually changed (parents: %s)" |
|
1391 | "Node `%s` wasn't actually changed (parents: %s)" | |
1389 | % (not_changed.pop().path, parents)) |
|
1392 | % (not_changed.pop().path, parents)) | |
1390 |
|
1393 | |||
1391 | # Check nodes marked as removed |
|
1394 | # Check nodes marked as removed | |
1392 | if self.removed and not parents: |
|
1395 | if self.removed and not parents: | |
1393 | raise NodeDoesNotExistError( |
|
1396 | raise NodeDoesNotExistError( | |
1394 | "Cannot remove node at %s as there " |
|
1397 | "Cannot remove node at %s as there " | |
1395 | "were no parents specified" % self.removed[0].path) |
|
1398 | "were no parents specified" % self.removed[0].path) | |
1396 | really_removed = set() |
|
1399 | really_removed = set() | |
1397 | for p in parents: |
|
1400 | for p in parents: | |
1398 | for node in self.removed: |
|
1401 | for node in self.removed: | |
1399 | try: |
|
1402 | try: | |
1400 | p.get_node(node.path) |
|
1403 | p.get_node(node.path) | |
1401 | really_removed.add(node) |
|
1404 | really_removed.add(node) | |
1402 | except CommitError: |
|
1405 | except CommitError: | |
1403 | pass |
|
1406 | pass | |
1404 | not_removed = set(self.removed) - really_removed |
|
1407 | not_removed = set(self.removed) - really_removed | |
1405 | if not_removed: |
|
1408 | if not_removed: | |
1406 | # TODO: johbo: This code branch does not seem to be covered |
|
1409 | # TODO: johbo: This code branch does not seem to be covered | |
1407 | raise NodeDoesNotExistError( |
|
1410 | raise NodeDoesNotExistError( | |
1408 | "Cannot remove node at %s from " |
|
1411 | "Cannot remove node at %s from " | |
1409 | "following parents: %s" % (not_removed, parents)) |
|
1412 | "following parents: %s" % (not_removed, parents)) | |
1410 |
|
1413 | |||
1411 | def commit( |
|
1414 | def commit( | |
1412 | self, message, author, parents=None, branch=None, date=None, |
|
1415 | self, message, author, parents=None, branch=None, date=None, | |
1413 | **kwargs): |
|
1416 | **kwargs): | |
1414 | """ |
|
1417 | """ | |
1415 | Performs in-memory commit (doesn't check workdir in any way) and |
|
1418 | Performs in-memory commit (doesn't check workdir in any way) and | |
1416 | returns newly created :class:`BaseCommit`. Updates repository's |
|
1419 | returns newly created :class:`BaseCommit`. Updates repository's | |
1417 | attribute `commits`. |
|
1420 | attribute `commits`. | |
1418 |
|
1421 | |||
1419 | .. note:: |
|
1422 | .. note:: | |
1420 |
|
1423 | |||
1421 | While overriding this method each backend's should call |
|
1424 | While overriding this method each backend's should call | |
1422 | ``self.check_integrity(parents)`` in the first place. |
|
1425 | ``self.check_integrity(parents)`` in the first place. | |
1423 |
|
1426 | |||
1424 | :param message: message of the commit |
|
1427 | :param message: message of the commit | |
1425 | :param author: full username, i.e. "Joe Doe <joe.doe@example.com>" |
|
1428 | :param author: full username, i.e. "Joe Doe <joe.doe@example.com>" | |
1426 | :param parents: single parent or sequence of parents from which commit |
|
1429 | :param parents: single parent or sequence of parents from which commit | |
1427 | would be derived |
|
1430 | would be derived | |
1428 | :param date: ``datetime.datetime`` instance. Defaults to |
|
1431 | :param date: ``datetime.datetime`` instance. Defaults to | |
1429 | ``datetime.datetime.now()``. |
|
1432 | ``datetime.datetime.now()``. | |
1430 | :param branch: branch name, as string. If none given, default backend's |
|
1433 | :param branch: branch name, as string. If none given, default backend's | |
1431 | branch would be used. |
|
1434 | branch would be used. | |
1432 |
|
1435 | |||
1433 | :raises ``CommitError``: if any error occurs while committing |
|
1436 | :raises ``CommitError``: if any error occurs while committing | |
1434 | """ |
|
1437 | """ | |
1435 | raise NotImplementedError |
|
1438 | raise NotImplementedError | |
1436 |
|
1439 | |||
1437 |
|
1440 | |||
1438 | class BaseInMemoryChangesetClass(type): |
|
1441 | class BaseInMemoryChangesetClass(type): | |
1439 |
|
1442 | |||
1440 | def __instancecheck__(self, instance): |
|
1443 | def __instancecheck__(self, instance): | |
1441 | return isinstance(instance, BaseInMemoryCommit) |
|
1444 | return isinstance(instance, BaseInMemoryCommit) | |
1442 |
|
1445 | |||
1443 |
|
1446 | |||
1444 | class BaseInMemoryChangeset(BaseInMemoryCommit): |
|
1447 | class BaseInMemoryChangeset(BaseInMemoryCommit): | |
1445 |
|
1448 | |||
1446 | __metaclass__ = BaseInMemoryChangesetClass |
|
1449 | __metaclass__ = BaseInMemoryChangesetClass | |
1447 |
|
1450 | |||
1448 | def __new__(cls, *args, **kwargs): |
|
1451 | def __new__(cls, *args, **kwargs): | |
1449 | warnings.warn( |
|
1452 | warnings.warn( | |
1450 | "Use BaseCommit instead of BaseInMemoryCommit", DeprecationWarning) |
|
1453 | "Use BaseCommit instead of BaseInMemoryCommit", DeprecationWarning) | |
1451 | return super(BaseInMemoryChangeset, cls).__new__(cls, *args, **kwargs) |
|
1454 | return super(BaseInMemoryChangeset, cls).__new__(cls, *args, **kwargs) | |
1452 |
|
1455 | |||
1453 |
|
1456 | |||
1454 | class EmptyCommit(BaseCommit): |
|
1457 | class EmptyCommit(BaseCommit): | |
1455 | """ |
|
1458 | """ | |
1456 | An dummy empty commit. It's possible to pass hash when creating |
|
1459 | An dummy empty commit. It's possible to pass hash when creating | |
1457 | an EmptyCommit |
|
1460 | an EmptyCommit | |
1458 | """ |
|
1461 | """ | |
1459 |
|
1462 | |||
1460 | def __init__( |
|
1463 | def __init__( | |
1461 | self, commit_id='0' * 40, repo=None, alias=None, idx=-1, |
|
1464 | self, commit_id='0' * 40, repo=None, alias=None, idx=-1, | |
1462 | message='', author='', date=None): |
|
1465 | message='', author='', date=None): | |
1463 | self._empty_commit_id = commit_id |
|
1466 | self._empty_commit_id = commit_id | |
1464 | # TODO: johbo: Solve idx parameter, default value does not make |
|
1467 | # TODO: johbo: Solve idx parameter, default value does not make | |
1465 | # too much sense |
|
1468 | # too much sense | |
1466 | self.idx = idx |
|
1469 | self.idx = idx | |
1467 | self.message = message |
|
1470 | self.message = message | |
1468 | self.author = author |
|
1471 | self.author = author | |
1469 | self.date = date or datetime.datetime.fromtimestamp(0) |
|
1472 | self.date = date or datetime.datetime.fromtimestamp(0) | |
1470 | self.repository = repo |
|
1473 | self.repository = repo | |
1471 | self.alias = alias |
|
1474 | self.alias = alias | |
1472 |
|
1475 | |||
1473 | @LazyProperty |
|
1476 | @LazyProperty | |
1474 | def raw_id(self): |
|
1477 | def raw_id(self): | |
1475 | """ |
|
1478 | """ | |
1476 | Returns raw string identifying this commit, useful for web |
|
1479 | Returns raw string identifying this commit, useful for web | |
1477 | representation. |
|
1480 | representation. | |
1478 | """ |
|
1481 | """ | |
1479 |
|
1482 | |||
1480 | return self._empty_commit_id |
|
1483 | return self._empty_commit_id | |
1481 |
|
1484 | |||
1482 | @LazyProperty |
|
1485 | @LazyProperty | |
1483 | def branch(self): |
|
1486 | def branch(self): | |
1484 | if self.alias: |
|
1487 | if self.alias: | |
1485 | from rhodecode.lib.vcs.backends import get_backend |
|
1488 | from rhodecode.lib.vcs.backends import get_backend | |
1486 | return get_backend(self.alias).DEFAULT_BRANCH_NAME |
|
1489 | return get_backend(self.alias).DEFAULT_BRANCH_NAME | |
1487 |
|
1490 | |||
1488 | @LazyProperty |
|
1491 | @LazyProperty | |
1489 | def short_id(self): |
|
1492 | def short_id(self): | |
1490 | return self.raw_id[:12] |
|
1493 | return self.raw_id[:12] | |
1491 |
|
1494 | |||
1492 | @LazyProperty |
|
1495 | @LazyProperty | |
1493 | def id(self): |
|
1496 | def id(self): | |
1494 | return self.raw_id |
|
1497 | return self.raw_id | |
1495 |
|
1498 | |||
1496 | def get_file_commit(self, path): |
|
1499 | def get_file_commit(self, path): | |
1497 | return self |
|
1500 | return self | |
1498 |
|
1501 | |||
1499 | def get_file_content(self, path): |
|
1502 | def get_file_content(self, path): | |
1500 | return u'' |
|
1503 | return u'' | |
1501 |
|
1504 | |||
1502 | def get_file_size(self, path): |
|
1505 | def get_file_size(self, path): | |
1503 | return 0 |
|
1506 | return 0 | |
1504 |
|
1507 | |||
1505 |
|
1508 | |||
1506 | class EmptyChangesetClass(type): |
|
1509 | class EmptyChangesetClass(type): | |
1507 |
|
1510 | |||
1508 | def __instancecheck__(self, instance): |
|
1511 | def __instancecheck__(self, instance): | |
1509 | return isinstance(instance, EmptyCommit) |
|
1512 | return isinstance(instance, EmptyCommit) | |
1510 |
|
1513 | |||
1511 |
|
1514 | |||
1512 | class EmptyChangeset(EmptyCommit): |
|
1515 | class EmptyChangeset(EmptyCommit): | |
1513 |
|
1516 | |||
1514 | __metaclass__ = EmptyChangesetClass |
|
1517 | __metaclass__ = EmptyChangesetClass | |
1515 |
|
1518 | |||
1516 | def __new__(cls, *args, **kwargs): |
|
1519 | def __new__(cls, *args, **kwargs): | |
1517 | warnings.warn( |
|
1520 | warnings.warn( | |
1518 | "Use EmptyCommit instead of EmptyChangeset", DeprecationWarning) |
|
1521 | "Use EmptyCommit instead of EmptyChangeset", DeprecationWarning) | |
1519 | return super(EmptyCommit, cls).__new__(cls, *args, **kwargs) |
|
1522 | return super(EmptyCommit, cls).__new__(cls, *args, **kwargs) | |
1520 |
|
1523 | |||
1521 | def __init__(self, cs='0' * 40, repo=None, requested_revision=None, |
|
1524 | def __init__(self, cs='0' * 40, repo=None, requested_revision=None, | |
1522 | alias=None, revision=-1, message='', author='', date=None): |
|
1525 | alias=None, revision=-1, message='', author='', date=None): | |
1523 | if requested_revision is not None: |
|
1526 | if requested_revision is not None: | |
1524 | warnings.warn( |
|
1527 | warnings.warn( | |
1525 | "Parameter requested_revision not supported anymore", |
|
1528 | "Parameter requested_revision not supported anymore", | |
1526 | DeprecationWarning) |
|
1529 | DeprecationWarning) | |
1527 | super(EmptyChangeset, self).__init__( |
|
1530 | super(EmptyChangeset, self).__init__( | |
1528 | commit_id=cs, repo=repo, alias=alias, idx=revision, |
|
1531 | commit_id=cs, repo=repo, alias=alias, idx=revision, | |
1529 | message=message, author=author, date=date) |
|
1532 | message=message, author=author, date=date) | |
1530 |
|
1533 | |||
1531 | @property |
|
1534 | @property | |
1532 | def revision(self): |
|
1535 | def revision(self): | |
1533 | warnings.warn("Use idx instead", DeprecationWarning) |
|
1536 | warnings.warn("Use idx instead", DeprecationWarning) | |
1534 | return self.idx |
|
1537 | return self.idx | |
1535 |
|
1538 | |||
1536 | @revision.setter |
|
1539 | @revision.setter | |
1537 | def revision(self, value): |
|
1540 | def revision(self, value): | |
1538 | warnings.warn("Use idx instead", DeprecationWarning) |
|
1541 | warnings.warn("Use idx instead", DeprecationWarning) | |
1539 | self.idx = value |
|
1542 | self.idx = value | |
1540 |
|
1543 | |||
1541 |
|
1544 | |||
1542 | class EmptyRepository(BaseRepository): |
|
1545 | class EmptyRepository(BaseRepository): | |
1543 | def __init__(self, repo_path=None, config=None, create=False, **kwargs): |
|
1546 | def __init__(self, repo_path=None, config=None, create=False, **kwargs): | |
1544 | pass |
|
1547 | pass | |
1545 |
|
1548 | |||
1546 | def get_diff(self, *args, **kwargs): |
|
1549 | def get_diff(self, *args, **kwargs): | |
1547 | from rhodecode.lib.vcs.backends.git.diff import GitDiff |
|
1550 | from rhodecode.lib.vcs.backends.git.diff import GitDiff | |
1548 | return GitDiff('') |
|
1551 | return GitDiff('') | |
1549 |
|
1552 | |||
1550 |
|
1553 | |||
1551 | class CollectionGenerator(object): |
|
1554 | class CollectionGenerator(object): | |
1552 |
|
1555 | |||
1553 | def __init__(self, repo, commit_ids, collection_size=None, pre_load=None): |
|
1556 | def __init__(self, repo, commit_ids, collection_size=None, pre_load=None): | |
1554 | self.repo = repo |
|
1557 | self.repo = repo | |
1555 | self.commit_ids = commit_ids |
|
1558 | self.commit_ids = commit_ids | |
1556 | # TODO: (oliver) this isn't currently hooked up |
|
1559 | # TODO: (oliver) this isn't currently hooked up | |
1557 | self.collection_size = None |
|
1560 | self.collection_size = None | |
1558 | self.pre_load = pre_load |
|
1561 | self.pre_load = pre_load | |
1559 |
|
1562 | |||
1560 | def __len__(self): |
|
1563 | def __len__(self): | |
1561 | if self.collection_size is not None: |
|
1564 | if self.collection_size is not None: | |
1562 | return self.collection_size |
|
1565 | return self.collection_size | |
1563 | return self.commit_ids.__len__() |
|
1566 | return self.commit_ids.__len__() | |
1564 |
|
1567 | |||
1565 | def __iter__(self): |
|
1568 | def __iter__(self): | |
1566 | for commit_id in self.commit_ids: |
|
1569 | for commit_id in self.commit_ids: | |
1567 | # TODO: johbo: Mercurial passes in commit indices or commit ids |
|
1570 | # TODO: johbo: Mercurial passes in commit indices or commit ids | |
1568 | yield self._commit_factory(commit_id) |
|
1571 | yield self._commit_factory(commit_id) | |
1569 |
|
1572 | |||
1570 | def _commit_factory(self, commit_id): |
|
1573 | def _commit_factory(self, commit_id): | |
1571 | """ |
|
1574 | """ | |
1572 | Allows backends to override the way commits are generated. |
|
1575 | Allows backends to override the way commits are generated. | |
1573 | """ |
|
1576 | """ | |
1574 | return self.repo.get_commit(commit_id=commit_id, |
|
1577 | return self.repo.get_commit(commit_id=commit_id, | |
1575 | pre_load=self.pre_load) |
|
1578 | pre_load=self.pre_load) | |
1576 |
|
1579 | |||
1577 | def __getslice__(self, i, j): |
|
1580 | def __getslice__(self, i, j): | |
1578 | """ |
|
1581 | """ | |
1579 | Returns an iterator of sliced repository |
|
1582 | Returns an iterator of sliced repository | |
1580 | """ |
|
1583 | """ | |
1581 | commit_ids = self.commit_ids[i:j] |
|
1584 | commit_ids = self.commit_ids[i:j] | |
1582 | return self.__class__( |
|
1585 | return self.__class__( | |
1583 | self.repo, commit_ids, pre_load=self.pre_load) |
|
1586 | self.repo, commit_ids, pre_load=self.pre_load) | |
1584 |
|
1587 | |||
1585 | def __repr__(self): |
|
1588 | def __repr__(self): | |
1586 | return '<CollectionGenerator[len:%s]>' % (self.__len__()) |
|
1589 | return '<CollectionGenerator[len:%s]>' % (self.__len__()) | |
1587 |
|
1590 | |||
1588 |
|
1591 | |||
1589 | class Config(object): |
|
1592 | class Config(object): | |
1590 | """ |
|
1593 | """ | |
1591 | Represents the configuration for a repository. |
|
1594 | Represents the configuration for a repository. | |
1592 |
|
1595 | |||
1593 | The API is inspired by :class:`ConfigParser.ConfigParser` from the |
|
1596 | The API is inspired by :class:`ConfigParser.ConfigParser` from the | |
1594 | standard library. It implements only the needed subset. |
|
1597 | standard library. It implements only the needed subset. | |
1595 | """ |
|
1598 | """ | |
1596 |
|
1599 | |||
1597 | def __init__(self): |
|
1600 | def __init__(self): | |
1598 | self._values = {} |
|
1601 | self._values = {} | |
1599 |
|
1602 | |||
1600 | def copy(self): |
|
1603 | def copy(self): | |
1601 | clone = Config() |
|
1604 | clone = Config() | |
1602 | for section, values in self._values.items(): |
|
1605 | for section, values in self._values.items(): | |
1603 | clone._values[section] = values.copy() |
|
1606 | clone._values[section] = values.copy() | |
1604 | return clone |
|
1607 | return clone | |
1605 |
|
1608 | |||
1606 | def __repr__(self): |
|
1609 | def __repr__(self): | |
1607 | return '<Config(%s sections) at %s>' % ( |
|
1610 | return '<Config(%s sections) at %s>' % ( | |
1608 | len(self._values), hex(id(self))) |
|
1611 | len(self._values), hex(id(self))) | |
1609 |
|
1612 | |||
1610 | def items(self, section): |
|
1613 | def items(self, section): | |
1611 | return self._values.get(section, {}).iteritems() |
|
1614 | return self._values.get(section, {}).iteritems() | |
1612 |
|
1615 | |||
1613 | def get(self, section, option): |
|
1616 | def get(self, section, option): | |
1614 | return self._values.get(section, {}).get(option) |
|
1617 | return self._values.get(section, {}).get(option) | |
1615 |
|
1618 | |||
1616 | def set(self, section, option, value): |
|
1619 | def set(self, section, option, value): | |
1617 | section_values = self._values.setdefault(section, {}) |
|
1620 | section_values = self._values.setdefault(section, {}) | |
1618 | section_values[option] = value |
|
1621 | section_values[option] = value | |
1619 |
|
1622 | |||
1620 | def clear_section(self, section): |
|
1623 | def clear_section(self, section): | |
1621 | self._values[section] = {} |
|
1624 | self._values[section] = {} | |
1622 |
|
1625 | |||
1623 | def serialize(self): |
|
1626 | def serialize(self): | |
1624 | """ |
|
1627 | """ | |
1625 | Creates a list of three tuples (section, key, value) representing |
|
1628 | Creates a list of three tuples (section, key, value) representing | |
1626 | this config object. |
|
1629 | this config object. | |
1627 | """ |
|
1630 | """ | |
1628 | items = [] |
|
1631 | items = [] | |
1629 | for section in self._values: |
|
1632 | for section in self._values: | |
1630 | for option, value in self._values[section].items(): |
|
1633 | for option, value in self._values[section].items(): | |
1631 | items.append( |
|
1634 | items.append( | |
1632 | (safe_str(section), safe_str(option), safe_str(value))) |
|
1635 | (safe_str(section), safe_str(option), safe_str(value))) | |
1633 | return items |
|
1636 | return items | |
1634 |
|
1637 | |||
1635 |
|
1638 | |||
1636 | class Diff(object): |
|
1639 | class Diff(object): | |
1637 | """ |
|
1640 | """ | |
1638 | Represents a diff result from a repository backend. |
|
1641 | Represents a diff result from a repository backend. | |
1639 |
|
1642 | |||
1640 | Subclasses have to provide a backend specific value for |
|
1643 | Subclasses have to provide a backend specific value for | |
1641 | :attr:`_header_re` and :attr:`_meta_re`. |
|
1644 | :attr:`_header_re` and :attr:`_meta_re`. | |
1642 | """ |
|
1645 | """ | |
1643 | _meta_re = None |
|
1646 | _meta_re = None | |
1644 | _header_re = None |
|
1647 | _header_re = None | |
1645 |
|
1648 | |||
1646 | def __init__(self, raw_diff): |
|
1649 | def __init__(self, raw_diff): | |
1647 | self.raw = raw_diff |
|
1650 | self.raw = raw_diff | |
1648 |
|
1651 | |||
1649 | def chunks(self): |
|
1652 | def chunks(self): | |
1650 | """ |
|
1653 | """ | |
1651 | split the diff in chunks of separate --git a/file b/file chunks |
|
1654 | split the diff in chunks of separate --git a/file b/file chunks | |
1652 | to make diffs consistent we must prepend with \n, and make sure |
|
1655 | to make diffs consistent we must prepend with \n, and make sure | |
1653 | we can detect last chunk as this was also has special rule |
|
1656 | we can detect last chunk as this was also has special rule | |
1654 | """ |
|
1657 | """ | |
1655 |
|
1658 | |||
1656 | diff_parts = ('\n' + self.raw).split('\ndiff --git') |
|
1659 | diff_parts = ('\n' + self.raw).split('\ndiff --git') | |
1657 | header = diff_parts[0] |
|
1660 | header = diff_parts[0] | |
1658 |
|
1661 | |||
1659 | if self._meta_re: |
|
1662 | if self._meta_re: | |
1660 | match = self._meta_re.match(header) |
|
1663 | match = self._meta_re.match(header) | |
1661 |
|
1664 | |||
1662 | chunks = diff_parts[1:] |
|
1665 | chunks = diff_parts[1:] | |
1663 | total_chunks = len(chunks) |
|
1666 | total_chunks = len(chunks) | |
1664 |
|
1667 | |||
1665 | return ( |
|
1668 | return ( | |
1666 | DiffChunk(chunk, self, cur_chunk == total_chunks) |
|
1669 | DiffChunk(chunk, self, cur_chunk == total_chunks) | |
1667 | for cur_chunk, chunk in enumerate(chunks, start=1)) |
|
1670 | for cur_chunk, chunk in enumerate(chunks, start=1)) | |
1668 |
|
1671 | |||
1669 |
|
1672 | |||
1670 | class DiffChunk(object): |
|
1673 | class DiffChunk(object): | |
1671 |
|
1674 | |||
1672 | def __init__(self, chunk, diff, last_chunk): |
|
1675 | def __init__(self, chunk, diff, last_chunk): | |
1673 | self._diff = diff |
|
1676 | self._diff = diff | |
1674 |
|
1677 | |||
1675 | # since we split by \ndiff --git that part is lost from original diff |
|
1678 | # since we split by \ndiff --git that part is lost from original diff | |
1676 | # we need to re-apply it at the end, EXCEPT ! if it's last chunk |
|
1679 | # we need to re-apply it at the end, EXCEPT ! if it's last chunk | |
1677 | if not last_chunk: |
|
1680 | if not last_chunk: | |
1678 | chunk += '\n' |
|
1681 | chunk += '\n' | |
1679 |
|
1682 | |||
1680 | match = self._diff._header_re.match(chunk) |
|
1683 | match = self._diff._header_re.match(chunk) | |
1681 | self.header = match.groupdict() |
|
1684 | self.header = match.groupdict() | |
1682 | self.diff = chunk[match.end():] |
|
1685 | self.diff = chunk[match.end():] | |
1683 | self.raw = chunk |
|
1686 | self.raw = chunk | |
1684 |
|
1687 | |||
1685 |
|
1688 | |||
1686 | class BasePathPermissionChecker(object): |
|
1689 | class BasePathPermissionChecker(object): | |
1687 |
|
1690 | |||
1688 | @staticmethod |
|
1691 | @staticmethod | |
1689 | def create_from_patterns(includes, excludes): |
|
1692 | def create_from_patterns(includes, excludes): | |
1690 | if includes and '*' in includes and not excludes: |
|
1693 | if includes and '*' in includes and not excludes: | |
1691 | return AllPathPermissionChecker() |
|
1694 | return AllPathPermissionChecker() | |
1692 | elif excludes and '*' in excludes: |
|
1695 | elif excludes and '*' in excludes: | |
1693 | return NonePathPermissionChecker() |
|
1696 | return NonePathPermissionChecker() | |
1694 | else: |
|
1697 | else: | |
1695 | return PatternPathPermissionChecker(includes, excludes) |
|
1698 | return PatternPathPermissionChecker(includes, excludes) | |
1696 |
|
1699 | |||
1697 | @property |
|
1700 | @property | |
1698 | def has_full_access(self): |
|
1701 | def has_full_access(self): | |
1699 | raise NotImplemented() |
|
1702 | raise NotImplemented() | |
1700 |
|
1703 | |||
1701 | def has_access(self, path): |
|
1704 | def has_access(self, path): | |
1702 | raise NotImplemented() |
|
1705 | raise NotImplemented() | |
1703 |
|
1706 | |||
1704 |
|
1707 | |||
1705 | class AllPathPermissionChecker(BasePathPermissionChecker): |
|
1708 | class AllPathPermissionChecker(BasePathPermissionChecker): | |
1706 |
|
1709 | |||
1707 | @property |
|
1710 | @property | |
1708 | def has_full_access(self): |
|
1711 | def has_full_access(self): | |
1709 | return True |
|
1712 | return True | |
1710 |
|
1713 | |||
1711 | def has_access(self, path): |
|
1714 | def has_access(self, path): | |
1712 | return True |
|
1715 | return True | |
1713 |
|
1716 | |||
1714 |
|
1717 | |||
1715 | class NonePathPermissionChecker(BasePathPermissionChecker): |
|
1718 | class NonePathPermissionChecker(BasePathPermissionChecker): | |
1716 |
|
1719 | |||
1717 | @property |
|
1720 | @property | |
1718 | def has_full_access(self): |
|
1721 | def has_full_access(self): | |
1719 | return False |
|
1722 | return False | |
1720 |
|
1723 | |||
1721 | def has_access(self, path): |
|
1724 | def has_access(self, path): | |
1722 | return False |
|
1725 | return False | |
1723 |
|
1726 | |||
1724 |
|
1727 | |||
1725 | class PatternPathPermissionChecker(BasePathPermissionChecker): |
|
1728 | class PatternPathPermissionChecker(BasePathPermissionChecker): | |
1726 |
|
1729 | |||
1727 | def __init__(self, includes, excludes): |
|
1730 | def __init__(self, includes, excludes): | |
1728 | self.includes = includes |
|
1731 | self.includes = includes | |
1729 | self.excludes = excludes |
|
1732 | self.excludes = excludes | |
1730 | self.includes_re = [] if not includes else [ |
|
1733 | self.includes_re = [] if not includes else [ | |
1731 | re.compile(fnmatch.translate(pattern)) for pattern in includes] |
|
1734 | re.compile(fnmatch.translate(pattern)) for pattern in includes] | |
1732 | self.excludes_re = [] if not excludes else [ |
|
1735 | self.excludes_re = [] if not excludes else [ | |
1733 | re.compile(fnmatch.translate(pattern)) for pattern in excludes] |
|
1736 | re.compile(fnmatch.translate(pattern)) for pattern in excludes] | |
1734 |
|
1737 | |||
1735 | @property |
|
1738 | @property | |
1736 | def has_full_access(self): |
|
1739 | def has_full_access(self): | |
1737 | return '*' in self.includes and not self.excludes |
|
1740 | return '*' in self.includes and not self.excludes | |
1738 |
|
1741 | |||
1739 | def has_access(self, path): |
|
1742 | def has_access(self, path): | |
1740 | for regex in self.excludes_re: |
|
1743 | for regex in self.excludes_re: | |
1741 | if regex.match(path): |
|
1744 | if regex.match(path): | |
1742 | return False |
|
1745 | return False | |
1743 | for regex in self.includes_re: |
|
1746 | for regex in self.includes_re: | |
1744 | if regex.match(path): |
|
1747 | if regex.match(path): | |
1745 | return True |
|
1748 | return True | |
1746 | return False |
|
1749 | return False |
@@ -1,1006 +1,1009 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 |
|
2 | |||
3 | # Copyright (C) 2014-2018 RhodeCode GmbH |
|
3 | # Copyright (C) 2014-2018 RhodeCode GmbH | |
4 | # |
|
4 | # | |
5 | # This program is free software: you can redistribute it and/or modify |
|
5 | # This program is free software: you can redistribute it and/or modify | |
6 | # it under the terms of the GNU Affero General Public License, version 3 |
|
6 | # it under the terms of the GNU Affero General Public License, version 3 | |
7 | # (only), as published by the Free Software Foundation. |
|
7 | # (only), as published by the Free Software Foundation. | |
8 | # |
|
8 | # | |
9 | # This program is distributed in the hope that it will be useful, |
|
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. |
|
12 | # GNU General Public License for more details. | |
13 | # |
|
13 | # | |
14 | # You should have received a copy of the GNU Affero General Public License |
|
14 | # You should have received a copy of the GNU Affero General Public License | |
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
16 | # |
|
16 | # | |
17 | # This program is dual-licensed. If you wish to learn more about the |
|
17 | # This program is dual-licensed. If you wish to learn more about the | |
18 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
18 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
20 |
|
20 | |||
21 | """ |
|
21 | """ | |
22 | GIT repository module |
|
22 | GIT repository module | |
23 | """ |
|
23 | """ | |
24 |
|
24 | |||
25 | import logging |
|
25 | import logging | |
26 | import os |
|
26 | import os | |
27 | import re |
|
27 | import re | |
28 |
|
28 | |||
29 | from zope.cachedescriptors.property import Lazy as LazyProperty |
|
29 | from zope.cachedescriptors.property import Lazy as LazyProperty | |
30 |
|
30 | |||
31 | from rhodecode.lib.compat import OrderedDict |
|
31 | from rhodecode.lib.compat import OrderedDict | |
32 | from rhodecode.lib.datelib import ( |
|
32 | from rhodecode.lib.datelib import ( | |
33 | utcdate_fromtimestamp, makedate, date_astimestamp) |
|
33 | utcdate_fromtimestamp, makedate, date_astimestamp) | |
34 | from rhodecode.lib.utils import safe_unicode, safe_str |
|
34 | from rhodecode.lib.utils import safe_unicode, safe_str | |
35 | from rhodecode.lib.vcs import connection, path as vcspath |
|
35 | from rhodecode.lib.vcs import connection, path as vcspath | |
36 | from rhodecode.lib.vcs.backends.base import ( |
|
36 | from rhodecode.lib.vcs.backends.base import ( | |
37 | BaseRepository, CollectionGenerator, Config, MergeResponse, |
|
37 | BaseRepository, CollectionGenerator, Config, MergeResponse, | |
38 | MergeFailureReason, Reference) |
|
38 | MergeFailureReason, Reference) | |
39 | from rhodecode.lib.vcs.backends.git.commit import GitCommit |
|
39 | from rhodecode.lib.vcs.backends.git.commit import GitCommit | |
40 | from rhodecode.lib.vcs.backends.git.diff import GitDiff |
|
40 | from rhodecode.lib.vcs.backends.git.diff import GitDiff | |
41 | from rhodecode.lib.vcs.backends.git.inmemory import GitInMemoryCommit |
|
41 | from rhodecode.lib.vcs.backends.git.inmemory import GitInMemoryCommit | |
42 | from rhodecode.lib.vcs.exceptions import ( |
|
42 | from rhodecode.lib.vcs.exceptions import ( | |
43 | CommitDoesNotExistError, EmptyRepositoryError, |
|
43 | CommitDoesNotExistError, EmptyRepositoryError, | |
44 | RepositoryError, TagAlreadyExistError, TagDoesNotExistError, VCSError) |
|
44 | RepositoryError, TagAlreadyExistError, TagDoesNotExistError, VCSError) | |
45 |
|
45 | |||
46 |
|
46 | |||
47 | SHA_PATTERN = re.compile(r'^[[0-9a-fA-F]{12}|[0-9a-fA-F]{40}]$') |
|
47 | SHA_PATTERN = re.compile(r'^[[0-9a-fA-F]{12}|[0-9a-fA-F]{40}]$') | |
48 |
|
48 | |||
49 | log = logging.getLogger(__name__) |
|
49 | log = logging.getLogger(__name__) | |
50 |
|
50 | |||
51 |
|
51 | |||
52 | class GitRepository(BaseRepository): |
|
52 | class GitRepository(BaseRepository): | |
53 | """ |
|
53 | """ | |
54 | Git repository backend. |
|
54 | Git repository backend. | |
55 | """ |
|
55 | """ | |
56 | DEFAULT_BRANCH_NAME = 'master' |
|
56 | DEFAULT_BRANCH_NAME = 'master' | |
57 |
|
57 | |||
58 | contact = BaseRepository.DEFAULT_CONTACT |
|
58 | contact = BaseRepository.DEFAULT_CONTACT | |
59 |
|
59 | |||
60 | def __init__(self, repo_path, config=None, create=False, src_url=None, |
|
60 | def __init__(self, repo_path, config=None, create=False, src_url=None, | |
61 | update_after_clone=False, with_wire=None, bare=False): |
|
61 | update_after_clone=False, with_wire=None, bare=False): | |
62 |
|
62 | |||
63 | self.path = safe_str(os.path.abspath(repo_path)) |
|
63 | self.path = safe_str(os.path.abspath(repo_path)) | |
64 | self.config = config if config else self.get_default_config() |
|
64 | self.config = config if config else self.get_default_config() | |
65 | self._remote = connection.Git( |
|
65 | self.with_wire = with_wire | |
66 | self.path, self.config, with_wire=with_wire) |
|
|||
67 |
|
66 | |||
68 | self._init_repo(create, src_url, update_after_clone, bare) |
|
67 | self._init_repo(create, src_url, update_after_clone, bare) | |
69 |
|
68 | |||
70 | # caches |
|
69 | # caches | |
71 | self._commit_ids = {} |
|
70 | self._commit_ids = {} | |
72 |
|
71 | |||
73 | @LazyProperty |
|
72 | @LazyProperty | |
|
73 | def _remote(self): | |||
|
74 | return connection.Git(self.path, self.config, with_wire=self.with_wire) | |||
|
75 | ||||
|
76 | @LazyProperty | |||
74 | def bare(self): |
|
77 | def bare(self): | |
75 | return self._remote.bare() |
|
78 | return self._remote.bare() | |
76 |
|
79 | |||
77 | @LazyProperty |
|
80 | @LazyProperty | |
78 | def head(self): |
|
81 | def head(self): | |
79 | return self._remote.head() |
|
82 | return self._remote.head() | |
80 |
|
83 | |||
81 | @LazyProperty |
|
84 | @LazyProperty | |
82 | def commit_ids(self): |
|
85 | def commit_ids(self): | |
83 | """ |
|
86 | """ | |
84 | Returns list of commit ids, in ascending order. Being lazy |
|
87 | Returns list of commit ids, in ascending order. Being lazy | |
85 | attribute allows external tools to inject commit ids from cache. |
|
88 | attribute allows external tools to inject commit ids from cache. | |
86 | """ |
|
89 | """ | |
87 | commit_ids = self._get_all_commit_ids() |
|
90 | commit_ids = self._get_all_commit_ids() | |
88 | self._rebuild_cache(commit_ids) |
|
91 | self._rebuild_cache(commit_ids) | |
89 | return commit_ids |
|
92 | return commit_ids | |
90 |
|
93 | |||
91 | def _rebuild_cache(self, commit_ids): |
|
94 | def _rebuild_cache(self, commit_ids): | |
92 | self._commit_ids = dict((commit_id, index) |
|
95 | self._commit_ids = dict((commit_id, index) | |
93 | for index, commit_id in enumerate(commit_ids)) |
|
96 | for index, commit_id in enumerate(commit_ids)) | |
94 |
|
97 | |||
95 | def run_git_command(self, cmd, **opts): |
|
98 | def run_git_command(self, cmd, **opts): | |
96 | """ |
|
99 | """ | |
97 | Runs given ``cmd`` as git command and returns tuple |
|
100 | Runs given ``cmd`` as git command and returns tuple | |
98 | (stdout, stderr). |
|
101 | (stdout, stderr). | |
99 |
|
102 | |||
100 | :param cmd: git command to be executed |
|
103 | :param cmd: git command to be executed | |
101 | :param opts: env options to pass into Subprocess command |
|
104 | :param opts: env options to pass into Subprocess command | |
102 | """ |
|
105 | """ | |
103 | if not isinstance(cmd, list): |
|
106 | if not isinstance(cmd, list): | |
104 | raise ValueError('cmd must be a list, got %s instead' % type(cmd)) |
|
107 | raise ValueError('cmd must be a list, got %s instead' % type(cmd)) | |
105 |
|
108 | |||
106 | skip_stderr_log = opts.pop('skip_stderr_log', False) |
|
109 | skip_stderr_log = opts.pop('skip_stderr_log', False) | |
107 | out, err = self._remote.run_git_command(cmd, **opts) |
|
110 | out, err = self._remote.run_git_command(cmd, **opts) | |
108 | if err and not skip_stderr_log: |
|
111 | if err and not skip_stderr_log: | |
109 | log.debug('Stderr output of git command "%s":\n%s', cmd, err) |
|
112 | log.debug('Stderr output of git command "%s":\n%s', cmd, err) | |
110 | return out, err |
|
113 | return out, err | |
111 |
|
114 | |||
112 | @staticmethod |
|
115 | @staticmethod | |
113 | def check_url(url, config): |
|
116 | def check_url(url, config): | |
114 | """ |
|
117 | """ | |
115 | Function will check given url and try to verify if it's a valid |
|
118 | Function will check given url and try to verify if it's a valid | |
116 | link. Sometimes it may happened that git will issue basic |
|
119 | link. Sometimes it may happened that git will issue basic | |
117 | auth request that can cause whole API to hang when used from python |
|
120 | auth request that can cause whole API to hang when used from python | |
118 | or other external calls. |
|
121 | or other external calls. | |
119 |
|
122 | |||
120 | On failures it'll raise urllib2.HTTPError, exception is also thrown |
|
123 | On failures it'll raise urllib2.HTTPError, exception is also thrown | |
121 | when the return code is non 200 |
|
124 | when the return code is non 200 | |
122 | """ |
|
125 | """ | |
123 | # check first if it's not an url |
|
126 | # check first if it's not an url | |
124 | if os.path.isdir(url) or url.startswith('file:'): |
|
127 | if os.path.isdir(url) or url.startswith('file:'): | |
125 | return True |
|
128 | return True | |
126 |
|
129 | |||
127 | if '+' in url.split('://', 1)[0]: |
|
130 | if '+' in url.split('://', 1)[0]: | |
128 | url = url.split('+', 1)[1] |
|
131 | url = url.split('+', 1)[1] | |
129 |
|
132 | |||
130 | # Request the _remote to verify the url |
|
133 | # Request the _remote to verify the url | |
131 | return connection.Git.check_url(url, config.serialize()) |
|
134 | return connection.Git.check_url(url, config.serialize()) | |
132 |
|
135 | |||
133 | @staticmethod |
|
136 | @staticmethod | |
134 | def is_valid_repository(path): |
|
137 | def is_valid_repository(path): | |
135 | if os.path.isdir(os.path.join(path, '.git')): |
|
138 | if os.path.isdir(os.path.join(path, '.git')): | |
136 | return True |
|
139 | return True | |
137 | # check case of bare repository |
|
140 | # check case of bare repository | |
138 | try: |
|
141 | try: | |
139 | GitRepository(path) |
|
142 | GitRepository(path) | |
140 | return True |
|
143 | return True | |
141 | except VCSError: |
|
144 | except VCSError: | |
142 | pass |
|
145 | pass | |
143 | return False |
|
146 | return False | |
144 |
|
147 | |||
145 | def _init_repo(self, create, src_url=None, update_after_clone=False, |
|
148 | def _init_repo(self, create, src_url=None, update_after_clone=False, | |
146 | bare=False): |
|
149 | bare=False): | |
147 | if create and os.path.exists(self.path): |
|
150 | if create and os.path.exists(self.path): | |
148 | raise RepositoryError( |
|
151 | raise RepositoryError( | |
149 | "Cannot create repository at %s, location already exist" |
|
152 | "Cannot create repository at %s, location already exist" | |
150 | % self.path) |
|
153 | % self.path) | |
151 |
|
154 | |||
152 | try: |
|
155 | try: | |
153 | if create and src_url: |
|
156 | if create and src_url: | |
154 | GitRepository.check_url(src_url, self.config) |
|
157 | GitRepository.check_url(src_url, self.config) | |
155 | self.clone(src_url, update_after_clone, bare) |
|
158 | self.clone(src_url, update_after_clone, bare) | |
156 | elif create: |
|
159 | elif create: | |
157 | os.makedirs(self.path, mode=0755) |
|
160 | os.makedirs(self.path, mode=0755) | |
158 |
|
161 | |||
159 | if bare: |
|
162 | if bare: | |
160 | self._remote.init_bare() |
|
163 | self._remote.init_bare() | |
161 | else: |
|
164 | else: | |
162 | self._remote.init() |
|
165 | self._remote.init() | |
163 | else: |
|
166 | else: | |
164 | if not self._remote.assert_correct_path(): |
|
167 | if not self._remote.assert_correct_path(): | |
165 | raise RepositoryError( |
|
168 | raise RepositoryError( | |
166 | 'Path "%s" does not contain a Git repository' % |
|
169 | 'Path "%s" does not contain a Git repository' % | |
167 | (self.path,)) |
|
170 | (self.path,)) | |
168 |
|
171 | |||
169 | # TODO: johbo: check if we have to translate the OSError here |
|
172 | # TODO: johbo: check if we have to translate the OSError here | |
170 | except OSError as err: |
|
173 | except OSError as err: | |
171 | raise RepositoryError(err) |
|
174 | raise RepositoryError(err) | |
172 |
|
175 | |||
173 | def _get_all_commit_ids(self, filters=None): |
|
176 | def _get_all_commit_ids(self, filters=None): | |
174 | # we must check if this repo is not empty, since later command |
|
177 | # we must check if this repo is not empty, since later command | |
175 | # fails if it is. And it's cheaper to ask than throw the subprocess |
|
178 | # fails if it is. And it's cheaper to ask than throw the subprocess | |
176 | # errors |
|
179 | # errors | |
177 | try: |
|
180 | try: | |
178 | self._remote.head() |
|
181 | self._remote.head() | |
179 | except KeyError: |
|
182 | except KeyError: | |
180 | return [] |
|
183 | return [] | |
181 |
|
184 | |||
182 | rev_filter = ['--branches', '--tags'] |
|
185 | rev_filter = ['--branches', '--tags'] | |
183 | extra_filter = [] |
|
186 | extra_filter = [] | |
184 |
|
187 | |||
185 | if filters: |
|
188 | if filters: | |
186 | if filters.get('since'): |
|
189 | if filters.get('since'): | |
187 | extra_filter.append('--since=%s' % (filters['since'])) |
|
190 | extra_filter.append('--since=%s' % (filters['since'])) | |
188 | if filters.get('until'): |
|
191 | if filters.get('until'): | |
189 | extra_filter.append('--until=%s' % (filters['until'])) |
|
192 | extra_filter.append('--until=%s' % (filters['until'])) | |
190 | if filters.get('branch_name'): |
|
193 | if filters.get('branch_name'): | |
191 | rev_filter = ['--tags'] |
|
194 | rev_filter = ['--tags'] | |
192 | extra_filter.append(filters['branch_name']) |
|
195 | extra_filter.append(filters['branch_name']) | |
193 | rev_filter.extend(extra_filter) |
|
196 | rev_filter.extend(extra_filter) | |
194 |
|
197 | |||
195 | # if filters.get('start') or filters.get('end'): |
|
198 | # if filters.get('start') or filters.get('end'): | |
196 | # # skip is offset, max-count is limit |
|
199 | # # skip is offset, max-count is limit | |
197 | # if filters.get('start'): |
|
200 | # if filters.get('start'): | |
198 | # extra_filter += ' --skip=%s' % filters['start'] |
|
201 | # extra_filter += ' --skip=%s' % filters['start'] | |
199 | # if filters.get('end'): |
|
202 | # if filters.get('end'): | |
200 | # extra_filter += ' --max-count=%s' % (filters['end'] - (filters['start'] or 0)) |
|
203 | # extra_filter += ' --max-count=%s' % (filters['end'] - (filters['start'] or 0)) | |
201 |
|
204 | |||
202 | cmd = ['rev-list', '--reverse', '--date-order'] + rev_filter |
|
205 | cmd = ['rev-list', '--reverse', '--date-order'] + rev_filter | |
203 | try: |
|
206 | try: | |
204 | output, __ = self.run_git_command(cmd) |
|
207 | output, __ = self.run_git_command(cmd) | |
205 | except RepositoryError: |
|
208 | except RepositoryError: | |
206 | # Can be raised for empty repositories |
|
209 | # Can be raised for empty repositories | |
207 | return [] |
|
210 | return [] | |
208 | return output.splitlines() |
|
211 | return output.splitlines() | |
209 |
|
212 | |||
210 | def _get_commit_id(self, commit_id_or_idx): |
|
213 | def _get_commit_id(self, commit_id_or_idx): | |
211 | def is_null(value): |
|
214 | def is_null(value): | |
212 | return len(value) == commit_id_or_idx.count('0') |
|
215 | return len(value) == commit_id_or_idx.count('0') | |
213 |
|
216 | |||
214 | if self.is_empty(): |
|
217 | if self.is_empty(): | |
215 | raise EmptyRepositoryError("There are no commits yet") |
|
218 | raise EmptyRepositoryError("There are no commits yet") | |
216 |
|
219 | |||
217 | if commit_id_or_idx in (None, '', 'tip', 'HEAD', 'head', -1): |
|
220 | if commit_id_or_idx in (None, '', 'tip', 'HEAD', 'head', -1): | |
218 | return self.commit_ids[-1] |
|
221 | return self.commit_ids[-1] | |
219 |
|
222 | |||
220 | is_bstr = isinstance(commit_id_or_idx, (str, unicode)) |
|
223 | is_bstr = isinstance(commit_id_or_idx, (str, unicode)) | |
221 | if ((is_bstr and commit_id_or_idx.isdigit() and len(commit_id_or_idx) < 12) |
|
224 | if ((is_bstr and commit_id_or_idx.isdigit() and len(commit_id_or_idx) < 12) | |
222 | or isinstance(commit_id_or_idx, int) or is_null(commit_id_or_idx)): |
|
225 | or isinstance(commit_id_or_idx, int) or is_null(commit_id_or_idx)): | |
223 | try: |
|
226 | try: | |
224 | commit_id_or_idx = self.commit_ids[int(commit_id_or_idx)] |
|
227 | commit_id_or_idx = self.commit_ids[int(commit_id_or_idx)] | |
225 | except Exception: |
|
228 | except Exception: | |
226 | msg = "Commit %s does not exist for %s" % ( |
|
229 | msg = "Commit %s does not exist for %s" % ( | |
227 | commit_id_or_idx, self) |
|
230 | commit_id_or_idx, self) | |
228 | raise CommitDoesNotExistError(msg) |
|
231 | raise CommitDoesNotExistError(msg) | |
229 |
|
232 | |||
230 | elif is_bstr: |
|
233 | elif is_bstr: | |
231 | # check full path ref, eg. refs/heads/master |
|
234 | # check full path ref, eg. refs/heads/master | |
232 | ref_id = self._refs.get(commit_id_or_idx) |
|
235 | ref_id = self._refs.get(commit_id_or_idx) | |
233 | if ref_id: |
|
236 | if ref_id: | |
234 | return ref_id |
|
237 | return ref_id | |
235 |
|
238 | |||
236 | # check branch name |
|
239 | # check branch name | |
237 | branch_ids = self.branches.values() |
|
240 | branch_ids = self.branches.values() | |
238 | ref_id = self._refs.get('refs/heads/%s' % commit_id_or_idx) |
|
241 | ref_id = self._refs.get('refs/heads/%s' % commit_id_or_idx) | |
239 | if ref_id: |
|
242 | if ref_id: | |
240 | return ref_id |
|
243 | return ref_id | |
241 |
|
244 | |||
242 | # check tag name |
|
245 | # check tag name | |
243 | ref_id = self._refs.get('refs/tags/%s' % commit_id_or_idx) |
|
246 | ref_id = self._refs.get('refs/tags/%s' % commit_id_or_idx) | |
244 | if ref_id: |
|
247 | if ref_id: | |
245 | return ref_id |
|
248 | return ref_id | |
246 |
|
249 | |||
247 | if (not SHA_PATTERN.match(commit_id_or_idx) or |
|
250 | if (not SHA_PATTERN.match(commit_id_or_idx) or | |
248 | commit_id_or_idx not in self.commit_ids): |
|
251 | commit_id_or_idx not in self.commit_ids): | |
249 | msg = "Commit %s does not exist for %s" % ( |
|
252 | msg = "Commit %s does not exist for %s" % ( | |
250 | commit_id_or_idx, self) |
|
253 | commit_id_or_idx, self) | |
251 | raise CommitDoesNotExistError(msg) |
|
254 | raise CommitDoesNotExistError(msg) | |
252 |
|
255 | |||
253 | # Ensure we return full id |
|
256 | # Ensure we return full id | |
254 | if not SHA_PATTERN.match(str(commit_id_or_idx)): |
|
257 | if not SHA_PATTERN.match(str(commit_id_or_idx)): | |
255 | raise CommitDoesNotExistError( |
|
258 | raise CommitDoesNotExistError( | |
256 | "Given commit id %s not recognized" % commit_id_or_idx) |
|
259 | "Given commit id %s not recognized" % commit_id_or_idx) | |
257 | return commit_id_or_idx |
|
260 | return commit_id_or_idx | |
258 |
|
261 | |||
259 | def get_hook_location(self): |
|
262 | def get_hook_location(self): | |
260 | """ |
|
263 | """ | |
261 | returns absolute path to location where hooks are stored |
|
264 | returns absolute path to location where hooks are stored | |
262 | """ |
|
265 | """ | |
263 | loc = os.path.join(self.path, 'hooks') |
|
266 | loc = os.path.join(self.path, 'hooks') | |
264 | if not self.bare: |
|
267 | if not self.bare: | |
265 | loc = os.path.join(self.path, '.git', 'hooks') |
|
268 | loc = os.path.join(self.path, '.git', 'hooks') | |
266 | return loc |
|
269 | return loc | |
267 |
|
270 | |||
268 | @LazyProperty |
|
271 | @LazyProperty | |
269 | def last_change(self): |
|
272 | def last_change(self): | |
270 | """ |
|
273 | """ | |
271 | Returns last change made on this repository as |
|
274 | Returns last change made on this repository as | |
272 | `datetime.datetime` object. |
|
275 | `datetime.datetime` object. | |
273 | """ |
|
276 | """ | |
274 | try: |
|
277 | try: | |
275 | return self.get_commit().date |
|
278 | return self.get_commit().date | |
276 | except RepositoryError: |
|
279 | except RepositoryError: | |
277 | tzoffset = makedate()[1] |
|
280 | tzoffset = makedate()[1] | |
278 | return utcdate_fromtimestamp(self._get_fs_mtime(), tzoffset) |
|
281 | return utcdate_fromtimestamp(self._get_fs_mtime(), tzoffset) | |
279 |
|
282 | |||
280 | def _get_fs_mtime(self): |
|
283 | def _get_fs_mtime(self): | |
281 | idx_loc = '' if self.bare else '.git' |
|
284 | idx_loc = '' if self.bare else '.git' | |
282 | # fallback to filesystem |
|
285 | # fallback to filesystem | |
283 | in_path = os.path.join(self.path, idx_loc, "index") |
|
286 | in_path = os.path.join(self.path, idx_loc, "index") | |
284 | he_path = os.path.join(self.path, idx_loc, "HEAD") |
|
287 | he_path = os.path.join(self.path, idx_loc, "HEAD") | |
285 | if os.path.exists(in_path): |
|
288 | if os.path.exists(in_path): | |
286 | return os.stat(in_path).st_mtime |
|
289 | return os.stat(in_path).st_mtime | |
287 | else: |
|
290 | else: | |
288 | return os.stat(he_path).st_mtime |
|
291 | return os.stat(he_path).st_mtime | |
289 |
|
292 | |||
290 | @LazyProperty |
|
293 | @LazyProperty | |
291 | def description(self): |
|
294 | def description(self): | |
292 | description = self._remote.get_description() |
|
295 | description = self._remote.get_description() | |
293 | return safe_unicode(description or self.DEFAULT_DESCRIPTION) |
|
296 | return safe_unicode(description or self.DEFAULT_DESCRIPTION) | |
294 |
|
297 | |||
295 | def _get_refs_entries(self, prefix='', reverse=False, strip_prefix=True): |
|
298 | def _get_refs_entries(self, prefix='', reverse=False, strip_prefix=True): | |
296 | if self.is_empty(): |
|
299 | if self.is_empty(): | |
297 | return OrderedDict() |
|
300 | return OrderedDict() | |
298 |
|
301 | |||
299 | result = [] |
|
302 | result = [] | |
300 | for ref, sha in self._refs.iteritems(): |
|
303 | for ref, sha in self._refs.iteritems(): | |
301 | if ref.startswith(prefix): |
|
304 | if ref.startswith(prefix): | |
302 | ref_name = ref |
|
305 | ref_name = ref | |
303 | if strip_prefix: |
|
306 | if strip_prefix: | |
304 | ref_name = ref[len(prefix):] |
|
307 | ref_name = ref[len(prefix):] | |
305 | result.append((safe_unicode(ref_name), sha)) |
|
308 | result.append((safe_unicode(ref_name), sha)) | |
306 |
|
309 | |||
307 | def get_name(entry): |
|
310 | def get_name(entry): | |
308 | return entry[0] |
|
311 | return entry[0] | |
309 |
|
312 | |||
310 | return OrderedDict(sorted(result, key=get_name, reverse=reverse)) |
|
313 | return OrderedDict(sorted(result, key=get_name, reverse=reverse)) | |
311 |
|
314 | |||
312 | def _get_branches(self): |
|
315 | def _get_branches(self): | |
313 | return self._get_refs_entries(prefix='refs/heads/', strip_prefix=True) |
|
316 | return self._get_refs_entries(prefix='refs/heads/', strip_prefix=True) | |
314 |
|
317 | |||
315 | @LazyProperty |
|
318 | @LazyProperty | |
316 | def branches(self): |
|
319 | def branches(self): | |
317 | return self._get_branches() |
|
320 | return self._get_branches() | |
318 |
|
321 | |||
319 | @LazyProperty |
|
322 | @LazyProperty | |
320 | def branches_closed(self): |
|
323 | def branches_closed(self): | |
321 | return {} |
|
324 | return {} | |
322 |
|
325 | |||
323 | @LazyProperty |
|
326 | @LazyProperty | |
324 | def bookmarks(self): |
|
327 | def bookmarks(self): | |
325 | return {} |
|
328 | return {} | |
326 |
|
329 | |||
327 | @LazyProperty |
|
330 | @LazyProperty | |
328 | def branches_all(self): |
|
331 | def branches_all(self): | |
329 | all_branches = {} |
|
332 | all_branches = {} | |
330 | all_branches.update(self.branches) |
|
333 | all_branches.update(self.branches) | |
331 | all_branches.update(self.branches_closed) |
|
334 | all_branches.update(self.branches_closed) | |
332 | return all_branches |
|
335 | return all_branches | |
333 |
|
336 | |||
334 | @LazyProperty |
|
337 | @LazyProperty | |
335 | def tags(self): |
|
338 | def tags(self): | |
336 | return self._get_tags() |
|
339 | return self._get_tags() | |
337 |
|
340 | |||
338 | def _get_tags(self): |
|
341 | def _get_tags(self): | |
339 | return self._get_refs_entries( |
|
342 | return self._get_refs_entries( | |
340 | prefix='refs/tags/', strip_prefix=True, reverse=True) |
|
343 | prefix='refs/tags/', strip_prefix=True, reverse=True) | |
341 |
|
344 | |||
342 | def tag(self, name, user, commit_id=None, message=None, date=None, |
|
345 | def tag(self, name, user, commit_id=None, message=None, date=None, | |
343 | **kwargs): |
|
346 | **kwargs): | |
344 | # TODO: fix this method to apply annotated tags correct with message |
|
347 | # TODO: fix this method to apply annotated tags correct with message | |
345 | """ |
|
348 | """ | |
346 | Creates and returns a tag for the given ``commit_id``. |
|
349 | Creates and returns a tag for the given ``commit_id``. | |
347 |
|
350 | |||
348 | :param name: name for new tag |
|
351 | :param name: name for new tag | |
349 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" |
|
352 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" | |
350 | :param commit_id: commit id for which new tag would be created |
|
353 | :param commit_id: commit id for which new tag would be created | |
351 | :param message: message of the tag's commit |
|
354 | :param message: message of the tag's commit | |
352 | :param date: date of tag's commit |
|
355 | :param date: date of tag's commit | |
353 |
|
356 | |||
354 | :raises TagAlreadyExistError: if tag with same name already exists |
|
357 | :raises TagAlreadyExistError: if tag with same name already exists | |
355 | """ |
|
358 | """ | |
356 | if name in self.tags: |
|
359 | if name in self.tags: | |
357 | raise TagAlreadyExistError("Tag %s already exists" % name) |
|
360 | raise TagAlreadyExistError("Tag %s already exists" % name) | |
358 | commit = self.get_commit(commit_id=commit_id) |
|
361 | commit = self.get_commit(commit_id=commit_id) | |
359 | message = message or "Added tag %s for commit %s" % ( |
|
362 | message = message or "Added tag %s for commit %s" % ( | |
360 | name, commit.raw_id) |
|
363 | name, commit.raw_id) | |
361 | self._remote.set_refs('refs/tags/%s' % name, commit._commit['id']) |
|
364 | self._remote.set_refs('refs/tags/%s' % name, commit._commit['id']) | |
362 |
|
365 | |||
363 | self._refs = self._get_refs() |
|
366 | self._refs = self._get_refs() | |
364 | self.tags = self._get_tags() |
|
367 | self.tags = self._get_tags() | |
365 | return commit |
|
368 | return commit | |
366 |
|
369 | |||
367 | def remove_tag(self, name, user, message=None, date=None): |
|
370 | def remove_tag(self, name, user, message=None, date=None): | |
368 | """ |
|
371 | """ | |
369 | Removes tag with the given ``name``. |
|
372 | Removes tag with the given ``name``. | |
370 |
|
373 | |||
371 | :param name: name of the tag to be removed |
|
374 | :param name: name of the tag to be removed | |
372 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" |
|
375 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" | |
373 | :param message: message of the tag's removal commit |
|
376 | :param message: message of the tag's removal commit | |
374 | :param date: date of tag's removal commit |
|
377 | :param date: date of tag's removal commit | |
375 |
|
378 | |||
376 | :raises TagDoesNotExistError: if tag with given name does not exists |
|
379 | :raises TagDoesNotExistError: if tag with given name does not exists | |
377 | """ |
|
380 | """ | |
378 | if name not in self.tags: |
|
381 | if name not in self.tags: | |
379 | raise TagDoesNotExistError("Tag %s does not exist" % name) |
|
382 | raise TagDoesNotExistError("Tag %s does not exist" % name) | |
380 | tagpath = vcspath.join( |
|
383 | tagpath = vcspath.join( | |
381 | self._remote.get_refs_path(), 'refs', 'tags', name) |
|
384 | self._remote.get_refs_path(), 'refs', 'tags', name) | |
382 | try: |
|
385 | try: | |
383 | os.remove(tagpath) |
|
386 | os.remove(tagpath) | |
384 | self._refs = self._get_refs() |
|
387 | self._refs = self._get_refs() | |
385 | self.tags = self._get_tags() |
|
388 | self.tags = self._get_tags() | |
386 | except OSError as e: |
|
389 | except OSError as e: | |
387 | raise RepositoryError(e.strerror) |
|
390 | raise RepositoryError(e.strerror) | |
388 |
|
391 | |||
389 | def _get_refs(self): |
|
392 | def _get_refs(self): | |
390 | return self._remote.get_refs() |
|
393 | return self._remote.get_refs() | |
391 |
|
394 | |||
392 | @LazyProperty |
|
395 | @LazyProperty | |
393 | def _refs(self): |
|
396 | def _refs(self): | |
394 | return self._get_refs() |
|
397 | return self._get_refs() | |
395 |
|
398 | |||
396 | @property |
|
399 | @property | |
397 | def _ref_tree(self): |
|
400 | def _ref_tree(self): | |
398 | node = tree = {} |
|
401 | node = tree = {} | |
399 | for ref, sha in self._refs.iteritems(): |
|
402 | for ref, sha in self._refs.iteritems(): | |
400 | path = ref.split('/') |
|
403 | path = ref.split('/') | |
401 | for bit in path[:-1]: |
|
404 | for bit in path[:-1]: | |
402 | node = node.setdefault(bit, {}) |
|
405 | node = node.setdefault(bit, {}) | |
403 | node[path[-1]] = sha |
|
406 | node[path[-1]] = sha | |
404 | node = tree |
|
407 | node = tree | |
405 | return tree |
|
408 | return tree | |
406 |
|
409 | |||
407 | def get_remote_ref(self, ref_name): |
|
410 | def get_remote_ref(self, ref_name): | |
408 | ref_key = 'refs/remotes/origin/{}'.format(safe_str(ref_name)) |
|
411 | ref_key = 'refs/remotes/origin/{}'.format(safe_str(ref_name)) | |
409 | try: |
|
412 | try: | |
410 | return self._refs[ref_key] |
|
413 | return self._refs[ref_key] | |
411 | except Exception: |
|
414 | except Exception: | |
412 | return |
|
415 | return | |
413 |
|
416 | |||
414 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): |
|
417 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): | |
415 | """ |
|
418 | """ | |
416 | Returns `GitCommit` object representing commit from git repository |
|
419 | Returns `GitCommit` object representing commit from git repository | |
417 | at the given `commit_id` or head (most recent commit) if None given. |
|
420 | at the given `commit_id` or head (most recent commit) if None given. | |
418 | """ |
|
421 | """ | |
419 | if commit_id is not None: |
|
422 | if commit_id is not None: | |
420 | self._validate_commit_id(commit_id) |
|
423 | self._validate_commit_id(commit_id) | |
421 | elif commit_idx is not None: |
|
424 | elif commit_idx is not None: | |
422 | self._validate_commit_idx(commit_idx) |
|
425 | self._validate_commit_idx(commit_idx) | |
423 | commit_id = commit_idx |
|
426 | commit_id = commit_idx | |
424 | commit_id = self._get_commit_id(commit_id) |
|
427 | commit_id = self._get_commit_id(commit_id) | |
425 | try: |
|
428 | try: | |
426 | # Need to call remote to translate id for tagging scenario |
|
429 | # Need to call remote to translate id for tagging scenario | |
427 | commit_id = self._remote.get_object(commit_id)["commit_id"] |
|
430 | commit_id = self._remote.get_object(commit_id)["commit_id"] | |
428 | idx = self._commit_ids[commit_id] |
|
431 | idx = self._commit_ids[commit_id] | |
429 | except KeyError: |
|
432 | except KeyError: | |
430 | raise RepositoryError("Cannot get object with id %s" % commit_id) |
|
433 | raise RepositoryError("Cannot get object with id %s" % commit_id) | |
431 |
|
434 | |||
432 | return GitCommit(self, commit_id, idx, pre_load=pre_load) |
|
435 | return GitCommit(self, commit_id, idx, pre_load=pre_load) | |
433 |
|
436 | |||
434 | def get_commits( |
|
437 | def get_commits( | |
435 | self, start_id=None, end_id=None, start_date=None, end_date=None, |
|
438 | self, start_id=None, end_id=None, start_date=None, end_date=None, | |
436 | branch_name=None, show_hidden=False, pre_load=None): |
|
439 | branch_name=None, show_hidden=False, pre_load=None): | |
437 | """ |
|
440 | """ | |
438 | Returns generator of `GitCommit` objects from start to end (both |
|
441 | Returns generator of `GitCommit` objects from start to end (both | |
439 | are inclusive), in ascending date order. |
|
442 | are inclusive), in ascending date order. | |
440 |
|
443 | |||
441 | :param start_id: None, str(commit_id) |
|
444 | :param start_id: None, str(commit_id) | |
442 | :param end_id: None, str(commit_id) |
|
445 | :param end_id: None, str(commit_id) | |
443 | :param start_date: if specified, commits with commit date less than |
|
446 | :param start_date: if specified, commits with commit date less than | |
444 | ``start_date`` would be filtered out from returned set |
|
447 | ``start_date`` would be filtered out from returned set | |
445 | :param end_date: if specified, commits with commit date greater than |
|
448 | :param end_date: if specified, commits with commit date greater than | |
446 | ``end_date`` would be filtered out from returned set |
|
449 | ``end_date`` would be filtered out from returned set | |
447 | :param branch_name: if specified, commits not reachable from given |
|
450 | :param branch_name: if specified, commits not reachable from given | |
448 | branch would be filtered out from returned set |
|
451 | branch would be filtered out from returned set | |
449 | :param show_hidden: Show hidden commits such as obsolete or hidden from |
|
452 | :param show_hidden: Show hidden commits such as obsolete or hidden from | |
450 | Mercurial evolve |
|
453 | Mercurial evolve | |
451 | :raise BranchDoesNotExistError: If given `branch_name` does not |
|
454 | :raise BranchDoesNotExistError: If given `branch_name` does not | |
452 | exist. |
|
455 | exist. | |
453 | :raise CommitDoesNotExistError: If commits for given `start` or |
|
456 | :raise CommitDoesNotExistError: If commits for given `start` or | |
454 | `end` could not be found. |
|
457 | `end` could not be found. | |
455 |
|
458 | |||
456 | """ |
|
459 | """ | |
457 | if self.is_empty(): |
|
460 | if self.is_empty(): | |
458 | raise EmptyRepositoryError("There are no commits yet") |
|
461 | raise EmptyRepositoryError("There are no commits yet") | |
459 | self._validate_branch_name(branch_name) |
|
462 | self._validate_branch_name(branch_name) | |
460 |
|
463 | |||
461 | if start_id is not None: |
|
464 | if start_id is not None: | |
462 | self._validate_commit_id(start_id) |
|
465 | self._validate_commit_id(start_id) | |
463 | if end_id is not None: |
|
466 | if end_id is not None: | |
464 | self._validate_commit_id(end_id) |
|
467 | self._validate_commit_id(end_id) | |
465 |
|
468 | |||
466 | start_raw_id = self._get_commit_id(start_id) |
|
469 | start_raw_id = self._get_commit_id(start_id) | |
467 | start_pos = self._commit_ids[start_raw_id] if start_id else None |
|
470 | start_pos = self._commit_ids[start_raw_id] if start_id else None | |
468 | end_raw_id = self._get_commit_id(end_id) |
|
471 | end_raw_id = self._get_commit_id(end_id) | |
469 | end_pos = max(0, self._commit_ids[end_raw_id]) if end_id else None |
|
472 | end_pos = max(0, self._commit_ids[end_raw_id]) if end_id else None | |
470 |
|
473 | |||
471 | if None not in [start_id, end_id] and start_pos > end_pos: |
|
474 | if None not in [start_id, end_id] and start_pos > end_pos: | |
472 | raise RepositoryError( |
|
475 | raise RepositoryError( | |
473 | "Start commit '%s' cannot be after end commit '%s'" % |
|
476 | "Start commit '%s' cannot be after end commit '%s'" % | |
474 | (start_id, end_id)) |
|
477 | (start_id, end_id)) | |
475 |
|
478 | |||
476 | if end_pos is not None: |
|
479 | if end_pos is not None: | |
477 | end_pos += 1 |
|
480 | end_pos += 1 | |
478 |
|
481 | |||
479 | filter_ = [] |
|
482 | filter_ = [] | |
480 | if branch_name: |
|
483 | if branch_name: | |
481 | filter_.append({'branch_name': branch_name}) |
|
484 | filter_.append({'branch_name': branch_name}) | |
482 | if start_date and not end_date: |
|
485 | if start_date and not end_date: | |
483 | filter_.append({'since': start_date}) |
|
486 | filter_.append({'since': start_date}) | |
484 | if end_date and not start_date: |
|
487 | if end_date and not start_date: | |
485 | filter_.append({'until': end_date}) |
|
488 | filter_.append({'until': end_date}) | |
486 | if start_date and end_date: |
|
489 | if start_date and end_date: | |
487 | filter_.append({'since': start_date}) |
|
490 | filter_.append({'since': start_date}) | |
488 | filter_.append({'until': end_date}) |
|
491 | filter_.append({'until': end_date}) | |
489 |
|
492 | |||
490 | # if start_pos or end_pos: |
|
493 | # if start_pos or end_pos: | |
491 | # filter_.append({'start': start_pos}) |
|
494 | # filter_.append({'start': start_pos}) | |
492 | # filter_.append({'end': end_pos}) |
|
495 | # filter_.append({'end': end_pos}) | |
493 |
|
496 | |||
494 | if filter_: |
|
497 | if filter_: | |
495 | revfilters = { |
|
498 | revfilters = { | |
496 | 'branch_name': branch_name, |
|
499 | 'branch_name': branch_name, | |
497 | 'since': start_date.strftime('%m/%d/%y %H:%M:%S') if start_date else None, |
|
500 | 'since': start_date.strftime('%m/%d/%y %H:%M:%S') if start_date else None, | |
498 | 'until': end_date.strftime('%m/%d/%y %H:%M:%S') if end_date else None, |
|
501 | 'until': end_date.strftime('%m/%d/%y %H:%M:%S') if end_date else None, | |
499 | 'start': start_pos, |
|
502 | 'start': start_pos, | |
500 | 'end': end_pos, |
|
503 | 'end': end_pos, | |
501 | } |
|
504 | } | |
502 | commit_ids = self._get_all_commit_ids(filters=revfilters) |
|
505 | commit_ids = self._get_all_commit_ids(filters=revfilters) | |
503 |
|
506 | |||
504 | # pure python stuff, it's slow due to walker walking whole repo |
|
507 | # pure python stuff, it's slow due to walker walking whole repo | |
505 | # def get_revs(walker): |
|
508 | # def get_revs(walker): | |
506 | # for walker_entry in walker: |
|
509 | # for walker_entry in walker: | |
507 | # yield walker_entry.commit.id |
|
510 | # yield walker_entry.commit.id | |
508 | # revfilters = {} |
|
511 | # revfilters = {} | |
509 | # commit_ids = list(reversed(list(get_revs(self._repo.get_walker(**revfilters))))) |
|
512 | # commit_ids = list(reversed(list(get_revs(self._repo.get_walker(**revfilters))))) | |
510 | else: |
|
513 | else: | |
511 | commit_ids = self.commit_ids |
|
514 | commit_ids = self.commit_ids | |
512 |
|
515 | |||
513 | if start_pos or end_pos: |
|
516 | if start_pos or end_pos: | |
514 | commit_ids = commit_ids[start_pos: end_pos] |
|
517 | commit_ids = commit_ids[start_pos: end_pos] | |
515 |
|
518 | |||
516 | return CollectionGenerator(self, commit_ids, pre_load=pre_load) |
|
519 | return CollectionGenerator(self, commit_ids, pre_load=pre_load) | |
517 |
|
520 | |||
518 | def get_diff( |
|
521 | def get_diff( | |
519 | self, commit1, commit2, path='', ignore_whitespace=False, |
|
522 | self, commit1, commit2, path='', ignore_whitespace=False, | |
520 | context=3, path1=None): |
|
523 | context=3, path1=None): | |
521 | """ |
|
524 | """ | |
522 | Returns (git like) *diff*, as plain text. Shows changes introduced by |
|
525 | Returns (git like) *diff*, as plain text. Shows changes introduced by | |
523 | ``commit2`` since ``commit1``. |
|
526 | ``commit2`` since ``commit1``. | |
524 |
|
527 | |||
525 | :param commit1: Entry point from which diff is shown. Can be |
|
528 | :param commit1: Entry point from which diff is shown. Can be | |
526 | ``self.EMPTY_COMMIT`` - in this case, patch showing all |
|
529 | ``self.EMPTY_COMMIT`` - in this case, patch showing all | |
527 | the changes since empty state of the repository until ``commit2`` |
|
530 | the changes since empty state of the repository until ``commit2`` | |
528 | :param commit2: Until which commits changes should be shown. |
|
531 | :param commit2: Until which commits changes should be shown. | |
529 | :param ignore_whitespace: If set to ``True``, would not show whitespace |
|
532 | :param ignore_whitespace: If set to ``True``, would not show whitespace | |
530 | changes. Defaults to ``False``. |
|
533 | changes. Defaults to ``False``. | |
531 | :param context: How many lines before/after changed lines should be |
|
534 | :param context: How many lines before/after changed lines should be | |
532 | shown. Defaults to ``3``. |
|
535 | shown. Defaults to ``3``. | |
533 | """ |
|
536 | """ | |
534 | self._validate_diff_commits(commit1, commit2) |
|
537 | self._validate_diff_commits(commit1, commit2) | |
535 | if path1 is not None and path1 != path: |
|
538 | if path1 is not None and path1 != path: | |
536 | raise ValueError("Diff of two different paths not supported.") |
|
539 | raise ValueError("Diff of two different paths not supported.") | |
537 |
|
540 | |||
538 | flags = [ |
|
541 | flags = [ | |
539 | '-U%s' % context, '--full-index', '--binary', '-p', |
|
542 | '-U%s' % context, '--full-index', '--binary', '-p', | |
540 | '-M', '--abbrev=40'] |
|
543 | '-M', '--abbrev=40'] | |
541 | if ignore_whitespace: |
|
544 | if ignore_whitespace: | |
542 | flags.append('-w') |
|
545 | flags.append('-w') | |
543 |
|
546 | |||
544 | if commit1 == self.EMPTY_COMMIT: |
|
547 | if commit1 == self.EMPTY_COMMIT: | |
545 | cmd = ['show'] + flags + [commit2.raw_id] |
|
548 | cmd = ['show'] + flags + [commit2.raw_id] | |
546 | else: |
|
549 | else: | |
547 | cmd = ['diff'] + flags + [commit1.raw_id, commit2.raw_id] |
|
550 | cmd = ['diff'] + flags + [commit1.raw_id, commit2.raw_id] | |
548 |
|
551 | |||
549 | if path: |
|
552 | if path: | |
550 | cmd.extend(['--', path]) |
|
553 | cmd.extend(['--', path]) | |
551 |
|
554 | |||
552 | stdout, __ = self.run_git_command(cmd) |
|
555 | stdout, __ = self.run_git_command(cmd) | |
553 | # If we used 'show' command, strip first few lines (until actual diff |
|
556 | # If we used 'show' command, strip first few lines (until actual diff | |
554 | # starts) |
|
557 | # starts) | |
555 | if commit1 == self.EMPTY_COMMIT: |
|
558 | if commit1 == self.EMPTY_COMMIT: | |
556 | lines = stdout.splitlines() |
|
559 | lines = stdout.splitlines() | |
557 | x = 0 |
|
560 | x = 0 | |
558 | for line in lines: |
|
561 | for line in lines: | |
559 | if line.startswith('diff'): |
|
562 | if line.startswith('diff'): | |
560 | break |
|
563 | break | |
561 | x += 1 |
|
564 | x += 1 | |
562 | # Append new line just like 'diff' command do |
|
565 | # Append new line just like 'diff' command do | |
563 | stdout = '\n'.join(lines[x:]) + '\n' |
|
566 | stdout = '\n'.join(lines[x:]) + '\n' | |
564 | return GitDiff(stdout) |
|
567 | return GitDiff(stdout) | |
565 |
|
568 | |||
566 | def strip(self, commit_id, branch_name): |
|
569 | def strip(self, commit_id, branch_name): | |
567 | commit = self.get_commit(commit_id=commit_id) |
|
570 | commit = self.get_commit(commit_id=commit_id) | |
568 | if commit.merge: |
|
571 | if commit.merge: | |
569 | raise Exception('Cannot reset to merge commit') |
|
572 | raise Exception('Cannot reset to merge commit') | |
570 |
|
573 | |||
571 | # parent is going to be the new head now |
|
574 | # parent is going to be the new head now | |
572 | commit = commit.parents[0] |
|
575 | commit = commit.parents[0] | |
573 | self._remote.set_refs('refs/heads/%s' % branch_name, commit.raw_id) |
|
576 | self._remote.set_refs('refs/heads/%s' % branch_name, commit.raw_id) | |
574 |
|
577 | |||
575 | self.commit_ids = self._get_all_commit_ids() |
|
578 | self.commit_ids = self._get_all_commit_ids() | |
576 | self._rebuild_cache(self.commit_ids) |
|
579 | self._rebuild_cache(self.commit_ids) | |
577 |
|
580 | |||
578 | def get_common_ancestor(self, commit_id1, commit_id2, repo2): |
|
581 | def get_common_ancestor(self, commit_id1, commit_id2, repo2): | |
579 | if commit_id1 == commit_id2: |
|
582 | if commit_id1 == commit_id2: | |
580 | return commit_id1 |
|
583 | return commit_id1 | |
581 |
|
584 | |||
582 | if self != repo2: |
|
585 | if self != repo2: | |
583 | commits = self._remote.get_missing_revs( |
|
586 | commits = self._remote.get_missing_revs( | |
584 | commit_id1, commit_id2, repo2.path) |
|
587 | commit_id1, commit_id2, repo2.path) | |
585 | if commits: |
|
588 | if commits: | |
586 | commit = repo2.get_commit(commits[-1]) |
|
589 | commit = repo2.get_commit(commits[-1]) | |
587 | if commit.parents: |
|
590 | if commit.parents: | |
588 | ancestor_id = commit.parents[0].raw_id |
|
591 | ancestor_id = commit.parents[0].raw_id | |
589 | else: |
|
592 | else: | |
590 | ancestor_id = None |
|
593 | ancestor_id = None | |
591 | else: |
|
594 | else: | |
592 | # no commits from other repo, ancestor_id is the commit_id2 |
|
595 | # no commits from other repo, ancestor_id is the commit_id2 | |
593 | ancestor_id = commit_id2 |
|
596 | ancestor_id = commit_id2 | |
594 | else: |
|
597 | else: | |
595 | output, __ = self.run_git_command( |
|
598 | output, __ = self.run_git_command( | |
596 | ['merge-base', commit_id1, commit_id2]) |
|
599 | ['merge-base', commit_id1, commit_id2]) | |
597 | ancestor_id = re.findall(r'[0-9a-fA-F]{40}', output)[0] |
|
600 | ancestor_id = re.findall(r'[0-9a-fA-F]{40}', output)[0] | |
598 |
|
601 | |||
599 | return ancestor_id |
|
602 | return ancestor_id | |
600 |
|
603 | |||
601 | def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None): |
|
604 | def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None): | |
602 | repo1 = self |
|
605 | repo1 = self | |
603 | ancestor_id = None |
|
606 | ancestor_id = None | |
604 |
|
607 | |||
605 | if commit_id1 == commit_id2: |
|
608 | if commit_id1 == commit_id2: | |
606 | commits = [] |
|
609 | commits = [] | |
607 | elif repo1 != repo2: |
|
610 | elif repo1 != repo2: | |
608 | missing_ids = self._remote.get_missing_revs(commit_id1, commit_id2, |
|
611 | missing_ids = self._remote.get_missing_revs(commit_id1, commit_id2, | |
609 | repo2.path) |
|
612 | repo2.path) | |
610 | commits = [ |
|
613 | commits = [ | |
611 | repo2.get_commit(commit_id=commit_id, pre_load=pre_load) |
|
614 | repo2.get_commit(commit_id=commit_id, pre_load=pre_load) | |
612 | for commit_id in reversed(missing_ids)] |
|
615 | for commit_id in reversed(missing_ids)] | |
613 | else: |
|
616 | else: | |
614 | output, __ = repo1.run_git_command( |
|
617 | output, __ = repo1.run_git_command( | |
615 | ['log', '--reverse', '--pretty=format: %H', '-s', |
|
618 | ['log', '--reverse', '--pretty=format: %H', '-s', | |
616 | '%s..%s' % (commit_id1, commit_id2)]) |
|
619 | '%s..%s' % (commit_id1, commit_id2)]) | |
617 | commits = [ |
|
620 | commits = [ | |
618 | repo1.get_commit(commit_id=commit_id, pre_load=pre_load) |
|
621 | repo1.get_commit(commit_id=commit_id, pre_load=pre_load) | |
619 | for commit_id in re.findall(r'[0-9a-fA-F]{40}', output)] |
|
622 | for commit_id in re.findall(r'[0-9a-fA-F]{40}', output)] | |
620 |
|
623 | |||
621 | return commits |
|
624 | return commits | |
622 |
|
625 | |||
623 | @LazyProperty |
|
626 | @LazyProperty | |
624 | def in_memory_commit(self): |
|
627 | def in_memory_commit(self): | |
625 | """ |
|
628 | """ | |
626 | Returns ``GitInMemoryCommit`` object for this repository. |
|
629 | Returns ``GitInMemoryCommit`` object for this repository. | |
627 | """ |
|
630 | """ | |
628 | return GitInMemoryCommit(self) |
|
631 | return GitInMemoryCommit(self) | |
629 |
|
632 | |||
630 | def clone(self, url, update_after_clone=True, bare=False): |
|
633 | def clone(self, url, update_after_clone=True, bare=False): | |
631 | """ |
|
634 | """ | |
632 | Tries to clone commits from external location. |
|
635 | Tries to clone commits from external location. | |
633 |
|
636 | |||
634 | :param update_after_clone: If set to ``False``, git won't checkout |
|
637 | :param update_after_clone: If set to ``False``, git won't checkout | |
635 | working directory |
|
638 | working directory | |
636 | :param bare: If set to ``True``, repository would be cloned into |
|
639 | :param bare: If set to ``True``, repository would be cloned into | |
637 | *bare* git repository (no working directory at all). |
|
640 | *bare* git repository (no working directory at all). | |
638 | """ |
|
641 | """ | |
639 | # init_bare and init expect empty dir created to proceed |
|
642 | # init_bare and init expect empty dir created to proceed | |
640 | if not os.path.exists(self.path): |
|
643 | if not os.path.exists(self.path): | |
641 | os.mkdir(self.path) |
|
644 | os.mkdir(self.path) | |
642 |
|
645 | |||
643 | if bare: |
|
646 | if bare: | |
644 | self._remote.init_bare() |
|
647 | self._remote.init_bare() | |
645 | else: |
|
648 | else: | |
646 | self._remote.init() |
|
649 | self._remote.init() | |
647 |
|
650 | |||
648 | deferred = '^{}' |
|
651 | deferred = '^{}' | |
649 | valid_refs = ('refs/heads', 'refs/tags', 'HEAD') |
|
652 | valid_refs = ('refs/heads', 'refs/tags', 'HEAD') | |
650 |
|
653 | |||
651 | return self._remote.clone( |
|
654 | return self._remote.clone( | |
652 | url, deferred, valid_refs, update_after_clone) |
|
655 | url, deferred, valid_refs, update_after_clone) | |
653 |
|
656 | |||
654 | def pull(self, url, commit_ids=None): |
|
657 | def pull(self, url, commit_ids=None): | |
655 | """ |
|
658 | """ | |
656 | Tries to pull changes from external location. We use fetch here since |
|
659 | Tries to pull changes from external location. We use fetch here since | |
657 | pull in get does merges and we want to be compatible with hg backend so |
|
660 | pull in get does merges and we want to be compatible with hg backend so | |
658 | pull == fetch in this case |
|
661 | pull == fetch in this case | |
659 | """ |
|
662 | """ | |
660 | self.fetch(url, commit_ids=commit_ids) |
|
663 | self.fetch(url, commit_ids=commit_ids) | |
661 |
|
664 | |||
662 | def fetch(self, url, commit_ids=None): |
|
665 | def fetch(self, url, commit_ids=None): | |
663 | """ |
|
666 | """ | |
664 | Tries to fetch changes from external location. |
|
667 | Tries to fetch changes from external location. | |
665 | """ |
|
668 | """ | |
666 | refs = None |
|
669 | refs = None | |
667 |
|
670 | |||
668 | if commit_ids is not None: |
|
671 | if commit_ids is not None: | |
669 | remote_refs = self._remote.get_remote_refs(url) |
|
672 | remote_refs = self._remote.get_remote_refs(url) | |
670 | refs = [ |
|
673 | refs = [ | |
671 | ref for ref in remote_refs if remote_refs[ref] in commit_ids] |
|
674 | ref for ref in remote_refs if remote_refs[ref] in commit_ids] | |
672 | self._remote.fetch(url, refs=refs) |
|
675 | self._remote.fetch(url, refs=refs) | |
673 |
|
676 | |||
674 | def push(self, url): |
|
677 | def push(self, url): | |
675 | refs = None |
|
678 | refs = None | |
676 | self._remote.sync_push(url, refs=refs) |
|
679 | self._remote.sync_push(url, refs=refs) | |
677 |
|
680 | |||
678 | def set_refs(self, ref_name, commit_id): |
|
681 | def set_refs(self, ref_name, commit_id): | |
679 | self._remote.set_refs(ref_name, commit_id) |
|
682 | self._remote.set_refs(ref_name, commit_id) | |
680 |
|
683 | |||
681 | def remove_ref(self, ref_name): |
|
684 | def remove_ref(self, ref_name): | |
682 | self._remote.remove_ref(ref_name) |
|
685 | self._remote.remove_ref(ref_name) | |
683 |
|
686 | |||
684 | def _update_server_info(self): |
|
687 | def _update_server_info(self): | |
685 | """ |
|
688 | """ | |
686 | runs gits update-server-info command in this repo instance |
|
689 | runs gits update-server-info command in this repo instance | |
687 | """ |
|
690 | """ | |
688 | self._remote.update_server_info() |
|
691 | self._remote.update_server_info() | |
689 |
|
692 | |||
690 | def _current_branch(self): |
|
693 | def _current_branch(self): | |
691 | """ |
|
694 | """ | |
692 | Return the name of the current branch. |
|
695 | Return the name of the current branch. | |
693 |
|
696 | |||
694 | It only works for non bare repositories (i.e. repositories with a |
|
697 | It only works for non bare repositories (i.e. repositories with a | |
695 | working copy) |
|
698 | working copy) | |
696 | """ |
|
699 | """ | |
697 | if self.bare: |
|
700 | if self.bare: | |
698 | raise RepositoryError('Bare git repos do not have active branches') |
|
701 | raise RepositoryError('Bare git repos do not have active branches') | |
699 |
|
702 | |||
700 | if self.is_empty(): |
|
703 | if self.is_empty(): | |
701 | return None |
|
704 | return None | |
702 |
|
705 | |||
703 | stdout, _ = self.run_git_command(['rev-parse', '--abbrev-ref', 'HEAD']) |
|
706 | stdout, _ = self.run_git_command(['rev-parse', '--abbrev-ref', 'HEAD']) | |
704 | return stdout.strip() |
|
707 | return stdout.strip() | |
705 |
|
708 | |||
706 | def _checkout(self, branch_name, create=False, force=False): |
|
709 | def _checkout(self, branch_name, create=False, force=False): | |
707 | """ |
|
710 | """ | |
708 | Checkout a branch in the working directory. |
|
711 | Checkout a branch in the working directory. | |
709 |
|
712 | |||
710 | It tries to create the branch if create is True, failing if the branch |
|
713 | It tries to create the branch if create is True, failing if the branch | |
711 | already exists. |
|
714 | already exists. | |
712 |
|
715 | |||
713 | It only works for non bare repositories (i.e. repositories with a |
|
716 | It only works for non bare repositories (i.e. repositories with a | |
714 | working copy) |
|
717 | working copy) | |
715 | """ |
|
718 | """ | |
716 | if self.bare: |
|
719 | if self.bare: | |
717 | raise RepositoryError('Cannot checkout branches in a bare git repo') |
|
720 | raise RepositoryError('Cannot checkout branches in a bare git repo') | |
718 |
|
721 | |||
719 | cmd = ['checkout'] |
|
722 | cmd = ['checkout'] | |
720 | if force: |
|
723 | if force: | |
721 | cmd.append('-f') |
|
724 | cmd.append('-f') | |
722 | if create: |
|
725 | if create: | |
723 | cmd.append('-b') |
|
726 | cmd.append('-b') | |
724 | cmd.append(branch_name) |
|
727 | cmd.append(branch_name) | |
725 | self.run_git_command(cmd, fail_on_stderr=False) |
|
728 | self.run_git_command(cmd, fail_on_stderr=False) | |
726 |
|
729 | |||
727 | def _identify(self): |
|
730 | def _identify(self): | |
728 | """ |
|
731 | """ | |
729 | Return the current state of the working directory. |
|
732 | Return the current state of the working directory. | |
730 | """ |
|
733 | """ | |
731 | if self.bare: |
|
734 | if self.bare: | |
732 | raise RepositoryError('Bare git repos do not have active branches') |
|
735 | raise RepositoryError('Bare git repos do not have active branches') | |
733 |
|
736 | |||
734 | if self.is_empty(): |
|
737 | if self.is_empty(): | |
735 | return None |
|
738 | return None | |
736 |
|
739 | |||
737 | stdout, _ = self.run_git_command(['rev-parse', 'HEAD']) |
|
740 | stdout, _ = self.run_git_command(['rev-parse', 'HEAD']) | |
738 | return stdout.strip() |
|
741 | return stdout.strip() | |
739 |
|
742 | |||
740 | def _local_clone(self, clone_path, branch_name, source_branch=None): |
|
743 | def _local_clone(self, clone_path, branch_name, source_branch=None): | |
741 | """ |
|
744 | """ | |
742 | Create a local clone of the current repo. |
|
745 | Create a local clone of the current repo. | |
743 | """ |
|
746 | """ | |
744 | # N.B.(skreft): the --branch option is required as otherwise the shallow |
|
747 | # N.B.(skreft): the --branch option is required as otherwise the shallow | |
745 | # clone will only fetch the active branch. |
|
748 | # clone will only fetch the active branch. | |
746 | cmd = ['clone', '--branch', branch_name, |
|
749 | cmd = ['clone', '--branch', branch_name, | |
747 | self.path, os.path.abspath(clone_path)] |
|
750 | self.path, os.path.abspath(clone_path)] | |
748 |
|
751 | |||
749 | self.run_git_command(cmd, fail_on_stderr=False) |
|
752 | self.run_git_command(cmd, fail_on_stderr=False) | |
750 |
|
753 | |||
751 | # if we get the different source branch, make sure we also fetch it for |
|
754 | # if we get the different source branch, make sure we also fetch it for | |
752 | # merge conditions |
|
755 | # merge conditions | |
753 | if source_branch and source_branch != branch_name: |
|
756 | if source_branch and source_branch != branch_name: | |
754 | # check if the ref exists. |
|
757 | # check if the ref exists. | |
755 | shadow_repo = GitRepository(os.path.abspath(clone_path)) |
|
758 | shadow_repo = GitRepository(os.path.abspath(clone_path)) | |
756 | if shadow_repo.get_remote_ref(source_branch): |
|
759 | if shadow_repo.get_remote_ref(source_branch): | |
757 | cmd = ['fetch', self.path, source_branch] |
|
760 | cmd = ['fetch', self.path, source_branch] | |
758 | self.run_git_command(cmd, fail_on_stderr=False) |
|
761 | self.run_git_command(cmd, fail_on_stderr=False) | |
759 |
|
762 | |||
760 | def _local_fetch(self, repository_path, branch_name, use_origin=False): |
|
763 | def _local_fetch(self, repository_path, branch_name, use_origin=False): | |
761 | """ |
|
764 | """ | |
762 | Fetch a branch from a local repository. |
|
765 | Fetch a branch from a local repository. | |
763 | """ |
|
766 | """ | |
764 | repository_path = os.path.abspath(repository_path) |
|
767 | repository_path = os.path.abspath(repository_path) | |
765 | if repository_path == self.path: |
|
768 | if repository_path == self.path: | |
766 | raise ValueError('Cannot fetch from the same repository') |
|
769 | raise ValueError('Cannot fetch from the same repository') | |
767 |
|
770 | |||
768 | if use_origin: |
|
771 | if use_origin: | |
769 | branch_name = '+{branch}:refs/heads/{branch}'.format( |
|
772 | branch_name = '+{branch}:refs/heads/{branch}'.format( | |
770 | branch=branch_name) |
|
773 | branch=branch_name) | |
771 |
|
774 | |||
772 | cmd = ['fetch', '--no-tags', '--update-head-ok', |
|
775 | cmd = ['fetch', '--no-tags', '--update-head-ok', | |
773 | repository_path, branch_name] |
|
776 | repository_path, branch_name] | |
774 | self.run_git_command(cmd, fail_on_stderr=False) |
|
777 | self.run_git_command(cmd, fail_on_stderr=False) | |
775 |
|
778 | |||
776 | def _local_reset(self, branch_name): |
|
779 | def _local_reset(self, branch_name): | |
777 | branch_name = '{}'.format(branch_name) |
|
780 | branch_name = '{}'.format(branch_name) | |
778 | cmd = ['reset', '--hard', branch_name] |
|
781 | cmd = ['reset', '--hard', branch_name] | |
779 | self.run_git_command(cmd, fail_on_stderr=False) |
|
782 | self.run_git_command(cmd, fail_on_stderr=False) | |
780 |
|
783 | |||
781 | def _last_fetch_heads(self): |
|
784 | def _last_fetch_heads(self): | |
782 | """ |
|
785 | """ | |
783 | Return the last fetched heads that need merging. |
|
786 | Return the last fetched heads that need merging. | |
784 |
|
787 | |||
785 | The algorithm is defined at |
|
788 | The algorithm is defined at | |
786 | https://github.com/git/git/blob/v2.1.3/git-pull.sh#L283 |
|
789 | https://github.com/git/git/blob/v2.1.3/git-pull.sh#L283 | |
787 | """ |
|
790 | """ | |
788 | if not self.bare: |
|
791 | if not self.bare: | |
789 | fetch_heads_path = os.path.join(self.path, '.git', 'FETCH_HEAD') |
|
792 | fetch_heads_path = os.path.join(self.path, '.git', 'FETCH_HEAD') | |
790 | else: |
|
793 | else: | |
791 | fetch_heads_path = os.path.join(self.path, 'FETCH_HEAD') |
|
794 | fetch_heads_path = os.path.join(self.path, 'FETCH_HEAD') | |
792 |
|
795 | |||
793 | heads = [] |
|
796 | heads = [] | |
794 | with open(fetch_heads_path) as f: |
|
797 | with open(fetch_heads_path) as f: | |
795 | for line in f: |
|
798 | for line in f: | |
796 | if ' not-for-merge ' in line: |
|
799 | if ' not-for-merge ' in line: | |
797 | continue |
|
800 | continue | |
798 | line = re.sub('\t.*', '', line, flags=re.DOTALL) |
|
801 | line = re.sub('\t.*', '', line, flags=re.DOTALL) | |
799 | heads.append(line) |
|
802 | heads.append(line) | |
800 |
|
803 | |||
801 | return heads |
|
804 | return heads | |
802 |
|
805 | |||
803 | def _get_shadow_instance(self, shadow_repository_path, enable_hooks=False): |
|
806 | def _get_shadow_instance(self, shadow_repository_path, enable_hooks=False): | |
804 | return GitRepository(shadow_repository_path) |
|
807 | return GitRepository(shadow_repository_path) | |
805 |
|
808 | |||
806 | def _local_pull(self, repository_path, branch_name, ff_only=True): |
|
809 | def _local_pull(self, repository_path, branch_name, ff_only=True): | |
807 | """ |
|
810 | """ | |
808 | Pull a branch from a local repository. |
|
811 | Pull a branch from a local repository. | |
809 | """ |
|
812 | """ | |
810 | if self.bare: |
|
813 | if self.bare: | |
811 | raise RepositoryError('Cannot pull into a bare git repository') |
|
814 | raise RepositoryError('Cannot pull into a bare git repository') | |
812 | # N.B.(skreft): The --ff-only option is to make sure this is a |
|
815 | # N.B.(skreft): The --ff-only option is to make sure this is a | |
813 | # fast-forward (i.e., we are only pulling new changes and there are no |
|
816 | # fast-forward (i.e., we are only pulling new changes and there are no | |
814 | # conflicts with our current branch) |
|
817 | # conflicts with our current branch) | |
815 | # Additionally, that option needs to go before --no-tags, otherwise git |
|
818 | # Additionally, that option needs to go before --no-tags, otherwise git | |
816 | # pull complains about it being an unknown flag. |
|
819 | # pull complains about it being an unknown flag. | |
817 | cmd = ['pull'] |
|
820 | cmd = ['pull'] | |
818 | if ff_only: |
|
821 | if ff_only: | |
819 | cmd.append('--ff-only') |
|
822 | cmd.append('--ff-only') | |
820 | cmd.extend(['--no-tags', repository_path, branch_name]) |
|
823 | cmd.extend(['--no-tags', repository_path, branch_name]) | |
821 | self.run_git_command(cmd, fail_on_stderr=False) |
|
824 | self.run_git_command(cmd, fail_on_stderr=False) | |
822 |
|
825 | |||
823 | def _local_merge(self, merge_message, user_name, user_email, heads): |
|
826 | def _local_merge(self, merge_message, user_name, user_email, heads): | |
824 | """ |
|
827 | """ | |
825 | Merge the given head into the checked out branch. |
|
828 | Merge the given head into the checked out branch. | |
826 |
|
829 | |||
827 | It will force a merge commit. |
|
830 | It will force a merge commit. | |
828 |
|
831 | |||
829 | Currently it raises an error if the repo is empty, as it is not possible |
|
832 | Currently it raises an error if the repo is empty, as it is not possible | |
830 | to create a merge commit in an empty repo. |
|
833 | to create a merge commit in an empty repo. | |
831 |
|
834 | |||
832 | :param merge_message: The message to use for the merge commit. |
|
835 | :param merge_message: The message to use for the merge commit. | |
833 | :param heads: the heads to merge. |
|
836 | :param heads: the heads to merge. | |
834 | """ |
|
837 | """ | |
835 | if self.bare: |
|
838 | if self.bare: | |
836 | raise RepositoryError('Cannot merge into a bare git repository') |
|
839 | raise RepositoryError('Cannot merge into a bare git repository') | |
837 |
|
840 | |||
838 | if not heads: |
|
841 | if not heads: | |
839 | return |
|
842 | return | |
840 |
|
843 | |||
841 | if self.is_empty(): |
|
844 | if self.is_empty(): | |
842 | # TODO(skreft): do somehting more robust in this case. |
|
845 | # TODO(skreft): do somehting more robust in this case. | |
843 | raise RepositoryError( |
|
846 | raise RepositoryError( | |
844 | 'Do not know how to merge into empty repositories yet') |
|
847 | 'Do not know how to merge into empty repositories yet') | |
845 |
|
848 | |||
846 | # N.B.(skreft): the --no-ff option is used to enforce the creation of a |
|
849 | # N.B.(skreft): the --no-ff option is used to enforce the creation of a | |
847 | # commit message. We also specify the user who is doing the merge. |
|
850 | # commit message. We also specify the user who is doing the merge. | |
848 | cmd = ['-c', 'user.name="%s"' % safe_str(user_name), |
|
851 | cmd = ['-c', 'user.name="%s"' % safe_str(user_name), | |
849 | '-c', 'user.email=%s' % safe_str(user_email), |
|
852 | '-c', 'user.email=%s' % safe_str(user_email), | |
850 | 'merge', '--no-ff', '-m', safe_str(merge_message)] |
|
853 | 'merge', '--no-ff', '-m', safe_str(merge_message)] | |
851 | cmd.extend(heads) |
|
854 | cmd.extend(heads) | |
852 | try: |
|
855 | try: | |
853 | output = self.run_git_command(cmd, fail_on_stderr=False) |
|
856 | output = self.run_git_command(cmd, fail_on_stderr=False) | |
854 | except RepositoryError: |
|
857 | except RepositoryError: | |
855 | # Cleanup any merge leftovers |
|
858 | # Cleanup any merge leftovers | |
856 | self.run_git_command(['merge', '--abort'], fail_on_stderr=False) |
|
859 | self.run_git_command(['merge', '--abort'], fail_on_stderr=False) | |
857 | raise |
|
860 | raise | |
858 |
|
861 | |||
859 | def _local_push( |
|
862 | def _local_push( | |
860 | self, source_branch, repository_path, target_branch, |
|
863 | self, source_branch, repository_path, target_branch, | |
861 | enable_hooks=False, rc_scm_data=None): |
|
864 | enable_hooks=False, rc_scm_data=None): | |
862 | """ |
|
865 | """ | |
863 | Push the source_branch to the given repository and target_branch. |
|
866 | Push the source_branch to the given repository and target_branch. | |
864 |
|
867 | |||
865 | Currently it if the target_branch is not master and the target repo is |
|
868 | Currently it if the target_branch is not master and the target repo is | |
866 | empty, the push will work, but then GitRepository won't be able to find |
|
869 | empty, the push will work, but then GitRepository won't be able to find | |
867 | the pushed branch or the commits. As the HEAD will be corrupted (i.e., |
|
870 | the pushed branch or the commits. As the HEAD will be corrupted (i.e., | |
868 | pointing to master, which does not exist). |
|
871 | pointing to master, which does not exist). | |
869 |
|
872 | |||
870 | It does not run the hooks in the target repo. |
|
873 | It does not run the hooks in the target repo. | |
871 | """ |
|
874 | """ | |
872 | # TODO(skreft): deal with the case in which the target repo is empty, |
|
875 | # TODO(skreft): deal with the case in which the target repo is empty, | |
873 | # and the target_branch is not master. |
|
876 | # and the target_branch is not master. | |
874 | target_repo = GitRepository(repository_path) |
|
877 | target_repo = GitRepository(repository_path) | |
875 | if (not target_repo.bare and |
|
878 | if (not target_repo.bare and | |
876 | target_repo._current_branch() == target_branch): |
|
879 | target_repo._current_branch() == target_branch): | |
877 | # Git prevents pushing to the checked out branch, so simulate it by |
|
880 | # Git prevents pushing to the checked out branch, so simulate it by | |
878 | # pulling into the target repository. |
|
881 | # pulling into the target repository. | |
879 | target_repo._local_pull(self.path, source_branch) |
|
882 | target_repo._local_pull(self.path, source_branch) | |
880 | else: |
|
883 | else: | |
881 | cmd = ['push', os.path.abspath(repository_path), |
|
884 | cmd = ['push', os.path.abspath(repository_path), | |
882 | '%s:%s' % (source_branch, target_branch)] |
|
885 | '%s:%s' % (source_branch, target_branch)] | |
883 | gitenv = {} |
|
886 | gitenv = {} | |
884 | if rc_scm_data: |
|
887 | if rc_scm_data: | |
885 | gitenv.update({'RC_SCM_DATA': rc_scm_data}) |
|
888 | gitenv.update({'RC_SCM_DATA': rc_scm_data}) | |
886 |
|
889 | |||
887 | if not enable_hooks: |
|
890 | if not enable_hooks: | |
888 | gitenv['RC_SKIP_HOOKS'] = '1' |
|
891 | gitenv['RC_SKIP_HOOKS'] = '1' | |
889 | self.run_git_command(cmd, fail_on_stderr=False, extra_env=gitenv) |
|
892 | self.run_git_command(cmd, fail_on_stderr=False, extra_env=gitenv) | |
890 |
|
893 | |||
891 | def _get_new_pr_branch(self, source_branch, target_branch): |
|
894 | def _get_new_pr_branch(self, source_branch, target_branch): | |
892 | prefix = 'pr_%s-%s_' % (source_branch, target_branch) |
|
895 | prefix = 'pr_%s-%s_' % (source_branch, target_branch) | |
893 | pr_branches = [] |
|
896 | pr_branches = [] | |
894 | for branch in self.branches: |
|
897 | for branch in self.branches: | |
895 | if branch.startswith(prefix): |
|
898 | if branch.startswith(prefix): | |
896 | pr_branches.append(int(branch[len(prefix):])) |
|
899 | pr_branches.append(int(branch[len(prefix):])) | |
897 |
|
900 | |||
898 | if not pr_branches: |
|
901 | if not pr_branches: | |
899 | branch_id = 0 |
|
902 | branch_id = 0 | |
900 | else: |
|
903 | else: | |
901 | branch_id = max(pr_branches) + 1 |
|
904 | branch_id = max(pr_branches) + 1 | |
902 |
|
905 | |||
903 | return '%s%d' % (prefix, branch_id) |
|
906 | return '%s%d' % (prefix, branch_id) | |
904 |
|
907 | |||
905 | def _maybe_prepare_merge_workspace( |
|
908 | def _maybe_prepare_merge_workspace( | |
906 | self, repo_id, workspace_id, target_ref, source_ref): |
|
909 | self, repo_id, workspace_id, target_ref, source_ref): | |
907 | shadow_repository_path = self._get_shadow_repository_path( |
|
910 | shadow_repository_path = self._get_shadow_repository_path( | |
908 | repo_id, workspace_id) |
|
911 | repo_id, workspace_id) | |
909 | if not os.path.exists(shadow_repository_path): |
|
912 | if not os.path.exists(shadow_repository_path): | |
910 | self._local_clone( |
|
913 | self._local_clone( | |
911 | shadow_repository_path, target_ref.name, source_ref.name) |
|
914 | shadow_repository_path, target_ref.name, source_ref.name) | |
912 | log.debug( |
|
915 | log.debug( | |
913 | 'Prepared shadow repository in %s', shadow_repository_path) |
|
916 | 'Prepared shadow repository in %s', shadow_repository_path) | |
914 |
|
917 | |||
915 | return shadow_repository_path |
|
918 | return shadow_repository_path | |
916 |
|
919 | |||
917 | def _merge_repo(self, repo_id, workspace_id, target_ref, |
|
920 | def _merge_repo(self, repo_id, workspace_id, target_ref, | |
918 | source_repo, source_ref, merge_message, |
|
921 | source_repo, source_ref, merge_message, | |
919 | merger_name, merger_email, dry_run=False, |
|
922 | merger_name, merger_email, dry_run=False, | |
920 | use_rebase=False, close_branch=False): |
|
923 | use_rebase=False, close_branch=False): | |
921 | if target_ref.commit_id != self.branches[target_ref.name]: |
|
924 | if target_ref.commit_id != self.branches[target_ref.name]: | |
922 | log.warning('Target ref %s commit mismatch %s vs %s', target_ref, |
|
925 | log.warning('Target ref %s commit mismatch %s vs %s', target_ref, | |
923 | target_ref.commit_id, self.branches[target_ref.name]) |
|
926 | target_ref.commit_id, self.branches[target_ref.name]) | |
924 | return MergeResponse( |
|
927 | return MergeResponse( | |
925 | False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD) |
|
928 | False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD) | |
926 |
|
929 | |||
927 | shadow_repository_path = self._maybe_prepare_merge_workspace( |
|
930 | shadow_repository_path = self._maybe_prepare_merge_workspace( | |
928 | repo_id, workspace_id, target_ref, source_ref) |
|
931 | repo_id, workspace_id, target_ref, source_ref) | |
929 | shadow_repo = self._get_shadow_instance(shadow_repository_path) |
|
932 | shadow_repo = self._get_shadow_instance(shadow_repository_path) | |
930 |
|
933 | |||
931 | # checkout source, if it's different. Otherwise we could not |
|
934 | # checkout source, if it's different. Otherwise we could not | |
932 | # fetch proper commits for merge testing |
|
935 | # fetch proper commits for merge testing | |
933 | if source_ref.name != target_ref.name: |
|
936 | if source_ref.name != target_ref.name: | |
934 | if shadow_repo.get_remote_ref(source_ref.name): |
|
937 | if shadow_repo.get_remote_ref(source_ref.name): | |
935 | shadow_repo._checkout(source_ref.name, force=True) |
|
938 | shadow_repo._checkout(source_ref.name, force=True) | |
936 |
|
939 | |||
937 | # checkout target, and fetch changes |
|
940 | # checkout target, and fetch changes | |
938 | shadow_repo._checkout(target_ref.name, force=True) |
|
941 | shadow_repo._checkout(target_ref.name, force=True) | |
939 |
|
942 | |||
940 | # fetch/reset pull the target, in case it is changed |
|
943 | # fetch/reset pull the target, in case it is changed | |
941 | # this handles even force changes |
|
944 | # this handles even force changes | |
942 | shadow_repo._local_fetch(self.path, target_ref.name, use_origin=True) |
|
945 | shadow_repo._local_fetch(self.path, target_ref.name, use_origin=True) | |
943 | shadow_repo._local_reset(target_ref.name) |
|
946 | shadow_repo._local_reset(target_ref.name) | |
944 |
|
947 | |||
945 | # Need to reload repo to invalidate the cache, or otherwise we cannot |
|
948 | # Need to reload repo to invalidate the cache, or otherwise we cannot | |
946 | # retrieve the last target commit. |
|
949 | # retrieve the last target commit. | |
947 | shadow_repo = self._get_shadow_instance(shadow_repository_path) |
|
950 | shadow_repo = self._get_shadow_instance(shadow_repository_path) | |
948 | if target_ref.commit_id != shadow_repo.branches[target_ref.name]: |
|
951 | if target_ref.commit_id != shadow_repo.branches[target_ref.name]: | |
949 | log.warning('Shadow Target ref %s commit mismatch %s vs %s', |
|
952 | log.warning('Shadow Target ref %s commit mismatch %s vs %s', | |
950 | target_ref, target_ref.commit_id, |
|
953 | target_ref, target_ref.commit_id, | |
951 | shadow_repo.branches[target_ref.name]) |
|
954 | shadow_repo.branches[target_ref.name]) | |
952 | return MergeResponse( |
|
955 | return MergeResponse( | |
953 | False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD) |
|
956 | False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD) | |
954 |
|
957 | |||
955 | # calculate new branch |
|
958 | # calculate new branch | |
956 | pr_branch = shadow_repo._get_new_pr_branch( |
|
959 | pr_branch = shadow_repo._get_new_pr_branch( | |
957 | source_ref.name, target_ref.name) |
|
960 | source_ref.name, target_ref.name) | |
958 | log.debug('using pull-request merge branch: `%s`', pr_branch) |
|
961 | log.debug('using pull-request merge branch: `%s`', pr_branch) | |
959 | # checkout to temp branch, and fetch changes |
|
962 | # checkout to temp branch, and fetch changes | |
960 | shadow_repo._checkout(pr_branch, create=True) |
|
963 | shadow_repo._checkout(pr_branch, create=True) | |
961 | try: |
|
964 | try: | |
962 | shadow_repo._local_fetch(source_repo.path, source_ref.name) |
|
965 | shadow_repo._local_fetch(source_repo.path, source_ref.name) | |
963 | except RepositoryError: |
|
966 | except RepositoryError: | |
964 | log.exception('Failure when doing local fetch on git shadow repo') |
|
967 | log.exception('Failure when doing local fetch on git shadow repo') | |
965 | return MergeResponse( |
|
968 | return MergeResponse( | |
966 | False, False, None, MergeFailureReason.MISSING_SOURCE_REF) |
|
969 | False, False, None, MergeFailureReason.MISSING_SOURCE_REF) | |
967 |
|
970 | |||
968 | merge_ref = None |
|
971 | merge_ref = None | |
969 | merge_failure_reason = MergeFailureReason.NONE |
|
972 | merge_failure_reason = MergeFailureReason.NONE | |
970 | try: |
|
973 | try: | |
971 | shadow_repo._local_merge(merge_message, merger_name, merger_email, |
|
974 | shadow_repo._local_merge(merge_message, merger_name, merger_email, | |
972 | [source_ref.commit_id]) |
|
975 | [source_ref.commit_id]) | |
973 | merge_possible = True |
|
976 | merge_possible = True | |
974 |
|
977 | |||
975 | # Need to reload repo to invalidate the cache, or otherwise we |
|
978 | # Need to reload repo to invalidate the cache, or otherwise we | |
976 | # cannot retrieve the merge commit. |
|
979 | # cannot retrieve the merge commit. | |
977 | shadow_repo = GitRepository(shadow_repository_path) |
|
980 | shadow_repo = GitRepository(shadow_repository_path) | |
978 | merge_commit_id = shadow_repo.branches[pr_branch] |
|
981 | merge_commit_id = shadow_repo.branches[pr_branch] | |
979 |
|
982 | |||
980 | # Set a reference pointing to the merge commit. This reference may |
|
983 | # Set a reference pointing to the merge commit. This reference may | |
981 | # be used to easily identify the last successful merge commit in |
|
984 | # be used to easily identify the last successful merge commit in | |
982 | # the shadow repository. |
|
985 | # the shadow repository. | |
983 | shadow_repo.set_refs('refs/heads/pr-merge', merge_commit_id) |
|
986 | shadow_repo.set_refs('refs/heads/pr-merge', merge_commit_id) | |
984 | merge_ref = Reference('branch', 'pr-merge', merge_commit_id) |
|
987 | merge_ref = Reference('branch', 'pr-merge', merge_commit_id) | |
985 | except RepositoryError: |
|
988 | except RepositoryError: | |
986 | log.exception('Failure when doing local merge on git shadow repo') |
|
989 | log.exception('Failure when doing local merge on git shadow repo') | |
987 | merge_possible = False |
|
990 | merge_possible = False | |
988 | merge_failure_reason = MergeFailureReason.MERGE_FAILED |
|
991 | merge_failure_reason = MergeFailureReason.MERGE_FAILED | |
989 |
|
992 | |||
990 | if merge_possible and not dry_run: |
|
993 | if merge_possible and not dry_run: | |
991 | try: |
|
994 | try: | |
992 | shadow_repo._local_push( |
|
995 | shadow_repo._local_push( | |
993 | pr_branch, self.path, target_ref.name, enable_hooks=True, |
|
996 | pr_branch, self.path, target_ref.name, enable_hooks=True, | |
994 | rc_scm_data=self.config.get('rhodecode', 'RC_SCM_DATA')) |
|
997 | rc_scm_data=self.config.get('rhodecode', 'RC_SCM_DATA')) | |
995 | merge_succeeded = True |
|
998 | merge_succeeded = True | |
996 | except RepositoryError: |
|
999 | except RepositoryError: | |
997 | log.exception( |
|
1000 | log.exception( | |
998 | 'Failure when doing local push on git shadow repo') |
|
1001 | 'Failure when doing local push on git shadow repo') | |
999 | merge_succeeded = False |
|
1002 | merge_succeeded = False | |
1000 | merge_failure_reason = MergeFailureReason.PUSH_FAILED |
|
1003 | merge_failure_reason = MergeFailureReason.PUSH_FAILED | |
1001 | else: |
|
1004 | else: | |
1002 | merge_succeeded = False |
|
1005 | merge_succeeded = False | |
1003 |
|
1006 | |||
1004 | return MergeResponse( |
|
1007 | return MergeResponse( | |
1005 | merge_possible, merge_succeeded, merge_ref, |
|
1008 | merge_possible, merge_succeeded, merge_ref, | |
1006 | merge_failure_reason) |
|
1009 | merge_failure_reason) |
@@ -1,915 +1,917 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 |
|
2 | |||
3 | # Copyright (C) 2014-2018 RhodeCode GmbH |
|
3 | # Copyright (C) 2014-2018 RhodeCode GmbH | |
4 | # |
|
4 | # | |
5 | # This program is free software: you can redistribute it and/or modify |
|
5 | # This program is free software: you can redistribute it and/or modify | |
6 | # it under the terms of the GNU Affero General Public License, version 3 |
|
6 | # it under the terms of the GNU Affero General Public License, version 3 | |
7 | # (only), as published by the Free Software Foundation. |
|
7 | # (only), as published by the Free Software Foundation. | |
8 | # |
|
8 | # | |
9 | # This program is distributed in the hope that it will be useful, |
|
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. |
|
12 | # GNU General Public License for more details. | |
13 | # |
|
13 | # | |
14 | # You should have received a copy of the GNU Affero General Public License |
|
14 | # You should have received a copy of the GNU Affero General Public License | |
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
16 | # |
|
16 | # | |
17 | # This program is dual-licensed. If you wish to learn more about the |
|
17 | # This program is dual-licensed. If you wish to learn more about the | |
18 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
18 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
20 |
|
20 | |||
21 | """ |
|
21 | """ | |
22 | HG repository module |
|
22 | HG repository module | |
23 | """ |
|
23 | """ | |
24 | import os |
|
24 | import os | |
25 | import logging |
|
25 | import logging | |
26 | import binascii |
|
26 | import binascii | |
27 | import urllib |
|
27 | import urllib | |
28 |
|
28 | |||
29 | from zope.cachedescriptors.property import Lazy as LazyProperty |
|
29 | from zope.cachedescriptors.property import Lazy as LazyProperty | |
30 |
|
30 | |||
31 | from rhodecode.lib.compat import OrderedDict |
|
31 | from rhodecode.lib.compat import OrderedDict | |
32 | from rhodecode.lib.datelib import ( |
|
32 | from rhodecode.lib.datelib import ( | |
33 | date_to_timestamp_plus_offset, utcdate_fromtimestamp, makedate) |
|
33 | date_to_timestamp_plus_offset, utcdate_fromtimestamp, makedate) | |
34 | from rhodecode.lib.utils import safe_unicode, safe_str |
|
34 | from rhodecode.lib.utils import safe_unicode, safe_str | |
35 | from rhodecode.lib.vcs import connection, exceptions |
|
35 | from rhodecode.lib.vcs import connection, exceptions | |
36 | from rhodecode.lib.vcs.backends.base import ( |
|
36 | from rhodecode.lib.vcs.backends.base import ( | |
37 | BaseRepository, CollectionGenerator, Config, MergeResponse, |
|
37 | BaseRepository, CollectionGenerator, Config, MergeResponse, | |
38 | MergeFailureReason, Reference, BasePathPermissionChecker) |
|
38 | MergeFailureReason, Reference, BasePathPermissionChecker) | |
39 | from rhodecode.lib.vcs.backends.hg.commit import MercurialCommit |
|
39 | from rhodecode.lib.vcs.backends.hg.commit import MercurialCommit | |
40 | from rhodecode.lib.vcs.backends.hg.diff import MercurialDiff |
|
40 | from rhodecode.lib.vcs.backends.hg.diff import MercurialDiff | |
41 | from rhodecode.lib.vcs.backends.hg.inmemory import MercurialInMemoryCommit |
|
41 | from rhodecode.lib.vcs.backends.hg.inmemory import MercurialInMemoryCommit | |
42 | from rhodecode.lib.vcs.exceptions import ( |
|
42 | from rhodecode.lib.vcs.exceptions import ( | |
43 | EmptyRepositoryError, RepositoryError, TagAlreadyExistError, |
|
43 | EmptyRepositoryError, RepositoryError, TagAlreadyExistError, | |
44 | TagDoesNotExistError, CommitDoesNotExistError, SubrepoMergeError) |
|
44 | TagDoesNotExistError, CommitDoesNotExistError, SubrepoMergeError) | |
45 | from rhodecode.lib.vcs.compat import configparser |
|
45 | from rhodecode.lib.vcs.compat import configparser | |
46 |
|
46 | |||
47 | hexlify = binascii.hexlify |
|
47 | hexlify = binascii.hexlify | |
48 | nullid = "\0" * 20 |
|
48 | nullid = "\0" * 20 | |
49 |
|
49 | |||
50 | log = logging.getLogger(__name__) |
|
50 | log = logging.getLogger(__name__) | |
51 |
|
51 | |||
52 |
|
52 | |||
53 | class MercurialRepository(BaseRepository): |
|
53 | class MercurialRepository(BaseRepository): | |
54 | """ |
|
54 | """ | |
55 | Mercurial repository backend |
|
55 | Mercurial repository backend | |
56 | """ |
|
56 | """ | |
57 | DEFAULT_BRANCH_NAME = 'default' |
|
57 | DEFAULT_BRANCH_NAME = 'default' | |
58 |
|
58 | |||
59 | def __init__(self, repo_path, config=None, create=False, src_url=None, |
|
59 | def __init__(self, repo_path, config=None, create=False, src_url=None, | |
60 | update_after_clone=False, with_wire=None): |
|
60 | update_after_clone=False, with_wire=None): | |
61 | """ |
|
61 | """ | |
62 | Raises RepositoryError if repository could not be find at the given |
|
62 | Raises RepositoryError if repository could not be find at the given | |
63 | ``repo_path``. |
|
63 | ``repo_path``. | |
64 |
|
64 | |||
65 | :param repo_path: local path of the repository |
|
65 | :param repo_path: local path of the repository | |
66 | :param config: config object containing the repo configuration |
|
66 | :param config: config object containing the repo configuration | |
67 | :param create=False: if set to True, would try to create repository if |
|
67 | :param create=False: if set to True, would try to create repository if | |
68 | it does not exist rather than raising exception |
|
68 | it does not exist rather than raising exception | |
69 | :param src_url=None: would try to clone repository from given location |
|
69 | :param src_url=None: would try to clone repository from given location | |
70 | :param update_after_clone=False: sets update of working copy after |
|
70 | :param update_after_clone=False: sets update of working copy after | |
71 | making a clone |
|
71 | making a clone | |
72 | """ |
|
72 | """ | |
73 |
|
73 | |||
74 | self.path = safe_str(os.path.abspath(repo_path)) |
|
74 | self.path = safe_str(os.path.abspath(repo_path)) | |
75 | # mercurial since 4.4.X requires certain configuration to be present |
|
75 | # mercurial since 4.4.X requires certain configuration to be present | |
76 | # because sometimes we init the repos with config we need to meet |
|
76 | # because sometimes we init the repos with config we need to meet | |
77 | # special requirements |
|
77 | # special requirements | |
78 | self.config = config if config else self.get_default_config( |
|
78 | self.config = config if config else self.get_default_config( | |
79 | default=[('extensions', 'largefiles', '1')]) |
|
79 | default=[('extensions', 'largefiles', '1')]) | |
80 |
|
80 | self.with_wire = with_wire | ||
81 | self._remote = connection.Hg( |
|
|||
82 | self.path, self.config, with_wire=with_wire) |
|
|||
83 |
|
81 | |||
84 | self._init_repo(create, src_url, update_after_clone) |
|
82 | self._init_repo(create, src_url, update_after_clone) | |
85 |
|
83 | |||
86 | # caches |
|
84 | # caches | |
87 | self._commit_ids = {} |
|
85 | self._commit_ids = {} | |
88 |
|
86 | |||
89 | @LazyProperty |
|
87 | @LazyProperty | |
|
88 | def _remote(self): | |||
|
89 | return connection.Hg(self.path, self.config, with_wire=self.with_wire) | |||
|
90 | ||||
|
91 | @LazyProperty | |||
90 | def commit_ids(self): |
|
92 | def commit_ids(self): | |
91 | """ |
|
93 | """ | |
92 | Returns list of commit ids, in ascending order. Being lazy |
|
94 | Returns list of commit ids, in ascending order. Being lazy | |
93 | attribute allows external tools to inject shas from cache. |
|
95 | attribute allows external tools to inject shas from cache. | |
94 | """ |
|
96 | """ | |
95 | commit_ids = self._get_all_commit_ids() |
|
97 | commit_ids = self._get_all_commit_ids() | |
96 | self._rebuild_cache(commit_ids) |
|
98 | self._rebuild_cache(commit_ids) | |
97 | return commit_ids |
|
99 | return commit_ids | |
98 |
|
100 | |||
99 | def _rebuild_cache(self, commit_ids): |
|
101 | def _rebuild_cache(self, commit_ids): | |
100 | self._commit_ids = dict((commit_id, index) |
|
102 | self._commit_ids = dict((commit_id, index) | |
101 | for index, commit_id in enumerate(commit_ids)) |
|
103 | for index, commit_id in enumerate(commit_ids)) | |
102 |
|
104 | |||
103 | @LazyProperty |
|
105 | @LazyProperty | |
104 | def branches(self): |
|
106 | def branches(self): | |
105 | return self._get_branches() |
|
107 | return self._get_branches() | |
106 |
|
108 | |||
107 | @LazyProperty |
|
109 | @LazyProperty | |
108 | def branches_closed(self): |
|
110 | def branches_closed(self): | |
109 | return self._get_branches(active=False, closed=True) |
|
111 | return self._get_branches(active=False, closed=True) | |
110 |
|
112 | |||
111 | @LazyProperty |
|
113 | @LazyProperty | |
112 | def branches_all(self): |
|
114 | def branches_all(self): | |
113 | all_branches = {} |
|
115 | all_branches = {} | |
114 | all_branches.update(self.branches) |
|
116 | all_branches.update(self.branches) | |
115 | all_branches.update(self.branches_closed) |
|
117 | all_branches.update(self.branches_closed) | |
116 | return all_branches |
|
118 | return all_branches | |
117 |
|
119 | |||
118 | def _get_branches(self, active=True, closed=False): |
|
120 | def _get_branches(self, active=True, closed=False): | |
119 | """ |
|
121 | """ | |
120 | Gets branches for this repository |
|
122 | Gets branches for this repository | |
121 | Returns only not closed active branches by default |
|
123 | Returns only not closed active branches by default | |
122 |
|
124 | |||
123 | :param active: return also active branches |
|
125 | :param active: return also active branches | |
124 | :param closed: return also closed branches |
|
126 | :param closed: return also closed branches | |
125 |
|
127 | |||
126 | """ |
|
128 | """ | |
127 | if self.is_empty(): |
|
129 | if self.is_empty(): | |
128 | return {} |
|
130 | return {} | |
129 |
|
131 | |||
130 | def get_name(ctx): |
|
132 | def get_name(ctx): | |
131 | return ctx[0] |
|
133 | return ctx[0] | |
132 |
|
134 | |||
133 | _branches = [(safe_unicode(n), hexlify(h),) for n, h in |
|
135 | _branches = [(safe_unicode(n), hexlify(h),) for n, h in | |
134 | self._remote.branches(active, closed).items()] |
|
136 | self._remote.branches(active, closed).items()] | |
135 |
|
137 | |||
136 | return OrderedDict(sorted(_branches, key=get_name, reverse=False)) |
|
138 | return OrderedDict(sorted(_branches, key=get_name, reverse=False)) | |
137 |
|
139 | |||
138 | @LazyProperty |
|
140 | @LazyProperty | |
139 | def tags(self): |
|
141 | def tags(self): | |
140 | """ |
|
142 | """ | |
141 | Gets tags for this repository |
|
143 | Gets tags for this repository | |
142 | """ |
|
144 | """ | |
143 | return self._get_tags() |
|
145 | return self._get_tags() | |
144 |
|
146 | |||
145 | def _get_tags(self): |
|
147 | def _get_tags(self): | |
146 | if self.is_empty(): |
|
148 | if self.is_empty(): | |
147 | return {} |
|
149 | return {} | |
148 |
|
150 | |||
149 | def get_name(ctx): |
|
151 | def get_name(ctx): | |
150 | return ctx[0] |
|
152 | return ctx[0] | |
151 |
|
153 | |||
152 | _tags = [(safe_unicode(n), hexlify(h),) for n, h in |
|
154 | _tags = [(safe_unicode(n), hexlify(h),) for n, h in | |
153 | self._remote.tags().items()] |
|
155 | self._remote.tags().items()] | |
154 |
|
156 | |||
155 | return OrderedDict(sorted(_tags, key=get_name, reverse=True)) |
|
157 | return OrderedDict(sorted(_tags, key=get_name, reverse=True)) | |
156 |
|
158 | |||
157 | def tag(self, name, user, commit_id=None, message=None, date=None, |
|
159 | def tag(self, name, user, commit_id=None, message=None, date=None, | |
158 | **kwargs): |
|
160 | **kwargs): | |
159 | """ |
|
161 | """ | |
160 | Creates and returns a tag for the given ``commit_id``. |
|
162 | Creates and returns a tag for the given ``commit_id``. | |
161 |
|
163 | |||
162 | :param name: name for new tag |
|
164 | :param name: name for new tag | |
163 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" |
|
165 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" | |
164 | :param commit_id: commit id for which new tag would be created |
|
166 | :param commit_id: commit id for which new tag would be created | |
165 | :param message: message of the tag's commit |
|
167 | :param message: message of the tag's commit | |
166 | :param date: date of tag's commit |
|
168 | :param date: date of tag's commit | |
167 |
|
169 | |||
168 | :raises TagAlreadyExistError: if tag with same name already exists |
|
170 | :raises TagAlreadyExistError: if tag with same name already exists | |
169 | """ |
|
171 | """ | |
170 | if name in self.tags: |
|
172 | if name in self.tags: | |
171 | raise TagAlreadyExistError("Tag %s already exists" % name) |
|
173 | raise TagAlreadyExistError("Tag %s already exists" % name) | |
172 | commit = self.get_commit(commit_id=commit_id) |
|
174 | commit = self.get_commit(commit_id=commit_id) | |
173 | local = kwargs.setdefault('local', False) |
|
175 | local = kwargs.setdefault('local', False) | |
174 |
|
176 | |||
175 | if message is None: |
|
177 | if message is None: | |
176 | message = "Added tag %s for commit %s" % (name, commit.short_id) |
|
178 | message = "Added tag %s for commit %s" % (name, commit.short_id) | |
177 |
|
179 | |||
178 | date, tz = date_to_timestamp_plus_offset(date) |
|
180 | date, tz = date_to_timestamp_plus_offset(date) | |
179 |
|
181 | |||
180 | self._remote.tag( |
|
182 | self._remote.tag( | |
181 | name, commit.raw_id, message, local, user, date, tz) |
|
183 | name, commit.raw_id, message, local, user, date, tz) | |
182 | self._remote.invalidate_vcs_cache() |
|
184 | self._remote.invalidate_vcs_cache() | |
183 |
|
185 | |||
184 | # Reinitialize tags |
|
186 | # Reinitialize tags | |
185 | self.tags = self._get_tags() |
|
187 | self.tags = self._get_tags() | |
186 | tag_id = self.tags[name] |
|
188 | tag_id = self.tags[name] | |
187 |
|
189 | |||
188 | return self.get_commit(commit_id=tag_id) |
|
190 | return self.get_commit(commit_id=tag_id) | |
189 |
|
191 | |||
190 | def remove_tag(self, name, user, message=None, date=None): |
|
192 | def remove_tag(self, name, user, message=None, date=None): | |
191 | """ |
|
193 | """ | |
192 | Removes tag with the given `name`. |
|
194 | Removes tag with the given `name`. | |
193 |
|
195 | |||
194 | :param name: name of the tag to be removed |
|
196 | :param name: name of the tag to be removed | |
195 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" |
|
197 | :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>" | |
196 | :param message: message of the tag's removal commit |
|
198 | :param message: message of the tag's removal commit | |
197 | :param date: date of tag's removal commit |
|
199 | :param date: date of tag's removal commit | |
198 |
|
200 | |||
199 | :raises TagDoesNotExistError: if tag with given name does not exists |
|
201 | :raises TagDoesNotExistError: if tag with given name does not exists | |
200 | """ |
|
202 | """ | |
201 | if name not in self.tags: |
|
203 | if name not in self.tags: | |
202 | raise TagDoesNotExistError("Tag %s does not exist" % name) |
|
204 | raise TagDoesNotExistError("Tag %s does not exist" % name) | |
203 | if message is None: |
|
205 | if message is None: | |
204 | message = "Removed tag %s" % name |
|
206 | message = "Removed tag %s" % name | |
205 | local = False |
|
207 | local = False | |
206 |
|
208 | |||
207 | date, tz = date_to_timestamp_plus_offset(date) |
|
209 | date, tz = date_to_timestamp_plus_offset(date) | |
208 |
|
210 | |||
209 | self._remote.tag(name, nullid, message, local, user, date, tz) |
|
211 | self._remote.tag(name, nullid, message, local, user, date, tz) | |
210 | self._remote.invalidate_vcs_cache() |
|
212 | self._remote.invalidate_vcs_cache() | |
211 | self.tags = self._get_tags() |
|
213 | self.tags = self._get_tags() | |
212 |
|
214 | |||
213 | @LazyProperty |
|
215 | @LazyProperty | |
214 | def bookmarks(self): |
|
216 | def bookmarks(self): | |
215 | """ |
|
217 | """ | |
216 | Gets bookmarks for this repository |
|
218 | Gets bookmarks for this repository | |
217 | """ |
|
219 | """ | |
218 | return self._get_bookmarks() |
|
220 | return self._get_bookmarks() | |
219 |
|
221 | |||
220 | def _get_bookmarks(self): |
|
222 | def _get_bookmarks(self): | |
221 | if self.is_empty(): |
|
223 | if self.is_empty(): | |
222 | return {} |
|
224 | return {} | |
223 |
|
225 | |||
224 | def get_name(ctx): |
|
226 | def get_name(ctx): | |
225 | return ctx[0] |
|
227 | return ctx[0] | |
226 |
|
228 | |||
227 | _bookmarks = [ |
|
229 | _bookmarks = [ | |
228 | (safe_unicode(n), hexlify(h)) for n, h in |
|
230 | (safe_unicode(n), hexlify(h)) for n, h in | |
229 | self._remote.bookmarks().items()] |
|
231 | self._remote.bookmarks().items()] | |
230 |
|
232 | |||
231 | return OrderedDict(sorted(_bookmarks, key=get_name)) |
|
233 | return OrderedDict(sorted(_bookmarks, key=get_name)) | |
232 |
|
234 | |||
233 | def _get_all_commit_ids(self): |
|
235 | def _get_all_commit_ids(self): | |
234 | return self._remote.get_all_commit_ids('visible') |
|
236 | return self._remote.get_all_commit_ids('visible') | |
235 |
|
237 | |||
236 | def get_diff( |
|
238 | def get_diff( | |
237 | self, commit1, commit2, path='', ignore_whitespace=False, |
|
239 | self, commit1, commit2, path='', ignore_whitespace=False, | |
238 | context=3, path1=None): |
|
240 | context=3, path1=None): | |
239 | """ |
|
241 | """ | |
240 | Returns (git like) *diff*, as plain text. Shows changes introduced by |
|
242 | Returns (git like) *diff*, as plain text. Shows changes introduced by | |
241 | `commit2` since `commit1`. |
|
243 | `commit2` since `commit1`. | |
242 |
|
244 | |||
243 | :param commit1: Entry point from which diff is shown. Can be |
|
245 | :param commit1: Entry point from which diff is shown. Can be | |
244 | ``self.EMPTY_COMMIT`` - in this case, patch showing all |
|
246 | ``self.EMPTY_COMMIT`` - in this case, patch showing all | |
245 | the changes since empty state of the repository until `commit2` |
|
247 | the changes since empty state of the repository until `commit2` | |
246 | :param commit2: Until which commit changes should be shown. |
|
248 | :param commit2: Until which commit changes should be shown. | |
247 | :param ignore_whitespace: If set to ``True``, would not show whitespace |
|
249 | :param ignore_whitespace: If set to ``True``, would not show whitespace | |
248 | changes. Defaults to ``False``. |
|
250 | changes. Defaults to ``False``. | |
249 | :param context: How many lines before/after changed lines should be |
|
251 | :param context: How many lines before/after changed lines should be | |
250 | shown. Defaults to ``3``. |
|
252 | shown. Defaults to ``3``. | |
251 | """ |
|
253 | """ | |
252 | self._validate_diff_commits(commit1, commit2) |
|
254 | self._validate_diff_commits(commit1, commit2) | |
253 | if path1 is not None and path1 != path: |
|
255 | if path1 is not None and path1 != path: | |
254 | raise ValueError("Diff of two different paths not supported.") |
|
256 | raise ValueError("Diff of two different paths not supported.") | |
255 |
|
257 | |||
256 | if path: |
|
258 | if path: | |
257 | file_filter = [self.path, path] |
|
259 | file_filter = [self.path, path] | |
258 | else: |
|
260 | else: | |
259 | file_filter = None |
|
261 | file_filter = None | |
260 |
|
262 | |||
261 | diff = self._remote.diff( |
|
263 | diff = self._remote.diff( | |
262 | commit1.raw_id, commit2.raw_id, file_filter=file_filter, |
|
264 | commit1.raw_id, commit2.raw_id, file_filter=file_filter, | |
263 | opt_git=True, opt_ignorews=ignore_whitespace, |
|
265 | opt_git=True, opt_ignorews=ignore_whitespace, | |
264 | context=context) |
|
266 | context=context) | |
265 | return MercurialDiff(diff) |
|
267 | return MercurialDiff(diff) | |
266 |
|
268 | |||
267 | def strip(self, commit_id, branch=None): |
|
269 | def strip(self, commit_id, branch=None): | |
268 | self._remote.strip(commit_id, update=False, backup="none") |
|
270 | self._remote.strip(commit_id, update=False, backup="none") | |
269 |
|
271 | |||
270 | self._remote.invalidate_vcs_cache() |
|
272 | self._remote.invalidate_vcs_cache() | |
271 | self.commit_ids = self._get_all_commit_ids() |
|
273 | self.commit_ids = self._get_all_commit_ids() | |
272 | self._rebuild_cache(self.commit_ids) |
|
274 | self._rebuild_cache(self.commit_ids) | |
273 |
|
275 | |||
274 | def verify(self): |
|
276 | def verify(self): | |
275 | verify = self._remote.verify() |
|
277 | verify = self._remote.verify() | |
276 |
|
278 | |||
277 | self._remote.invalidate_vcs_cache() |
|
279 | self._remote.invalidate_vcs_cache() | |
278 | return verify |
|
280 | return verify | |
279 |
|
281 | |||
280 | def get_common_ancestor(self, commit_id1, commit_id2, repo2): |
|
282 | def get_common_ancestor(self, commit_id1, commit_id2, repo2): | |
281 | if commit_id1 == commit_id2: |
|
283 | if commit_id1 == commit_id2: | |
282 | return commit_id1 |
|
284 | return commit_id1 | |
283 |
|
285 | |||
284 | ancestors = self._remote.revs_from_revspec( |
|
286 | ancestors = self._remote.revs_from_revspec( | |
285 | "ancestor(id(%s), id(%s))", commit_id1, commit_id2, |
|
287 | "ancestor(id(%s), id(%s))", commit_id1, commit_id2, | |
286 | other_path=repo2.path) |
|
288 | other_path=repo2.path) | |
287 | return repo2[ancestors[0]].raw_id if ancestors else None |
|
289 | return repo2[ancestors[0]].raw_id if ancestors else None | |
288 |
|
290 | |||
289 | def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None): |
|
291 | def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None): | |
290 | if commit_id1 == commit_id2: |
|
292 | if commit_id1 == commit_id2: | |
291 | commits = [] |
|
293 | commits = [] | |
292 | else: |
|
294 | else: | |
293 | if merge: |
|
295 | if merge: | |
294 | indexes = self._remote.revs_from_revspec( |
|
296 | indexes = self._remote.revs_from_revspec( | |
295 | "ancestors(id(%s)) - ancestors(id(%s)) - id(%s)", |
|
297 | "ancestors(id(%s)) - ancestors(id(%s)) - id(%s)", | |
296 | commit_id2, commit_id1, commit_id1, other_path=repo2.path) |
|
298 | commit_id2, commit_id1, commit_id1, other_path=repo2.path) | |
297 | else: |
|
299 | else: | |
298 | indexes = self._remote.revs_from_revspec( |
|
300 | indexes = self._remote.revs_from_revspec( | |
299 | "id(%s)..id(%s) - id(%s)", commit_id1, commit_id2, |
|
301 | "id(%s)..id(%s) - id(%s)", commit_id1, commit_id2, | |
300 | commit_id1, other_path=repo2.path) |
|
302 | commit_id1, other_path=repo2.path) | |
301 |
|
303 | |||
302 | commits = [repo2.get_commit(commit_idx=idx, pre_load=pre_load) |
|
304 | commits = [repo2.get_commit(commit_idx=idx, pre_load=pre_load) | |
303 | for idx in indexes] |
|
305 | for idx in indexes] | |
304 |
|
306 | |||
305 | return commits |
|
307 | return commits | |
306 |
|
308 | |||
307 | @staticmethod |
|
309 | @staticmethod | |
308 | def check_url(url, config): |
|
310 | def check_url(url, config): | |
309 | """ |
|
311 | """ | |
310 | Function will check given url and try to verify if it's a valid |
|
312 | Function will check given url and try to verify if it's a valid | |
311 | link. Sometimes it may happened that mercurial will issue basic |
|
313 | link. Sometimes it may happened that mercurial will issue basic | |
312 | auth request that can cause whole API to hang when used from python |
|
314 | auth request that can cause whole API to hang when used from python | |
313 | or other external calls. |
|
315 | or other external calls. | |
314 |
|
316 | |||
315 | On failures it'll raise urllib2.HTTPError, exception is also thrown |
|
317 | On failures it'll raise urllib2.HTTPError, exception is also thrown | |
316 | when the return code is non 200 |
|
318 | when the return code is non 200 | |
317 | """ |
|
319 | """ | |
318 | # check first if it's not an local url |
|
320 | # check first if it's not an local url | |
319 | if os.path.isdir(url) or url.startswith('file:'): |
|
321 | if os.path.isdir(url) or url.startswith('file:'): | |
320 | return True |
|
322 | return True | |
321 |
|
323 | |||
322 | # Request the _remote to verify the url |
|
324 | # Request the _remote to verify the url | |
323 | return connection.Hg.check_url(url, config.serialize()) |
|
325 | return connection.Hg.check_url(url, config.serialize()) | |
324 |
|
326 | |||
325 | @staticmethod |
|
327 | @staticmethod | |
326 | def is_valid_repository(path): |
|
328 | def is_valid_repository(path): | |
327 | return os.path.isdir(os.path.join(path, '.hg')) |
|
329 | return os.path.isdir(os.path.join(path, '.hg')) | |
328 |
|
330 | |||
329 | def _init_repo(self, create, src_url=None, update_after_clone=False): |
|
331 | def _init_repo(self, create, src_url=None, update_after_clone=False): | |
330 | """ |
|
332 | """ | |
331 | Function will check for mercurial repository in given path. If there |
|
333 | Function will check for mercurial repository in given path. If there | |
332 | is no repository in that path it will raise an exception unless |
|
334 | is no repository in that path it will raise an exception unless | |
333 | `create` parameter is set to True - in that case repository would |
|
335 | `create` parameter is set to True - in that case repository would | |
334 | be created. |
|
336 | be created. | |
335 |
|
337 | |||
336 | If `src_url` is given, would try to clone repository from the |
|
338 | If `src_url` is given, would try to clone repository from the | |
337 | location at given clone_point. Additionally it'll make update to |
|
339 | location at given clone_point. Additionally it'll make update to | |
338 | working copy accordingly to `update_after_clone` flag. |
|
340 | working copy accordingly to `update_after_clone` flag. | |
339 | """ |
|
341 | """ | |
340 | if create and os.path.exists(self.path): |
|
342 | if create and os.path.exists(self.path): | |
341 | raise RepositoryError( |
|
343 | raise RepositoryError( | |
342 | "Cannot create repository at %s, location already exist" |
|
344 | "Cannot create repository at %s, location already exist" | |
343 | % self.path) |
|
345 | % self.path) | |
344 |
|
346 | |||
345 | if src_url: |
|
347 | if src_url: | |
346 | url = str(self._get_url(src_url)) |
|
348 | url = str(self._get_url(src_url)) | |
347 | MercurialRepository.check_url(url, self.config) |
|
349 | MercurialRepository.check_url(url, self.config) | |
348 |
|
350 | |||
349 | self._remote.clone(url, self.path, update_after_clone) |
|
351 | self._remote.clone(url, self.path, update_after_clone) | |
350 |
|
352 | |||
351 | # Don't try to create if we've already cloned repo |
|
353 | # Don't try to create if we've already cloned repo | |
352 | create = False |
|
354 | create = False | |
353 |
|
355 | |||
354 | if create: |
|
356 | if create: | |
355 | os.makedirs(self.path, mode=0755) |
|
357 | os.makedirs(self.path, mode=0755) | |
356 |
|
358 | |||
357 | self._remote.localrepository(create) |
|
359 | self._remote.localrepository(create) | |
358 |
|
360 | |||
359 | @LazyProperty |
|
361 | @LazyProperty | |
360 | def in_memory_commit(self): |
|
362 | def in_memory_commit(self): | |
361 | return MercurialInMemoryCommit(self) |
|
363 | return MercurialInMemoryCommit(self) | |
362 |
|
364 | |||
363 | @LazyProperty |
|
365 | @LazyProperty | |
364 | def description(self): |
|
366 | def description(self): | |
365 | description = self._remote.get_config_value( |
|
367 | description = self._remote.get_config_value( | |
366 | 'web', 'description', untrusted=True) |
|
368 | 'web', 'description', untrusted=True) | |
367 | return safe_unicode(description or self.DEFAULT_DESCRIPTION) |
|
369 | return safe_unicode(description or self.DEFAULT_DESCRIPTION) | |
368 |
|
370 | |||
369 | @LazyProperty |
|
371 | @LazyProperty | |
370 | def contact(self): |
|
372 | def contact(self): | |
371 | contact = ( |
|
373 | contact = ( | |
372 | self._remote.get_config_value("web", "contact") or |
|
374 | self._remote.get_config_value("web", "contact") or | |
373 | self._remote.get_config_value("ui", "username")) |
|
375 | self._remote.get_config_value("ui", "username")) | |
374 | return safe_unicode(contact or self.DEFAULT_CONTACT) |
|
376 | return safe_unicode(contact or self.DEFAULT_CONTACT) | |
375 |
|
377 | |||
376 | @LazyProperty |
|
378 | @LazyProperty | |
377 | def last_change(self): |
|
379 | def last_change(self): | |
378 | """ |
|
380 | """ | |
379 | Returns last change made on this repository as |
|
381 | Returns last change made on this repository as | |
380 | `datetime.datetime` object. |
|
382 | `datetime.datetime` object. | |
381 | """ |
|
383 | """ | |
382 | try: |
|
384 | try: | |
383 | return self.get_commit().date |
|
385 | return self.get_commit().date | |
384 | except RepositoryError: |
|
386 | except RepositoryError: | |
385 | tzoffset = makedate()[1] |
|
387 | tzoffset = makedate()[1] | |
386 | return utcdate_fromtimestamp(self._get_fs_mtime(), tzoffset) |
|
388 | return utcdate_fromtimestamp(self._get_fs_mtime(), tzoffset) | |
387 |
|
389 | |||
388 | def _get_fs_mtime(self): |
|
390 | def _get_fs_mtime(self): | |
389 | # fallback to filesystem |
|
391 | # fallback to filesystem | |
390 | cl_path = os.path.join(self.path, '.hg', "00changelog.i") |
|
392 | cl_path = os.path.join(self.path, '.hg', "00changelog.i") | |
391 | st_path = os.path.join(self.path, '.hg', "store") |
|
393 | st_path = os.path.join(self.path, '.hg', "store") | |
392 | if os.path.exists(cl_path): |
|
394 | if os.path.exists(cl_path): | |
393 | return os.stat(cl_path).st_mtime |
|
395 | return os.stat(cl_path).st_mtime | |
394 | else: |
|
396 | else: | |
395 | return os.stat(st_path).st_mtime |
|
397 | return os.stat(st_path).st_mtime | |
396 |
|
398 | |||
397 | def _get_url(self, url): |
|
399 | def _get_url(self, url): | |
398 | """ |
|
400 | """ | |
399 | Returns normalized url. If schema is not given, would fall |
|
401 | Returns normalized url. If schema is not given, would fall | |
400 | to filesystem |
|
402 | to filesystem | |
401 | (``file:///``) schema. |
|
403 | (``file:///``) schema. | |
402 | """ |
|
404 | """ | |
403 | url = url.encode('utf8') |
|
405 | url = url.encode('utf8') | |
404 | if url != 'default' and '://' not in url: |
|
406 | if url != 'default' and '://' not in url: | |
405 | url = "file:" + urllib.pathname2url(url) |
|
407 | url = "file:" + urllib.pathname2url(url) | |
406 | return url |
|
408 | return url | |
407 |
|
409 | |||
408 | def get_hook_location(self): |
|
410 | def get_hook_location(self): | |
409 | """ |
|
411 | """ | |
410 | returns absolute path to location where hooks are stored |
|
412 | returns absolute path to location where hooks are stored | |
411 | """ |
|
413 | """ | |
412 | return os.path.join(self.path, '.hg', '.hgrc') |
|
414 | return os.path.join(self.path, '.hg', '.hgrc') | |
413 |
|
415 | |||
414 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): |
|
416 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): | |
415 | """ |
|
417 | """ | |
416 | Returns ``MercurialCommit`` object representing repository's |
|
418 | Returns ``MercurialCommit`` object representing repository's | |
417 | commit at the given `commit_id` or `commit_idx`. |
|
419 | commit at the given `commit_id` or `commit_idx`. | |
418 | """ |
|
420 | """ | |
419 | if self.is_empty(): |
|
421 | if self.is_empty(): | |
420 | raise EmptyRepositoryError("There are no commits yet") |
|
422 | raise EmptyRepositoryError("There are no commits yet") | |
421 |
|
423 | |||
422 | if commit_id is not None: |
|
424 | if commit_id is not None: | |
423 | self._validate_commit_id(commit_id) |
|
425 | self._validate_commit_id(commit_id) | |
424 | try: |
|
426 | try: | |
425 | idx = self._commit_ids[commit_id] |
|
427 | idx = self._commit_ids[commit_id] | |
426 | return MercurialCommit(self, commit_id, idx, pre_load=pre_load) |
|
428 | return MercurialCommit(self, commit_id, idx, pre_load=pre_load) | |
427 | except KeyError: |
|
429 | except KeyError: | |
428 | pass |
|
430 | pass | |
429 | elif commit_idx is not None: |
|
431 | elif commit_idx is not None: | |
430 | self._validate_commit_idx(commit_idx) |
|
432 | self._validate_commit_idx(commit_idx) | |
431 | try: |
|
433 | try: | |
432 | id_ = self.commit_ids[commit_idx] |
|
434 | id_ = self.commit_ids[commit_idx] | |
433 | if commit_idx < 0: |
|
435 | if commit_idx < 0: | |
434 | commit_idx += len(self.commit_ids) |
|
436 | commit_idx += len(self.commit_ids) | |
435 | return MercurialCommit( |
|
437 | return MercurialCommit( | |
436 | self, id_, commit_idx, pre_load=pre_load) |
|
438 | self, id_, commit_idx, pre_load=pre_load) | |
437 | except IndexError: |
|
439 | except IndexError: | |
438 | commit_id = commit_idx |
|
440 | commit_id = commit_idx | |
439 | else: |
|
441 | else: | |
440 | commit_id = "tip" |
|
442 | commit_id = "tip" | |
441 |
|
443 | |||
442 | if isinstance(commit_id, unicode): |
|
444 | if isinstance(commit_id, unicode): | |
443 | commit_id = safe_str(commit_id) |
|
445 | commit_id = safe_str(commit_id) | |
444 |
|
446 | |||
445 | try: |
|
447 | try: | |
446 | raw_id, idx = self._remote.lookup(commit_id, both=True) |
|
448 | raw_id, idx = self._remote.lookup(commit_id, both=True) | |
447 | except CommitDoesNotExistError: |
|
449 | except CommitDoesNotExistError: | |
448 | msg = "Commit %s does not exist for %s" % ( |
|
450 | msg = "Commit %s does not exist for %s" % ( | |
449 | commit_id, self) |
|
451 | commit_id, self) | |
450 | raise CommitDoesNotExistError(msg) |
|
452 | raise CommitDoesNotExistError(msg) | |
451 |
|
453 | |||
452 | return MercurialCommit(self, raw_id, idx, pre_load=pre_load) |
|
454 | return MercurialCommit(self, raw_id, idx, pre_load=pre_load) | |
453 |
|
455 | |||
454 | def get_commits( |
|
456 | def get_commits( | |
455 | self, start_id=None, end_id=None, start_date=None, end_date=None, |
|
457 | self, start_id=None, end_id=None, start_date=None, end_date=None, | |
456 | branch_name=None, show_hidden=False, pre_load=None): |
|
458 | branch_name=None, show_hidden=False, pre_load=None): | |
457 | """ |
|
459 | """ | |
458 | Returns generator of ``MercurialCommit`` objects from start to end |
|
460 | Returns generator of ``MercurialCommit`` objects from start to end | |
459 | (both are inclusive) |
|
461 | (both are inclusive) | |
460 |
|
462 | |||
461 | :param start_id: None, str(commit_id) |
|
463 | :param start_id: None, str(commit_id) | |
462 | :param end_id: None, str(commit_id) |
|
464 | :param end_id: None, str(commit_id) | |
463 | :param start_date: if specified, commits with commit date less than |
|
465 | :param start_date: if specified, commits with commit date less than | |
464 | ``start_date`` would be filtered out from returned set |
|
466 | ``start_date`` would be filtered out from returned set | |
465 | :param end_date: if specified, commits with commit date greater than |
|
467 | :param end_date: if specified, commits with commit date greater than | |
466 | ``end_date`` would be filtered out from returned set |
|
468 | ``end_date`` would be filtered out from returned set | |
467 | :param branch_name: if specified, commits not reachable from given |
|
469 | :param branch_name: if specified, commits not reachable from given | |
468 | branch would be filtered out from returned set |
|
470 | branch would be filtered out from returned set | |
469 | :param show_hidden: Show hidden commits such as obsolete or hidden from |
|
471 | :param show_hidden: Show hidden commits such as obsolete or hidden from | |
470 | Mercurial evolve |
|
472 | Mercurial evolve | |
471 | :raise BranchDoesNotExistError: If given ``branch_name`` does not |
|
473 | :raise BranchDoesNotExistError: If given ``branch_name`` does not | |
472 | exist. |
|
474 | exist. | |
473 | :raise CommitDoesNotExistError: If commit for given ``start`` or |
|
475 | :raise CommitDoesNotExistError: If commit for given ``start`` or | |
474 | ``end`` could not be found. |
|
476 | ``end`` could not be found. | |
475 | """ |
|
477 | """ | |
476 | # actually we should check now if it's not an empty repo |
|
478 | # actually we should check now if it's not an empty repo | |
477 | branch_ancestors = False |
|
479 | branch_ancestors = False | |
478 | if self.is_empty(): |
|
480 | if self.is_empty(): | |
479 | raise EmptyRepositoryError("There are no commits yet") |
|
481 | raise EmptyRepositoryError("There are no commits yet") | |
480 | self._validate_branch_name(branch_name) |
|
482 | self._validate_branch_name(branch_name) | |
481 |
|
483 | |||
482 | if start_id is not None: |
|
484 | if start_id is not None: | |
483 | self._validate_commit_id(start_id) |
|
485 | self._validate_commit_id(start_id) | |
484 | c_start = self.get_commit(commit_id=start_id) |
|
486 | c_start = self.get_commit(commit_id=start_id) | |
485 | start_pos = self._commit_ids[c_start.raw_id] |
|
487 | start_pos = self._commit_ids[c_start.raw_id] | |
486 | else: |
|
488 | else: | |
487 | start_pos = None |
|
489 | start_pos = None | |
488 |
|
490 | |||
489 | if end_id is not None: |
|
491 | if end_id is not None: | |
490 | self._validate_commit_id(end_id) |
|
492 | self._validate_commit_id(end_id) | |
491 | c_end = self.get_commit(commit_id=end_id) |
|
493 | c_end = self.get_commit(commit_id=end_id) | |
492 | end_pos = max(0, self._commit_ids[c_end.raw_id]) |
|
494 | end_pos = max(0, self._commit_ids[c_end.raw_id]) | |
493 | else: |
|
495 | else: | |
494 | end_pos = None |
|
496 | end_pos = None | |
495 |
|
497 | |||
496 | if None not in [start_id, end_id] and start_pos > end_pos: |
|
498 | if None not in [start_id, end_id] and start_pos > end_pos: | |
497 | raise RepositoryError( |
|
499 | raise RepositoryError( | |
498 | "Start commit '%s' cannot be after end commit '%s'" % |
|
500 | "Start commit '%s' cannot be after end commit '%s'" % | |
499 | (start_id, end_id)) |
|
501 | (start_id, end_id)) | |
500 |
|
502 | |||
501 | if end_pos is not None: |
|
503 | if end_pos is not None: | |
502 | end_pos += 1 |
|
504 | end_pos += 1 | |
503 |
|
505 | |||
504 | commit_filter = [] |
|
506 | commit_filter = [] | |
505 |
|
507 | |||
506 | if branch_name and not branch_ancestors: |
|
508 | if branch_name and not branch_ancestors: | |
507 | commit_filter.append('branch("%s")' % (branch_name,)) |
|
509 | commit_filter.append('branch("%s")' % (branch_name,)) | |
508 | elif branch_name and branch_ancestors: |
|
510 | elif branch_name and branch_ancestors: | |
509 | commit_filter.append('ancestors(branch("%s"))' % (branch_name,)) |
|
511 | commit_filter.append('ancestors(branch("%s"))' % (branch_name,)) | |
510 |
|
512 | |||
511 | if start_date and not end_date: |
|
513 | if start_date and not end_date: | |
512 | commit_filter.append('date(">%s")' % (start_date,)) |
|
514 | commit_filter.append('date(">%s")' % (start_date,)) | |
513 | if end_date and not start_date: |
|
515 | if end_date and not start_date: | |
514 | commit_filter.append('date("<%s")' % (end_date,)) |
|
516 | commit_filter.append('date("<%s")' % (end_date,)) | |
515 | if start_date and end_date: |
|
517 | if start_date and end_date: | |
516 | commit_filter.append( |
|
518 | commit_filter.append( | |
517 | 'date(">%s") and date("<%s")' % (start_date, end_date)) |
|
519 | 'date(">%s") and date("<%s")' % (start_date, end_date)) | |
518 |
|
520 | |||
519 | if not show_hidden: |
|
521 | if not show_hidden: | |
520 | commit_filter.append('not obsolete()') |
|
522 | commit_filter.append('not obsolete()') | |
521 | commit_filter.append('not hidden()') |
|
523 | commit_filter.append('not hidden()') | |
522 |
|
524 | |||
523 | # TODO: johbo: Figure out a simpler way for this solution |
|
525 | # TODO: johbo: Figure out a simpler way for this solution | |
524 | collection_generator = CollectionGenerator |
|
526 | collection_generator = CollectionGenerator | |
525 | if commit_filter: |
|
527 | if commit_filter: | |
526 | commit_filter = ' and '.join(map(safe_str, commit_filter)) |
|
528 | commit_filter = ' and '.join(map(safe_str, commit_filter)) | |
527 | revisions = self._remote.rev_range([commit_filter]) |
|
529 | revisions = self._remote.rev_range([commit_filter]) | |
528 | collection_generator = MercurialIndexBasedCollectionGenerator |
|
530 | collection_generator = MercurialIndexBasedCollectionGenerator | |
529 | else: |
|
531 | else: | |
530 | revisions = self.commit_ids |
|
532 | revisions = self.commit_ids | |
531 |
|
533 | |||
532 | if start_pos or end_pos: |
|
534 | if start_pos or end_pos: | |
533 | revisions = revisions[start_pos:end_pos] |
|
535 | revisions = revisions[start_pos:end_pos] | |
534 |
|
536 | |||
535 | return collection_generator(self, revisions, pre_load=pre_load) |
|
537 | return collection_generator(self, revisions, pre_load=pre_load) | |
536 |
|
538 | |||
537 | def pull(self, url, commit_ids=None): |
|
539 | def pull(self, url, commit_ids=None): | |
538 | """ |
|
540 | """ | |
539 | Tries to pull changes from external location. |
|
541 | Tries to pull changes from external location. | |
540 |
|
542 | |||
541 | :param commit_ids: Optional. Can be set to a list of commit ids |
|
543 | :param commit_ids: Optional. Can be set to a list of commit ids | |
542 | which shall be pulled from the other repository. |
|
544 | which shall be pulled from the other repository. | |
543 | """ |
|
545 | """ | |
544 | url = self._get_url(url) |
|
546 | url = self._get_url(url) | |
545 | self._remote.pull(url, commit_ids=commit_ids) |
|
547 | self._remote.pull(url, commit_ids=commit_ids) | |
546 | self._remote.invalidate_vcs_cache() |
|
548 | self._remote.invalidate_vcs_cache() | |
547 |
|
549 | |||
548 | def push(self, url): |
|
550 | def push(self, url): | |
549 | url = self._get_url(url) |
|
551 | url = self._get_url(url) | |
550 | self._remote.sync_push(url) |
|
552 | self._remote.sync_push(url) | |
551 |
|
553 | |||
552 | def _local_clone(self, clone_path): |
|
554 | def _local_clone(self, clone_path): | |
553 | """ |
|
555 | """ | |
554 | Create a local clone of the current repo. |
|
556 | Create a local clone of the current repo. | |
555 | """ |
|
557 | """ | |
556 | self._remote.clone(self.path, clone_path, update_after_clone=True, |
|
558 | self._remote.clone(self.path, clone_path, update_after_clone=True, | |
557 | hooks=False) |
|
559 | hooks=False) | |
558 |
|
560 | |||
559 | def _update(self, revision, clean=False): |
|
561 | def _update(self, revision, clean=False): | |
560 | """ |
|
562 | """ | |
561 | Update the working copy to the specified revision. |
|
563 | Update the working copy to the specified revision. | |
562 | """ |
|
564 | """ | |
563 | log.debug('Doing checkout to commit: `%s` for %s', revision, self) |
|
565 | log.debug('Doing checkout to commit: `%s` for %s', revision, self) | |
564 | self._remote.update(revision, clean=clean) |
|
566 | self._remote.update(revision, clean=clean) | |
565 |
|
567 | |||
566 | def _identify(self): |
|
568 | def _identify(self): | |
567 | """ |
|
569 | """ | |
568 | Return the current state of the working directory. |
|
570 | Return the current state of the working directory. | |
569 | """ |
|
571 | """ | |
570 | return self._remote.identify().strip().rstrip('+') |
|
572 | return self._remote.identify().strip().rstrip('+') | |
571 |
|
573 | |||
572 | def _heads(self, branch=None): |
|
574 | def _heads(self, branch=None): | |
573 | """ |
|
575 | """ | |
574 | Return the commit ids of the repository heads. |
|
576 | Return the commit ids of the repository heads. | |
575 | """ |
|
577 | """ | |
576 | return self._remote.heads(branch=branch).strip().split(' ') |
|
578 | return self._remote.heads(branch=branch).strip().split(' ') | |
577 |
|
579 | |||
578 | def _ancestor(self, revision1, revision2): |
|
580 | def _ancestor(self, revision1, revision2): | |
579 | """ |
|
581 | """ | |
580 | Return the common ancestor of the two revisions. |
|
582 | Return the common ancestor of the two revisions. | |
581 | """ |
|
583 | """ | |
582 | return self._remote.ancestor(revision1, revision2) |
|
584 | return self._remote.ancestor(revision1, revision2) | |
583 |
|
585 | |||
584 | def _local_push( |
|
586 | def _local_push( | |
585 | self, revision, repository_path, push_branches=False, |
|
587 | self, revision, repository_path, push_branches=False, | |
586 | enable_hooks=False): |
|
588 | enable_hooks=False): | |
587 | """ |
|
589 | """ | |
588 | Push the given revision to the specified repository. |
|
590 | Push the given revision to the specified repository. | |
589 |
|
591 | |||
590 | :param push_branches: allow to create branches in the target repo. |
|
592 | :param push_branches: allow to create branches in the target repo. | |
591 | """ |
|
593 | """ | |
592 | self._remote.push( |
|
594 | self._remote.push( | |
593 | [revision], repository_path, hooks=enable_hooks, |
|
595 | [revision], repository_path, hooks=enable_hooks, | |
594 | push_branches=push_branches) |
|
596 | push_branches=push_branches) | |
595 |
|
597 | |||
596 | def _local_merge(self, target_ref, merge_message, user_name, user_email, |
|
598 | def _local_merge(self, target_ref, merge_message, user_name, user_email, | |
597 | source_ref, use_rebase=False, dry_run=False): |
|
599 | source_ref, use_rebase=False, dry_run=False): | |
598 | """ |
|
600 | """ | |
599 | Merge the given source_revision into the checked out revision. |
|
601 | Merge the given source_revision into the checked out revision. | |
600 |
|
602 | |||
601 | Returns the commit id of the merge and a boolean indicating if the |
|
603 | Returns the commit id of the merge and a boolean indicating if the | |
602 | commit needs to be pushed. |
|
604 | commit needs to be pushed. | |
603 | """ |
|
605 | """ | |
604 | self._update(target_ref.commit_id) |
|
606 | self._update(target_ref.commit_id) | |
605 |
|
607 | |||
606 | ancestor = self._ancestor(target_ref.commit_id, source_ref.commit_id) |
|
608 | ancestor = self._ancestor(target_ref.commit_id, source_ref.commit_id) | |
607 | is_the_same_branch = self._is_the_same_branch(target_ref, source_ref) |
|
609 | is_the_same_branch = self._is_the_same_branch(target_ref, source_ref) | |
608 |
|
610 | |||
609 | if ancestor == source_ref.commit_id: |
|
611 | if ancestor == source_ref.commit_id: | |
610 | # Nothing to do, the changes were already integrated |
|
612 | # Nothing to do, the changes were already integrated | |
611 | return target_ref.commit_id, False |
|
613 | return target_ref.commit_id, False | |
612 |
|
614 | |||
613 | elif ancestor == target_ref.commit_id and is_the_same_branch: |
|
615 | elif ancestor == target_ref.commit_id and is_the_same_branch: | |
614 | # In this case we should force a commit message |
|
616 | # In this case we should force a commit message | |
615 | return source_ref.commit_id, True |
|
617 | return source_ref.commit_id, True | |
616 |
|
618 | |||
617 | if use_rebase: |
|
619 | if use_rebase: | |
618 | try: |
|
620 | try: | |
619 | bookmark_name = 'rcbook%s%s' % (source_ref.commit_id, |
|
621 | bookmark_name = 'rcbook%s%s' % (source_ref.commit_id, | |
620 | target_ref.commit_id) |
|
622 | target_ref.commit_id) | |
621 | self.bookmark(bookmark_name, revision=source_ref.commit_id) |
|
623 | self.bookmark(bookmark_name, revision=source_ref.commit_id) | |
622 | self._remote.rebase( |
|
624 | self._remote.rebase( | |
623 | source=source_ref.commit_id, dest=target_ref.commit_id) |
|
625 | source=source_ref.commit_id, dest=target_ref.commit_id) | |
624 | self._remote.invalidate_vcs_cache() |
|
626 | self._remote.invalidate_vcs_cache() | |
625 | self._update(bookmark_name) |
|
627 | self._update(bookmark_name) | |
626 | return self._identify(), True |
|
628 | return self._identify(), True | |
627 | except RepositoryError: |
|
629 | except RepositoryError: | |
628 | # The rebase-abort may raise another exception which 'hides' |
|
630 | # The rebase-abort may raise another exception which 'hides' | |
629 | # the original one, therefore we log it here. |
|
631 | # the original one, therefore we log it here. | |
630 | log.exception('Error while rebasing shadow repo during merge.') |
|
632 | log.exception('Error while rebasing shadow repo during merge.') | |
631 |
|
633 | |||
632 | # Cleanup any rebase leftovers |
|
634 | # Cleanup any rebase leftovers | |
633 | self._remote.invalidate_vcs_cache() |
|
635 | self._remote.invalidate_vcs_cache() | |
634 | self._remote.rebase(abort=True) |
|
636 | self._remote.rebase(abort=True) | |
635 | self._remote.invalidate_vcs_cache() |
|
637 | self._remote.invalidate_vcs_cache() | |
636 | self._remote.update(clean=True) |
|
638 | self._remote.update(clean=True) | |
637 | raise |
|
639 | raise | |
638 | else: |
|
640 | else: | |
639 | try: |
|
641 | try: | |
640 | self._remote.merge(source_ref.commit_id) |
|
642 | self._remote.merge(source_ref.commit_id) | |
641 | self._remote.invalidate_vcs_cache() |
|
643 | self._remote.invalidate_vcs_cache() | |
642 | self._remote.commit( |
|
644 | self._remote.commit( | |
643 | message=safe_str(merge_message), |
|
645 | message=safe_str(merge_message), | |
644 | username=safe_str('%s <%s>' % (user_name, user_email))) |
|
646 | username=safe_str('%s <%s>' % (user_name, user_email))) | |
645 | self._remote.invalidate_vcs_cache() |
|
647 | self._remote.invalidate_vcs_cache() | |
646 | return self._identify(), True |
|
648 | return self._identify(), True | |
647 | except RepositoryError: |
|
649 | except RepositoryError: | |
648 | # Cleanup any merge leftovers |
|
650 | # Cleanup any merge leftovers | |
649 | self._remote.update(clean=True) |
|
651 | self._remote.update(clean=True) | |
650 | raise |
|
652 | raise | |
651 |
|
653 | |||
652 | def _local_close(self, target_ref, user_name, user_email, |
|
654 | def _local_close(self, target_ref, user_name, user_email, | |
653 | source_ref, close_message=''): |
|
655 | source_ref, close_message=''): | |
654 | """ |
|
656 | """ | |
655 | Close the branch of the given source_revision |
|
657 | Close the branch of the given source_revision | |
656 |
|
658 | |||
657 | Returns the commit id of the close and a boolean indicating if the |
|
659 | Returns the commit id of the close and a boolean indicating if the | |
658 | commit needs to be pushed. |
|
660 | commit needs to be pushed. | |
659 | """ |
|
661 | """ | |
660 | self._update(source_ref.commit_id) |
|
662 | self._update(source_ref.commit_id) | |
661 | message = close_message or "Closing branch: `{}`".format(source_ref.name) |
|
663 | message = close_message or "Closing branch: `{}`".format(source_ref.name) | |
662 | try: |
|
664 | try: | |
663 | self._remote.commit( |
|
665 | self._remote.commit( | |
664 | message=safe_str(message), |
|
666 | message=safe_str(message), | |
665 | username=safe_str('%s <%s>' % (user_name, user_email)), |
|
667 | username=safe_str('%s <%s>' % (user_name, user_email)), | |
666 | close_branch=True) |
|
668 | close_branch=True) | |
667 | self._remote.invalidate_vcs_cache() |
|
669 | self._remote.invalidate_vcs_cache() | |
668 | return self._identify(), True |
|
670 | return self._identify(), True | |
669 | except RepositoryError: |
|
671 | except RepositoryError: | |
670 | # Cleanup any commit leftovers |
|
672 | # Cleanup any commit leftovers | |
671 | self._remote.update(clean=True) |
|
673 | self._remote.update(clean=True) | |
672 | raise |
|
674 | raise | |
673 |
|
675 | |||
674 | def _is_the_same_branch(self, target_ref, source_ref): |
|
676 | def _is_the_same_branch(self, target_ref, source_ref): | |
675 | return ( |
|
677 | return ( | |
676 | self._get_branch_name(target_ref) == |
|
678 | self._get_branch_name(target_ref) == | |
677 | self._get_branch_name(source_ref)) |
|
679 | self._get_branch_name(source_ref)) | |
678 |
|
680 | |||
679 | def _get_branch_name(self, ref): |
|
681 | def _get_branch_name(self, ref): | |
680 | if ref.type == 'branch': |
|
682 | if ref.type == 'branch': | |
681 | return ref.name |
|
683 | return ref.name | |
682 | return self._remote.ctx_branch(ref.commit_id) |
|
684 | return self._remote.ctx_branch(ref.commit_id) | |
683 |
|
685 | |||
684 | def _maybe_prepare_merge_workspace( |
|
686 | def _maybe_prepare_merge_workspace( | |
685 | self, repo_id, workspace_id, unused_target_ref, unused_source_ref): |
|
687 | self, repo_id, workspace_id, unused_target_ref, unused_source_ref): | |
686 | shadow_repository_path = self._get_shadow_repository_path( |
|
688 | shadow_repository_path = self._get_shadow_repository_path( | |
687 | repo_id, workspace_id) |
|
689 | repo_id, workspace_id) | |
688 | if not os.path.exists(shadow_repository_path): |
|
690 | if not os.path.exists(shadow_repository_path): | |
689 | self._local_clone(shadow_repository_path) |
|
691 | self._local_clone(shadow_repository_path) | |
690 | log.debug( |
|
692 | log.debug( | |
691 | 'Prepared shadow repository in %s', shadow_repository_path) |
|
693 | 'Prepared shadow repository in %s', shadow_repository_path) | |
692 |
|
694 | |||
693 | return shadow_repository_path |
|
695 | return shadow_repository_path | |
694 |
|
696 | |||
695 | def _merge_repo(self, repo_id, workspace_id, target_ref, |
|
697 | def _merge_repo(self, repo_id, workspace_id, target_ref, | |
696 | source_repo, source_ref, merge_message, |
|
698 | source_repo, source_ref, merge_message, | |
697 | merger_name, merger_email, dry_run=False, |
|
699 | merger_name, merger_email, dry_run=False, | |
698 | use_rebase=False, close_branch=False): |
|
700 | use_rebase=False, close_branch=False): | |
699 |
|
701 | |||
700 | log.debug('Executing merge_repo with %s strategy, dry_run mode:%s', |
|
702 | log.debug('Executing merge_repo with %s strategy, dry_run mode:%s', | |
701 | 'rebase' if use_rebase else 'merge', dry_run) |
|
703 | 'rebase' if use_rebase else 'merge', dry_run) | |
702 | if target_ref.commit_id not in self._heads(): |
|
704 | if target_ref.commit_id not in self._heads(): | |
703 | return MergeResponse( |
|
705 | return MergeResponse( | |
704 | False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD) |
|
706 | False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD) | |
705 |
|
707 | |||
706 | try: |
|
708 | try: | |
707 | if (target_ref.type == 'branch' and |
|
709 | if (target_ref.type == 'branch' and | |
708 | len(self._heads(target_ref.name)) != 1): |
|
710 | len(self._heads(target_ref.name)) != 1): | |
709 | return MergeResponse( |
|
711 | return MergeResponse( | |
710 | False, False, None, |
|
712 | False, False, None, | |
711 | MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS) |
|
713 | MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS) | |
712 | except CommitDoesNotExistError: |
|
714 | except CommitDoesNotExistError: | |
713 | log.exception('Failure when looking up branch heads on hg target') |
|
715 | log.exception('Failure when looking up branch heads on hg target') | |
714 | return MergeResponse( |
|
716 | return MergeResponse( | |
715 | False, False, None, MergeFailureReason.MISSING_TARGET_REF) |
|
717 | False, False, None, MergeFailureReason.MISSING_TARGET_REF) | |
716 |
|
718 | |||
717 | shadow_repository_path = self._maybe_prepare_merge_workspace( |
|
719 | shadow_repository_path = self._maybe_prepare_merge_workspace( | |
718 | repo_id, workspace_id, target_ref, source_ref) |
|
720 | repo_id, workspace_id, target_ref, source_ref) | |
719 | shadow_repo = self._get_shadow_instance(shadow_repository_path) |
|
721 | shadow_repo = self._get_shadow_instance(shadow_repository_path) | |
720 |
|
722 | |||
721 | log.debug('Pulling in target reference %s', target_ref) |
|
723 | log.debug('Pulling in target reference %s', target_ref) | |
722 | self._validate_pull_reference(target_ref) |
|
724 | self._validate_pull_reference(target_ref) | |
723 | shadow_repo._local_pull(self.path, target_ref) |
|
725 | shadow_repo._local_pull(self.path, target_ref) | |
724 | try: |
|
726 | try: | |
725 | log.debug('Pulling in source reference %s', source_ref) |
|
727 | log.debug('Pulling in source reference %s', source_ref) | |
726 | source_repo._validate_pull_reference(source_ref) |
|
728 | source_repo._validate_pull_reference(source_ref) | |
727 | shadow_repo._local_pull(source_repo.path, source_ref) |
|
729 | shadow_repo._local_pull(source_repo.path, source_ref) | |
728 | except CommitDoesNotExistError: |
|
730 | except CommitDoesNotExistError: | |
729 | log.exception('Failure when doing local pull on hg shadow repo') |
|
731 | log.exception('Failure when doing local pull on hg shadow repo') | |
730 | return MergeResponse( |
|
732 | return MergeResponse( | |
731 | False, False, None, MergeFailureReason.MISSING_SOURCE_REF) |
|
733 | False, False, None, MergeFailureReason.MISSING_SOURCE_REF) | |
732 |
|
734 | |||
733 | merge_ref = None |
|
735 | merge_ref = None | |
734 | merge_commit_id = None |
|
736 | merge_commit_id = None | |
735 | close_commit_id = None |
|
737 | close_commit_id = None | |
736 | merge_failure_reason = MergeFailureReason.NONE |
|
738 | merge_failure_reason = MergeFailureReason.NONE | |
737 |
|
739 | |||
738 | # enforce that close branch should be used only in case we source from |
|
740 | # enforce that close branch should be used only in case we source from | |
739 | # an actual Branch |
|
741 | # an actual Branch | |
740 | close_branch = close_branch and source_ref.type == 'branch' |
|
742 | close_branch = close_branch and source_ref.type == 'branch' | |
741 |
|
743 | |||
742 | # don't allow to close branch if source and target are the same |
|
744 | # don't allow to close branch if source and target are the same | |
743 | close_branch = close_branch and source_ref.name != target_ref.name |
|
745 | close_branch = close_branch and source_ref.name != target_ref.name | |
744 |
|
746 | |||
745 | needs_push_on_close = False |
|
747 | needs_push_on_close = False | |
746 | if close_branch and not use_rebase and not dry_run: |
|
748 | if close_branch and not use_rebase and not dry_run: | |
747 | try: |
|
749 | try: | |
748 | close_commit_id, needs_push_on_close = shadow_repo._local_close( |
|
750 | close_commit_id, needs_push_on_close = shadow_repo._local_close( | |
749 | target_ref, merger_name, merger_email, source_ref) |
|
751 | target_ref, merger_name, merger_email, source_ref) | |
750 | merge_possible = True |
|
752 | merge_possible = True | |
751 | except RepositoryError: |
|
753 | except RepositoryError: | |
752 | log.exception( |
|
754 | log.exception( | |
753 | 'Failure when doing close branch on hg shadow repo') |
|
755 | 'Failure when doing close branch on hg shadow repo') | |
754 | merge_possible = False |
|
756 | merge_possible = False | |
755 | merge_failure_reason = MergeFailureReason.MERGE_FAILED |
|
757 | merge_failure_reason = MergeFailureReason.MERGE_FAILED | |
756 | else: |
|
758 | else: | |
757 | merge_possible = True |
|
759 | merge_possible = True | |
758 |
|
760 | |||
759 | needs_push = False |
|
761 | needs_push = False | |
760 | if merge_possible: |
|
762 | if merge_possible: | |
761 | try: |
|
763 | try: | |
762 | merge_commit_id, needs_push = shadow_repo._local_merge( |
|
764 | merge_commit_id, needs_push = shadow_repo._local_merge( | |
763 | target_ref, merge_message, merger_name, merger_email, |
|
765 | target_ref, merge_message, merger_name, merger_email, | |
764 | source_ref, use_rebase=use_rebase, dry_run=dry_run) |
|
766 | source_ref, use_rebase=use_rebase, dry_run=dry_run) | |
765 | merge_possible = True |
|
767 | merge_possible = True | |
766 |
|
768 | |||
767 | # read the state of the close action, if it |
|
769 | # read the state of the close action, if it | |
768 | # maybe required a push |
|
770 | # maybe required a push | |
769 | needs_push = needs_push or needs_push_on_close |
|
771 | needs_push = needs_push or needs_push_on_close | |
770 |
|
772 | |||
771 | # Set a bookmark pointing to the merge commit. This bookmark |
|
773 | # Set a bookmark pointing to the merge commit. This bookmark | |
772 | # may be used to easily identify the last successful merge |
|
774 | # may be used to easily identify the last successful merge | |
773 | # commit in the shadow repository. |
|
775 | # commit in the shadow repository. | |
774 | shadow_repo.bookmark('pr-merge', revision=merge_commit_id) |
|
776 | shadow_repo.bookmark('pr-merge', revision=merge_commit_id) | |
775 | merge_ref = Reference('book', 'pr-merge', merge_commit_id) |
|
777 | merge_ref = Reference('book', 'pr-merge', merge_commit_id) | |
776 | except SubrepoMergeError: |
|
778 | except SubrepoMergeError: | |
777 | log.exception( |
|
779 | log.exception( | |
778 | 'Subrepo merge error during local merge on hg shadow repo.') |
|
780 | 'Subrepo merge error during local merge on hg shadow repo.') | |
779 | merge_possible = False |
|
781 | merge_possible = False | |
780 | merge_failure_reason = MergeFailureReason.SUBREPO_MERGE_FAILED |
|
782 | merge_failure_reason = MergeFailureReason.SUBREPO_MERGE_FAILED | |
781 | needs_push = False |
|
783 | needs_push = False | |
782 | except RepositoryError: |
|
784 | except RepositoryError: | |
783 | log.exception('Failure when doing local merge on hg shadow repo') |
|
785 | log.exception('Failure when doing local merge on hg shadow repo') | |
784 | merge_possible = False |
|
786 | merge_possible = False | |
785 | merge_failure_reason = MergeFailureReason.MERGE_FAILED |
|
787 | merge_failure_reason = MergeFailureReason.MERGE_FAILED | |
786 | needs_push = False |
|
788 | needs_push = False | |
787 |
|
789 | |||
788 | if merge_possible and not dry_run: |
|
790 | if merge_possible and not dry_run: | |
789 | if needs_push: |
|
791 | if needs_push: | |
790 | # In case the target is a bookmark, update it, so after pushing |
|
792 | # In case the target is a bookmark, update it, so after pushing | |
791 | # the bookmarks is also updated in the target. |
|
793 | # the bookmarks is also updated in the target. | |
792 | if target_ref.type == 'book': |
|
794 | if target_ref.type == 'book': | |
793 | shadow_repo.bookmark( |
|
795 | shadow_repo.bookmark( | |
794 | target_ref.name, revision=merge_commit_id) |
|
796 | target_ref.name, revision=merge_commit_id) | |
795 | try: |
|
797 | try: | |
796 | shadow_repo_with_hooks = self._get_shadow_instance( |
|
798 | shadow_repo_with_hooks = self._get_shadow_instance( | |
797 | shadow_repository_path, |
|
799 | shadow_repository_path, | |
798 | enable_hooks=True) |
|
800 | enable_hooks=True) | |
799 | # This is the actual merge action, we push from shadow |
|
801 | # This is the actual merge action, we push from shadow | |
800 | # into origin. |
|
802 | # into origin. | |
801 | # Note: the push_branches option will push any new branch |
|
803 | # Note: the push_branches option will push any new branch | |
802 | # defined in the source repository to the target. This may |
|
804 | # defined in the source repository to the target. This may | |
803 | # be dangerous as branches are permanent in Mercurial. |
|
805 | # be dangerous as branches are permanent in Mercurial. | |
804 | # This feature was requested in issue #441. |
|
806 | # This feature was requested in issue #441. | |
805 | shadow_repo_with_hooks._local_push( |
|
807 | shadow_repo_with_hooks._local_push( | |
806 | merge_commit_id, self.path, push_branches=True, |
|
808 | merge_commit_id, self.path, push_branches=True, | |
807 | enable_hooks=True) |
|
809 | enable_hooks=True) | |
808 |
|
810 | |||
809 | # maybe we also need to push the close_commit_id |
|
811 | # maybe we also need to push the close_commit_id | |
810 | if close_commit_id: |
|
812 | if close_commit_id: | |
811 | shadow_repo_with_hooks._local_push( |
|
813 | shadow_repo_with_hooks._local_push( | |
812 | close_commit_id, self.path, push_branches=True, |
|
814 | close_commit_id, self.path, push_branches=True, | |
813 | enable_hooks=True) |
|
815 | enable_hooks=True) | |
814 | merge_succeeded = True |
|
816 | merge_succeeded = True | |
815 | except RepositoryError: |
|
817 | except RepositoryError: | |
816 | log.exception( |
|
818 | log.exception( | |
817 | 'Failure when doing local push from the shadow ' |
|
819 | 'Failure when doing local push from the shadow ' | |
818 | 'repository to the target repository.') |
|
820 | 'repository to the target repository.') | |
819 | merge_succeeded = False |
|
821 | merge_succeeded = False | |
820 | merge_failure_reason = MergeFailureReason.PUSH_FAILED |
|
822 | merge_failure_reason = MergeFailureReason.PUSH_FAILED | |
821 | else: |
|
823 | else: | |
822 | merge_succeeded = True |
|
824 | merge_succeeded = True | |
823 | else: |
|
825 | else: | |
824 | merge_succeeded = False |
|
826 | merge_succeeded = False | |
825 |
|
827 | |||
826 | return MergeResponse( |
|
828 | return MergeResponse( | |
827 | merge_possible, merge_succeeded, merge_ref, merge_failure_reason) |
|
829 | merge_possible, merge_succeeded, merge_ref, merge_failure_reason) | |
828 |
|
830 | |||
829 | def _get_shadow_instance( |
|
831 | def _get_shadow_instance( | |
830 | self, shadow_repository_path, enable_hooks=False): |
|
832 | self, shadow_repository_path, enable_hooks=False): | |
831 | config = self.config.copy() |
|
833 | config = self.config.copy() | |
832 | if not enable_hooks: |
|
834 | if not enable_hooks: | |
833 | config.clear_section('hooks') |
|
835 | config.clear_section('hooks') | |
834 | return MercurialRepository(shadow_repository_path, config) |
|
836 | return MercurialRepository(shadow_repository_path, config) | |
835 |
|
837 | |||
836 | def _validate_pull_reference(self, reference): |
|
838 | def _validate_pull_reference(self, reference): | |
837 | if not (reference.name in self.bookmarks or |
|
839 | if not (reference.name in self.bookmarks or | |
838 | reference.name in self.branches or |
|
840 | reference.name in self.branches or | |
839 | self.get_commit(reference.commit_id)): |
|
841 | self.get_commit(reference.commit_id)): | |
840 | raise CommitDoesNotExistError( |
|
842 | raise CommitDoesNotExistError( | |
841 | 'Unknown branch, bookmark or commit id') |
|
843 | 'Unknown branch, bookmark or commit id') | |
842 |
|
844 | |||
843 | def _local_pull(self, repository_path, reference): |
|
845 | def _local_pull(self, repository_path, reference): | |
844 | """ |
|
846 | """ | |
845 | Fetch a branch, bookmark or commit from a local repository. |
|
847 | Fetch a branch, bookmark or commit from a local repository. | |
846 | """ |
|
848 | """ | |
847 | repository_path = os.path.abspath(repository_path) |
|
849 | repository_path = os.path.abspath(repository_path) | |
848 | if repository_path == self.path: |
|
850 | if repository_path == self.path: | |
849 | raise ValueError('Cannot pull from the same repository') |
|
851 | raise ValueError('Cannot pull from the same repository') | |
850 |
|
852 | |||
851 | reference_type_to_option_name = { |
|
853 | reference_type_to_option_name = { | |
852 | 'book': 'bookmark', |
|
854 | 'book': 'bookmark', | |
853 | 'branch': 'branch', |
|
855 | 'branch': 'branch', | |
854 | } |
|
856 | } | |
855 | option_name = reference_type_to_option_name.get( |
|
857 | option_name = reference_type_to_option_name.get( | |
856 | reference.type, 'revision') |
|
858 | reference.type, 'revision') | |
857 |
|
859 | |||
858 | if option_name == 'revision': |
|
860 | if option_name == 'revision': | |
859 | ref = reference.commit_id |
|
861 | ref = reference.commit_id | |
860 | else: |
|
862 | else: | |
861 | ref = reference.name |
|
863 | ref = reference.name | |
862 |
|
864 | |||
863 | options = {option_name: [ref]} |
|
865 | options = {option_name: [ref]} | |
864 | self._remote.pull_cmd(repository_path, hooks=False, **options) |
|
866 | self._remote.pull_cmd(repository_path, hooks=False, **options) | |
865 | self._remote.invalidate_vcs_cache() |
|
867 | self._remote.invalidate_vcs_cache() | |
866 |
|
868 | |||
867 | def bookmark(self, bookmark, revision=None): |
|
869 | def bookmark(self, bookmark, revision=None): | |
868 | if isinstance(bookmark, unicode): |
|
870 | if isinstance(bookmark, unicode): | |
869 | bookmark = safe_str(bookmark) |
|
871 | bookmark = safe_str(bookmark) | |
870 | self._remote.bookmark(bookmark, revision=revision) |
|
872 | self._remote.bookmark(bookmark, revision=revision) | |
871 | self._remote.invalidate_vcs_cache() |
|
873 | self._remote.invalidate_vcs_cache() | |
872 |
|
874 | |||
873 | def get_path_permissions(self, username): |
|
875 | def get_path_permissions(self, username): | |
874 | hgacl_file = os.path.join(self.path, '.hg/hgacl') |
|
876 | hgacl_file = os.path.join(self.path, '.hg/hgacl') | |
875 |
|
877 | |||
876 | def read_patterns(suffix): |
|
878 | def read_patterns(suffix): | |
877 | svalue = None |
|
879 | svalue = None | |
878 | try: |
|
880 | try: | |
879 | svalue = hgacl.get('narrowhgacl', username + suffix) |
|
881 | svalue = hgacl.get('narrowhgacl', username + suffix) | |
880 | except configparser.NoOptionError: |
|
882 | except configparser.NoOptionError: | |
881 | try: |
|
883 | try: | |
882 | svalue = hgacl.get('narrowhgacl', 'default' + suffix) |
|
884 | svalue = hgacl.get('narrowhgacl', 'default' + suffix) | |
883 | except configparser.NoOptionError: |
|
885 | except configparser.NoOptionError: | |
884 | pass |
|
886 | pass | |
885 | if not svalue: |
|
887 | if not svalue: | |
886 | return None |
|
888 | return None | |
887 | result = ['/'] |
|
889 | result = ['/'] | |
888 | for pattern in svalue.split(): |
|
890 | for pattern in svalue.split(): | |
889 | result.append(pattern) |
|
891 | result.append(pattern) | |
890 | if '*' not in pattern and '?' not in pattern: |
|
892 | if '*' not in pattern and '?' not in pattern: | |
891 | result.append(pattern + '/*') |
|
893 | result.append(pattern + '/*') | |
892 | return result |
|
894 | return result | |
893 |
|
895 | |||
894 | if os.path.exists(hgacl_file): |
|
896 | if os.path.exists(hgacl_file): | |
895 | try: |
|
897 | try: | |
896 | hgacl = configparser.RawConfigParser() |
|
898 | hgacl = configparser.RawConfigParser() | |
897 | hgacl.read(hgacl_file) |
|
899 | hgacl.read(hgacl_file) | |
898 |
|
900 | |||
899 | includes = read_patterns('.includes') |
|
901 | includes = read_patterns('.includes') | |
900 | excludes = read_patterns('.excludes') |
|
902 | excludes = read_patterns('.excludes') | |
901 | return BasePathPermissionChecker.create_from_patterns( |
|
903 | return BasePathPermissionChecker.create_from_patterns( | |
902 | includes, excludes) |
|
904 | includes, excludes) | |
903 | except BaseException as e: |
|
905 | except BaseException as e: | |
904 | msg = 'Cannot read ACL settings from {} on {}: {}'.format( |
|
906 | msg = 'Cannot read ACL settings from {} on {}: {}'.format( | |
905 | hgacl_file, self.name, e) |
|
907 | hgacl_file, self.name, e) | |
906 | raise exceptions.RepositoryRequirementError(msg) |
|
908 | raise exceptions.RepositoryRequirementError(msg) | |
907 | else: |
|
909 | else: | |
908 | return None |
|
910 | return None | |
909 |
|
911 | |||
910 |
|
912 | |||
911 | class MercurialIndexBasedCollectionGenerator(CollectionGenerator): |
|
913 | class MercurialIndexBasedCollectionGenerator(CollectionGenerator): | |
912 |
|
914 | |||
913 | def _commit_factory(self, commit_id): |
|
915 | def _commit_factory(self, commit_id): | |
914 | return self.repo.get_commit( |
|
916 | return self.repo.get_commit( | |
915 | commit_idx=commit_id, pre_load=self.pre_load) |
|
917 | commit_idx=commit_id, pre_load=self.pre_load) |
@@ -1,341 +1,343 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 |
|
2 | |||
3 | # Copyright (C) 2014-2018 RhodeCode GmbH |
|
3 | # Copyright (C) 2014-2018 RhodeCode GmbH | |
4 | # |
|
4 | # | |
5 | # This program is free software: you can redistribute it and/or modify |
|
5 | # This program is free software: you can redistribute it and/or modify | |
6 | # it under the terms of the GNU Affero General Public License, version 3 |
|
6 | # it under the terms of the GNU Affero General Public License, version 3 | |
7 | # (only), as published by the Free Software Foundation. |
|
7 | # (only), as published by the Free Software Foundation. | |
8 | # |
|
8 | # | |
9 | # This program is distributed in the hope that it will be useful, |
|
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. |
|
12 | # GNU General Public License for more details. | |
13 | # |
|
13 | # | |
14 | # You should have received a copy of the GNU Affero General Public License |
|
14 | # You should have received a copy of the GNU Affero General Public License | |
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
16 | # |
|
16 | # | |
17 | # This program is dual-licensed. If you wish to learn more about the |
|
17 | # This program is dual-licensed. If you wish to learn more about the | |
18 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
18 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
20 |
|
20 | |||
21 | """ |
|
21 | """ | |
22 | SVN repository module |
|
22 | SVN repository module | |
23 | """ |
|
23 | """ | |
24 |
|
24 | |||
25 | import logging |
|
25 | import logging | |
26 | import os |
|
26 | import os | |
27 | import urllib |
|
27 | import urllib | |
28 |
|
28 | |||
29 | from zope.cachedescriptors.property import Lazy as LazyProperty |
|
29 | from zope.cachedescriptors.property import Lazy as LazyProperty | |
30 |
|
30 | |||
31 | from rhodecode.lib.compat import OrderedDict |
|
31 | from rhodecode.lib.compat import OrderedDict | |
32 | from rhodecode.lib.datelib import date_astimestamp |
|
32 | from rhodecode.lib.datelib import date_astimestamp | |
33 | from rhodecode.lib.utils import safe_str, safe_unicode |
|
33 | from rhodecode.lib.utils import safe_str, safe_unicode | |
34 | from rhodecode.lib.vcs import connection, path as vcspath |
|
34 | from rhodecode.lib.vcs import connection, path as vcspath | |
35 | from rhodecode.lib.vcs.backends import base |
|
35 | from rhodecode.lib.vcs.backends import base | |
36 | from rhodecode.lib.vcs.backends.svn.commit import ( |
|
36 | from rhodecode.lib.vcs.backends.svn.commit import ( | |
37 | SubversionCommit, _date_from_svn_properties) |
|
37 | SubversionCommit, _date_from_svn_properties) | |
38 | from rhodecode.lib.vcs.backends.svn.diff import SubversionDiff |
|
38 | from rhodecode.lib.vcs.backends.svn.diff import SubversionDiff | |
39 | from rhodecode.lib.vcs.backends.svn.inmemory import SubversionInMemoryCommit |
|
39 | from rhodecode.lib.vcs.backends.svn.inmemory import SubversionInMemoryCommit | |
40 | from rhodecode.lib.vcs.conf import settings |
|
40 | from rhodecode.lib.vcs.conf import settings | |
41 | from rhodecode.lib.vcs.exceptions import ( |
|
41 | from rhodecode.lib.vcs.exceptions import ( | |
42 | CommitDoesNotExistError, EmptyRepositoryError, RepositoryError, |
|
42 | CommitDoesNotExistError, EmptyRepositoryError, RepositoryError, | |
43 | VCSError, NodeDoesNotExistError) |
|
43 | VCSError, NodeDoesNotExistError) | |
44 |
|
44 | |||
45 |
|
45 | |||
46 | log = logging.getLogger(__name__) |
|
46 | log = logging.getLogger(__name__) | |
47 |
|
47 | |||
48 |
|
48 | |||
49 | class SubversionRepository(base.BaseRepository): |
|
49 | class SubversionRepository(base.BaseRepository): | |
50 | """ |
|
50 | """ | |
51 | Subversion backend implementation |
|
51 | Subversion backend implementation | |
52 |
|
52 | |||
53 | .. important:: |
|
53 | .. important:: | |
54 |
|
54 | |||
55 | It is very important to distinguish the commit index and the commit id |
|
55 | It is very important to distinguish the commit index and the commit id | |
56 | which is assigned by Subversion. The first one is always handled as an |
|
56 | which is assigned by Subversion. The first one is always handled as an | |
57 | `int` by this implementation. The commit id assigned by Subversion on |
|
57 | `int` by this implementation. The commit id assigned by Subversion on | |
58 | the other side will always be a `str`. |
|
58 | the other side will always be a `str`. | |
59 |
|
59 | |||
60 | There is a specific trap since the first commit will have the index |
|
60 | There is a specific trap since the first commit will have the index | |
61 | ``0`` but the svn id will be ``"1"``. |
|
61 | ``0`` but the svn id will be ``"1"``. | |
62 |
|
62 | |||
63 | """ |
|
63 | """ | |
64 |
|
64 | |||
65 | # Note: Subversion does not really have a default branch name. |
|
65 | # Note: Subversion does not really have a default branch name. | |
66 | DEFAULT_BRANCH_NAME = None |
|
66 | DEFAULT_BRANCH_NAME = None | |
67 |
|
67 | |||
68 | contact = base.BaseRepository.DEFAULT_CONTACT |
|
68 | contact = base.BaseRepository.DEFAULT_CONTACT | |
69 | description = base.BaseRepository.DEFAULT_DESCRIPTION |
|
69 | description = base.BaseRepository.DEFAULT_DESCRIPTION | |
70 |
|
70 | |||
71 | def __init__(self, repo_path, config=None, create=False, src_url=None, |
|
71 | def __init__(self, repo_path, config=None, create=False, src_url=None, | |
72 | **kwargs): |
|
72 | **kwargs): | |
73 | self.path = safe_str(os.path.abspath(repo_path)) |
|
73 | self.path = safe_str(os.path.abspath(repo_path)) | |
74 | self.config = config if config else self.get_default_config() |
|
74 | self.config = config if config else self.get_default_config() | |
75 | self._remote = connection.Svn( |
|
|||
76 | self.path, self.config) |
|
|||
77 |
|
75 | |||
78 | self._init_repo(create, src_url) |
|
76 | self._init_repo(create, src_url) | |
79 |
|
77 | |||
|
78 | @LazyProperty | |||
|
79 | def _remote(self): | |||
|
80 | return connection.Svn(self.path, self.config) | |||
|
81 | ||||
80 | def _init_repo(self, create, src_url): |
|
82 | def _init_repo(self, create, src_url): | |
81 | if create and os.path.exists(self.path): |
|
83 | if create and os.path.exists(self.path): | |
82 | raise RepositoryError( |
|
84 | raise RepositoryError( | |
83 | "Cannot create repository at %s, location already exist" |
|
85 | "Cannot create repository at %s, location already exist" | |
84 | % self.path) |
|
86 | % self.path) | |
85 |
|
87 | |||
86 | if create: |
|
88 | if create: | |
87 | self._remote.create_repository(settings.SVN_COMPATIBLE_VERSION) |
|
89 | self._remote.create_repository(settings.SVN_COMPATIBLE_VERSION) | |
88 | if src_url: |
|
90 | if src_url: | |
89 | src_url = _sanitize_url(src_url) |
|
91 | src_url = _sanitize_url(src_url) | |
90 | self._remote.import_remote_repository(src_url) |
|
92 | self._remote.import_remote_repository(src_url) | |
91 | else: |
|
93 | else: | |
92 | self._check_path() |
|
94 | self._check_path() | |
93 |
|
95 | |||
94 | @LazyProperty |
|
96 | @LazyProperty | |
95 | def commit_ids(self): |
|
97 | def commit_ids(self): | |
96 | head = self._remote.lookup(None) |
|
98 | head = self._remote.lookup(None) | |
97 | return [str(r) for r in xrange(1, head + 1)] |
|
99 | return [str(r) for r in xrange(1, head + 1)] | |
98 |
|
100 | |||
99 | @LazyProperty |
|
101 | @LazyProperty | |
100 | def branches(self): |
|
102 | def branches(self): | |
101 | return self._tags_or_branches('vcs_svn_branch') |
|
103 | return self._tags_or_branches('vcs_svn_branch') | |
102 |
|
104 | |||
103 | @LazyProperty |
|
105 | @LazyProperty | |
104 | def branches_closed(self): |
|
106 | def branches_closed(self): | |
105 | return {} |
|
107 | return {} | |
106 |
|
108 | |||
107 | @LazyProperty |
|
109 | @LazyProperty | |
108 | def bookmarks(self): |
|
110 | def bookmarks(self): | |
109 | return {} |
|
111 | return {} | |
110 |
|
112 | |||
111 | @LazyProperty |
|
113 | @LazyProperty | |
112 | def branches_all(self): |
|
114 | def branches_all(self): | |
113 | # TODO: johbo: Implement proper branch support |
|
115 | # TODO: johbo: Implement proper branch support | |
114 | all_branches = {} |
|
116 | all_branches = {} | |
115 | all_branches.update(self.branches) |
|
117 | all_branches.update(self.branches) | |
116 | all_branches.update(self.branches_closed) |
|
118 | all_branches.update(self.branches_closed) | |
117 | return all_branches |
|
119 | return all_branches | |
118 |
|
120 | |||
119 | @LazyProperty |
|
121 | @LazyProperty | |
120 | def tags(self): |
|
122 | def tags(self): | |
121 | return self._tags_or_branches('vcs_svn_tag') |
|
123 | return self._tags_or_branches('vcs_svn_tag') | |
122 |
|
124 | |||
123 | def _tags_or_branches(self, config_section): |
|
125 | def _tags_or_branches(self, config_section): | |
124 | found_items = {} |
|
126 | found_items = {} | |
125 |
|
127 | |||
126 | if self.is_empty(): |
|
128 | if self.is_empty(): | |
127 | return {} |
|
129 | return {} | |
128 |
|
130 | |||
129 | for pattern in self._patterns_from_section(config_section): |
|
131 | for pattern in self._patterns_from_section(config_section): | |
130 | pattern = vcspath.sanitize(pattern) |
|
132 | pattern = vcspath.sanitize(pattern) | |
131 | tip = self.get_commit() |
|
133 | tip = self.get_commit() | |
132 | try: |
|
134 | try: | |
133 | if pattern.endswith('*'): |
|
135 | if pattern.endswith('*'): | |
134 | basedir = tip.get_node(vcspath.dirname(pattern)) |
|
136 | basedir = tip.get_node(vcspath.dirname(pattern)) | |
135 | directories = basedir.dirs |
|
137 | directories = basedir.dirs | |
136 | else: |
|
138 | else: | |
137 | directories = (tip.get_node(pattern), ) |
|
139 | directories = (tip.get_node(pattern), ) | |
138 | except NodeDoesNotExistError: |
|
140 | except NodeDoesNotExistError: | |
139 | continue |
|
141 | continue | |
140 | found_items.update( |
|
142 | found_items.update( | |
141 | (safe_unicode(n.path), |
|
143 | (safe_unicode(n.path), | |
142 | self.commit_ids[-1]) |
|
144 | self.commit_ids[-1]) | |
143 | for n in directories) |
|
145 | for n in directories) | |
144 |
|
146 | |||
145 | def get_name(item): |
|
147 | def get_name(item): | |
146 | return item[0] |
|
148 | return item[0] | |
147 |
|
149 | |||
148 | return OrderedDict(sorted(found_items.items(), key=get_name)) |
|
150 | return OrderedDict(sorted(found_items.items(), key=get_name)) | |
149 |
|
151 | |||
150 | def _patterns_from_section(self, section): |
|
152 | def _patterns_from_section(self, section): | |
151 | return (pattern for key, pattern in self.config.items(section)) |
|
153 | return (pattern for key, pattern in self.config.items(section)) | |
152 |
|
154 | |||
153 | def get_common_ancestor(self, commit_id1, commit_id2, repo2): |
|
155 | def get_common_ancestor(self, commit_id1, commit_id2, repo2): | |
154 | if self != repo2: |
|
156 | if self != repo2: | |
155 | raise ValueError( |
|
157 | raise ValueError( | |
156 | "Subversion does not support getting common ancestor of" |
|
158 | "Subversion does not support getting common ancestor of" | |
157 | " different repositories.") |
|
159 | " different repositories.") | |
158 |
|
160 | |||
159 | if int(commit_id1) < int(commit_id2): |
|
161 | if int(commit_id1) < int(commit_id2): | |
160 | return commit_id1 |
|
162 | return commit_id1 | |
161 | return commit_id2 |
|
163 | return commit_id2 | |
162 |
|
164 | |||
163 | def verify(self): |
|
165 | def verify(self): | |
164 | verify = self._remote.verify() |
|
166 | verify = self._remote.verify() | |
165 |
|
167 | |||
166 | self._remote.invalidate_vcs_cache() |
|
168 | self._remote.invalidate_vcs_cache() | |
167 | return verify |
|
169 | return verify | |
168 |
|
170 | |||
169 | def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None): |
|
171 | def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None): | |
170 | # TODO: johbo: Implement better comparison, this is a very naive |
|
172 | # TODO: johbo: Implement better comparison, this is a very naive | |
171 | # version which does not allow to compare branches, tags or folders |
|
173 | # version which does not allow to compare branches, tags or folders | |
172 | # at all. |
|
174 | # at all. | |
173 | if repo2 != self: |
|
175 | if repo2 != self: | |
174 | raise ValueError( |
|
176 | raise ValueError( | |
175 | "Subversion does not support comparison of of different " |
|
177 | "Subversion does not support comparison of of different " | |
176 | "repositories.") |
|
178 | "repositories.") | |
177 |
|
179 | |||
178 | if commit_id1 == commit_id2: |
|
180 | if commit_id1 == commit_id2: | |
179 | return [] |
|
181 | return [] | |
180 |
|
182 | |||
181 | commit_idx1 = self._get_commit_idx(commit_id1) |
|
183 | commit_idx1 = self._get_commit_idx(commit_id1) | |
182 | commit_idx2 = self._get_commit_idx(commit_id2) |
|
184 | commit_idx2 = self._get_commit_idx(commit_id2) | |
183 |
|
185 | |||
184 | commits = [ |
|
186 | commits = [ | |
185 | self.get_commit(commit_idx=idx) |
|
187 | self.get_commit(commit_idx=idx) | |
186 | for idx in range(commit_idx1 + 1, commit_idx2 + 1)] |
|
188 | for idx in range(commit_idx1 + 1, commit_idx2 + 1)] | |
187 |
|
189 | |||
188 | return commits |
|
190 | return commits | |
189 |
|
191 | |||
190 | def _get_commit_idx(self, commit_id): |
|
192 | def _get_commit_idx(self, commit_id): | |
191 | try: |
|
193 | try: | |
192 | svn_rev = int(commit_id) |
|
194 | svn_rev = int(commit_id) | |
193 | except: |
|
195 | except: | |
194 | # TODO: johbo: this might be only one case, HEAD, check this |
|
196 | # TODO: johbo: this might be only one case, HEAD, check this | |
195 | svn_rev = self._remote.lookup(commit_id) |
|
197 | svn_rev = self._remote.lookup(commit_id) | |
196 | commit_idx = svn_rev - 1 |
|
198 | commit_idx = svn_rev - 1 | |
197 | if commit_idx >= len(self.commit_ids): |
|
199 | if commit_idx >= len(self.commit_ids): | |
198 | raise CommitDoesNotExistError( |
|
200 | raise CommitDoesNotExistError( | |
199 | "Commit at index %s does not exist." % (commit_idx, )) |
|
201 | "Commit at index %s does not exist." % (commit_idx, )) | |
200 | return commit_idx |
|
202 | return commit_idx | |
201 |
|
203 | |||
202 | @staticmethod |
|
204 | @staticmethod | |
203 | def check_url(url, config): |
|
205 | def check_url(url, config): | |
204 | """ |
|
206 | """ | |
205 | Check if `url` is a valid source to import a Subversion repository. |
|
207 | Check if `url` is a valid source to import a Subversion repository. | |
206 | """ |
|
208 | """ | |
207 | # convert to URL if it's a local directory |
|
209 | # convert to URL if it's a local directory | |
208 | if os.path.isdir(url): |
|
210 | if os.path.isdir(url): | |
209 | url = 'file://' + urllib.pathname2url(url) |
|
211 | url = 'file://' + urllib.pathname2url(url) | |
210 | return connection.Svn.check_url(url, config.serialize()) |
|
212 | return connection.Svn.check_url(url, config.serialize()) | |
211 |
|
213 | |||
212 | @staticmethod |
|
214 | @staticmethod | |
213 | def is_valid_repository(path): |
|
215 | def is_valid_repository(path): | |
214 | try: |
|
216 | try: | |
215 | SubversionRepository(path) |
|
217 | SubversionRepository(path) | |
216 | return True |
|
218 | return True | |
217 | except VCSError: |
|
219 | except VCSError: | |
218 | pass |
|
220 | pass | |
219 | return False |
|
221 | return False | |
220 |
|
222 | |||
221 | def _check_path(self): |
|
223 | def _check_path(self): | |
222 | if not os.path.exists(self.path): |
|
224 | if not os.path.exists(self.path): | |
223 | raise VCSError('Path "%s" does not exist!' % (self.path, )) |
|
225 | raise VCSError('Path "%s" does not exist!' % (self.path, )) | |
224 | if not self._remote.is_path_valid_repository(self.path): |
|
226 | if not self._remote.is_path_valid_repository(self.path): | |
225 | raise VCSError( |
|
227 | raise VCSError( | |
226 | 'Path "%s" does not contain a Subversion repository' % |
|
228 | 'Path "%s" does not contain a Subversion repository' % | |
227 | (self.path, )) |
|
229 | (self.path, )) | |
228 |
|
230 | |||
229 | @LazyProperty |
|
231 | @LazyProperty | |
230 | def last_change(self): |
|
232 | def last_change(self): | |
231 | """ |
|
233 | """ | |
232 | Returns last change made on this repository as |
|
234 | Returns last change made on this repository as | |
233 | `datetime.datetime` object. |
|
235 | `datetime.datetime` object. | |
234 | """ |
|
236 | """ | |
235 | # Subversion always has a first commit which has id "0" and contains |
|
237 | # Subversion always has a first commit which has id "0" and contains | |
236 | # what we are looking for. |
|
238 | # what we are looking for. | |
237 | last_id = len(self.commit_ids) |
|
239 | last_id = len(self.commit_ids) | |
238 | properties = self._remote.revision_properties(last_id) |
|
240 | properties = self._remote.revision_properties(last_id) | |
239 | return _date_from_svn_properties(properties) |
|
241 | return _date_from_svn_properties(properties) | |
240 |
|
242 | |||
241 | @LazyProperty |
|
243 | @LazyProperty | |
242 | def in_memory_commit(self): |
|
244 | def in_memory_commit(self): | |
243 | return SubversionInMemoryCommit(self) |
|
245 | return SubversionInMemoryCommit(self) | |
244 |
|
246 | |||
245 | def get_hook_location(self): |
|
247 | def get_hook_location(self): | |
246 | """ |
|
248 | """ | |
247 | returns absolute path to location where hooks are stored |
|
249 | returns absolute path to location where hooks are stored | |
248 | """ |
|
250 | """ | |
249 | return os.path.join(self.path, 'hooks') |
|
251 | return os.path.join(self.path, 'hooks') | |
250 |
|
252 | |||
251 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): |
|
253 | def get_commit(self, commit_id=None, commit_idx=None, pre_load=None): | |
252 | if self.is_empty(): |
|
254 | if self.is_empty(): | |
253 | raise EmptyRepositoryError("There are no commits yet") |
|
255 | raise EmptyRepositoryError("There are no commits yet") | |
254 | if commit_id is not None: |
|
256 | if commit_id is not None: | |
255 | self._validate_commit_id(commit_id) |
|
257 | self._validate_commit_id(commit_id) | |
256 | elif commit_idx is not None: |
|
258 | elif commit_idx is not None: | |
257 | self._validate_commit_idx(commit_idx) |
|
259 | self._validate_commit_idx(commit_idx) | |
258 | try: |
|
260 | try: | |
259 | commit_id = self.commit_ids[commit_idx] |
|
261 | commit_id = self.commit_ids[commit_idx] | |
260 | except IndexError: |
|
262 | except IndexError: | |
261 | raise CommitDoesNotExistError |
|
263 | raise CommitDoesNotExistError | |
262 |
|
264 | |||
263 | commit_id = self._sanitize_commit_id(commit_id) |
|
265 | commit_id = self._sanitize_commit_id(commit_id) | |
264 | commit = SubversionCommit(repository=self, commit_id=commit_id) |
|
266 | commit = SubversionCommit(repository=self, commit_id=commit_id) | |
265 | return commit |
|
267 | return commit | |
266 |
|
268 | |||
267 | def get_commits( |
|
269 | def get_commits( | |
268 | self, start_id=None, end_id=None, start_date=None, end_date=None, |
|
270 | self, start_id=None, end_id=None, start_date=None, end_date=None, | |
269 | branch_name=None, show_hidden=False, pre_load=None): |
|
271 | branch_name=None, show_hidden=False, pre_load=None): | |
270 | if self.is_empty(): |
|
272 | if self.is_empty(): | |
271 | raise EmptyRepositoryError("There are no commit_ids yet") |
|
273 | raise EmptyRepositoryError("There are no commit_ids yet") | |
272 | self._validate_branch_name(branch_name) |
|
274 | self._validate_branch_name(branch_name) | |
273 |
|
275 | |||
274 | if start_id is not None: |
|
276 | if start_id is not None: | |
275 | self._validate_commit_id(start_id) |
|
277 | self._validate_commit_id(start_id) | |
276 | if end_id is not None: |
|
278 | if end_id is not None: | |
277 | self._validate_commit_id(end_id) |
|
279 | self._validate_commit_id(end_id) | |
278 |
|
280 | |||
279 | start_raw_id = self._sanitize_commit_id(start_id) |
|
281 | start_raw_id = self._sanitize_commit_id(start_id) | |
280 | start_pos = self.commit_ids.index(start_raw_id) if start_id else None |
|
282 | start_pos = self.commit_ids.index(start_raw_id) if start_id else None | |
281 | end_raw_id = self._sanitize_commit_id(end_id) |
|
283 | end_raw_id = self._sanitize_commit_id(end_id) | |
282 | end_pos = max(0, self.commit_ids.index(end_raw_id)) if end_id else None |
|
284 | end_pos = max(0, self.commit_ids.index(end_raw_id)) if end_id else None | |
283 |
|
285 | |||
284 | if None not in [start_id, end_id] and start_pos > end_pos: |
|
286 | if None not in [start_id, end_id] and start_pos > end_pos: | |
285 | raise RepositoryError( |
|
287 | raise RepositoryError( | |
286 | "Start commit '%s' cannot be after end commit '%s'" % |
|
288 | "Start commit '%s' cannot be after end commit '%s'" % | |
287 | (start_id, end_id)) |
|
289 | (start_id, end_id)) | |
288 | if end_pos is not None: |
|
290 | if end_pos is not None: | |
289 | end_pos += 1 |
|
291 | end_pos += 1 | |
290 |
|
292 | |||
291 | # Date based filtering |
|
293 | # Date based filtering | |
292 | if start_date or end_date: |
|
294 | if start_date or end_date: | |
293 | start_raw_id, end_raw_id = self._remote.lookup_interval( |
|
295 | start_raw_id, end_raw_id = self._remote.lookup_interval( | |
294 | date_astimestamp(start_date) if start_date else None, |
|
296 | date_astimestamp(start_date) if start_date else None, | |
295 | date_astimestamp(end_date) if end_date else None) |
|
297 | date_astimestamp(end_date) if end_date else None) | |
296 | start_pos = start_raw_id - 1 |
|
298 | start_pos = start_raw_id - 1 | |
297 | end_pos = end_raw_id |
|
299 | end_pos = end_raw_id | |
298 |
|
300 | |||
299 | commit_ids = self.commit_ids |
|
301 | commit_ids = self.commit_ids | |
300 |
|
302 | |||
301 | # TODO: johbo: Reconsider impact of DEFAULT_BRANCH_NAME here |
|
303 | # TODO: johbo: Reconsider impact of DEFAULT_BRANCH_NAME here | |
302 | if branch_name not in [None, self.DEFAULT_BRANCH_NAME]: |
|
304 | if branch_name not in [None, self.DEFAULT_BRANCH_NAME]: | |
303 | svn_rev = long(self.commit_ids[-1]) |
|
305 | svn_rev = long(self.commit_ids[-1]) | |
304 | commit_ids = self._remote.node_history( |
|
306 | commit_ids = self._remote.node_history( | |
305 | path=branch_name, revision=svn_rev, limit=None) |
|
307 | path=branch_name, revision=svn_rev, limit=None) | |
306 | commit_ids = [str(i) for i in reversed(commit_ids)] |
|
308 | commit_ids = [str(i) for i in reversed(commit_ids)] | |
307 |
|
309 | |||
308 | if start_pos or end_pos: |
|
310 | if start_pos or end_pos: | |
309 | commit_ids = commit_ids[start_pos:end_pos] |
|
311 | commit_ids = commit_ids[start_pos:end_pos] | |
310 | return base.CollectionGenerator(self, commit_ids, pre_load=pre_load) |
|
312 | return base.CollectionGenerator(self, commit_ids, pre_load=pre_load) | |
311 |
|
313 | |||
312 | def _sanitize_commit_id(self, commit_id): |
|
314 | def _sanitize_commit_id(self, commit_id): | |
313 | if commit_id and commit_id.isdigit(): |
|
315 | if commit_id and commit_id.isdigit(): | |
314 | if int(commit_id) <= len(self.commit_ids): |
|
316 | if int(commit_id) <= len(self.commit_ids): | |
315 | return commit_id |
|
317 | return commit_id | |
316 | else: |
|
318 | else: | |
317 | raise CommitDoesNotExistError( |
|
319 | raise CommitDoesNotExistError( | |
318 | "Commit %s does not exist." % (commit_id, )) |
|
320 | "Commit %s does not exist." % (commit_id, )) | |
319 | if commit_id not in [ |
|
321 | if commit_id not in [ | |
320 | None, 'HEAD', 'tip', self.DEFAULT_BRANCH_NAME]: |
|
322 | None, 'HEAD', 'tip', self.DEFAULT_BRANCH_NAME]: | |
321 | raise CommitDoesNotExistError( |
|
323 | raise CommitDoesNotExistError( | |
322 | "Commit id %s not understood." % (commit_id, )) |
|
324 | "Commit id %s not understood." % (commit_id, )) | |
323 | svn_rev = self._remote.lookup('HEAD') |
|
325 | svn_rev = self._remote.lookup('HEAD') | |
324 | return str(svn_rev) |
|
326 | return str(svn_rev) | |
325 |
|
327 | |||
326 | def get_diff( |
|
328 | def get_diff( | |
327 | self, commit1, commit2, path=None, ignore_whitespace=False, |
|
329 | self, commit1, commit2, path=None, ignore_whitespace=False, | |
328 | context=3, path1=None): |
|
330 | context=3, path1=None): | |
329 | self._validate_diff_commits(commit1, commit2) |
|
331 | self._validate_diff_commits(commit1, commit2) | |
330 | svn_rev1 = long(commit1.raw_id) |
|
332 | svn_rev1 = long(commit1.raw_id) | |
331 | svn_rev2 = long(commit2.raw_id) |
|
333 | svn_rev2 = long(commit2.raw_id) | |
332 | diff = self._remote.diff( |
|
334 | diff = self._remote.diff( | |
333 | svn_rev1, svn_rev2, path1=path1, path2=path, |
|
335 | svn_rev1, svn_rev2, path1=path1, path2=path, | |
334 | ignore_whitespace=ignore_whitespace, context=context) |
|
336 | ignore_whitespace=ignore_whitespace, context=context) | |
335 | return SubversionDiff(diff) |
|
337 | return SubversionDiff(diff) | |
336 |
|
338 | |||
337 |
|
339 | |||
338 | def _sanitize_url(url): |
|
340 | def _sanitize_url(url): | |
339 | if '://' not in url: |
|
341 | if '://' not in url: | |
340 | url = 'file://' + urllib.pathname2url(url) |
|
342 | url = 'file://' + urllib.pathname2url(url) | |
341 | return url |
|
343 | return url |
@@ -1,246 +1,253 b'' | |||||
1 | # -*- coding: utf-8 -*- |
|
1 | # -*- coding: utf-8 -*- | |
2 |
|
2 | |||
3 | # Copyright (C) 2016-2018 RhodeCode GmbH |
|
3 | # Copyright (C) 2016-2018 RhodeCode GmbH | |
4 | # |
|
4 | # | |
5 | # This program is free software: you can redistribute it and/or modify |
|
5 | # This program is free software: you can redistribute it and/or modify | |
6 | # it under the terms of the GNU Affero General Public License, version 3 |
|
6 | # it under the terms of the GNU Affero General Public License, version 3 | |
7 | # (only), as published by the Free Software Foundation. |
|
7 | # (only), as published by the Free Software Foundation. | |
8 | # |
|
8 | # | |
9 | # This program is distributed in the hope that it will be useful, |
|
9 | # This program is distributed in the hope that it will be useful, | |
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | # GNU General Public License for more details. |
|
12 | # GNU General Public License for more details. | |
13 | # |
|
13 | # | |
14 | # You should have received a copy of the GNU Affero General Public License |
|
14 | # You should have received a copy of the GNU Affero General Public License | |
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
15 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
16 | # |
|
16 | # | |
17 | # This program is dual-licensed. If you wish to learn more about the |
|
17 | # This program is dual-licensed. If you wish to learn more about the | |
18 | # RhodeCode Enterprise Edition, including its added features, Support services, |
|
18 | # RhodeCode Enterprise Edition, including its added features, Support services, | |
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ |
|
19 | # and proprietary license terms, please see https://rhodecode.com/licenses/ | |
20 |
|
20 | |||
21 | """ |
|
21 | """ | |
22 | This serves as a drop in replacement for pycurl. It implements the pycurl Curl |
|
22 | This serves as a drop in replacement for pycurl. It implements the pycurl Curl | |
23 | class in a way that is compatible with gevent. |
|
23 | class in a way that is compatible with gevent. | |
24 | """ |
|
24 | """ | |
25 |
|
25 | |||
26 |
|
26 | |||
27 | import logging |
|
27 | import logging | |
28 | import gevent |
|
28 | import gevent | |
29 | import pycurl |
|
29 | import pycurl | |
|
30 | import greenlet | |||
30 |
|
31 | |||
31 | # Import everything from pycurl. |
|
32 | # Import everything from pycurl. | |
32 | # This allows us to use this module as a drop in replacement of pycurl. |
|
33 | # This allows us to use this module as a drop in replacement of pycurl. | |
33 | from pycurl import * # noqa |
|
34 | from pycurl import * # noqa | |
34 |
|
35 | |||
35 | from gevent import core |
|
36 | from gevent import core | |
36 | from gevent.hub import Waiter |
|
37 | from gevent.hub import Waiter | |
37 |
|
38 | |||
38 |
|
39 | |||
39 | log = logging.getLogger(__name__) |
|
40 | log = logging.getLogger(__name__) | |
40 |
|
41 | |||
41 |
|
42 | |||
42 | class GeventCurlMulti(object): |
|
43 | class GeventCurlMulti(object): | |
43 | """ |
|
44 | """ | |
44 | Wrapper around pycurl.CurlMulti that integrates it into gevent's event |
|
45 | Wrapper around pycurl.CurlMulti that integrates it into gevent's event | |
45 | loop. |
|
46 | loop. | |
46 |
|
47 | |||
47 | Parts of this class are a modified version of code copied from the Tornado |
|
48 | Parts of this class are a modified version of code copied from the Tornado | |
48 | Web Server project which is licensed under the Apache License, Version 2.0 |
|
49 | Web Server project which is licensed under the Apache License, Version 2.0 | |
49 | (the "License"). To be more specific the code originates from this file: |
|
50 | (the "License"). To be more specific the code originates from this file: | |
50 | https://github.com/tornadoweb/tornado/blob/stable/tornado/curl_httpclient.py |
|
51 | https://github.com/tornadoweb/tornado/blob/stable/tornado/curl_httpclient.py | |
51 |
|
52 | |||
52 | This is the original license header of the origin: |
|
53 | This is the original license header of the origin: | |
53 |
|
54 | |||
54 | Copyright 2009 Facebook |
|
55 | Copyright 2009 Facebook | |
55 |
|
56 | |||
56 | Licensed under the Apache License, Version 2.0 (the "License"); you may |
|
57 | Licensed under the Apache License, Version 2.0 (the "License"); you may | |
57 | not use this file except in compliance with the License. You may obtain |
|
58 | not use this file except in compliance with the License. You may obtain | |
58 | a copy of the License at |
|
59 | a copy of the License at | |
59 |
|
60 | |||
60 | http://www.apache.org/licenses/LICENSE-2.0 |
|
61 | http://www.apache.org/licenses/LICENSE-2.0 | |
61 |
|
62 | |||
62 | Unless required by applicable law or agreed to in writing, software |
|
63 | Unless required by applicable law or agreed to in writing, software | |
63 | distributed under the License is distributed on an "AS IS" BASIS, |
|
64 | distributed under the License is distributed on an "AS IS" BASIS, | |
64 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
|
65 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or | |
65 | implied. See the License for the specific language governing |
|
66 | implied. See the License for the specific language governing | |
66 | permissions and limitations under the License. |
|
67 | permissions and limitations under the License. | |
67 | """ |
|
68 | """ | |
68 |
|
69 | |||
69 | def __init__(self, loop=None): |
|
70 | def __init__(self, loop=None): | |
70 | self._watchers = {} |
|
71 | self._watchers = {} | |
71 | self._timeout = None |
|
72 | self._timeout = None | |
72 | self.loop = loop or gevent.get_hub().loop |
|
73 | self.loop = loop or gevent.get_hub().loop | |
73 |
|
74 | |||
74 | # Setup curl's multi instance. |
|
75 | # Setup curl's multi instance. | |
75 | self._curl_multi = pycurl.CurlMulti() |
|
76 | self._curl_multi = pycurl.CurlMulti() | |
76 | self.setopt(pycurl.M_TIMERFUNCTION, self._set_timeout) |
|
77 | self.setopt(pycurl.M_TIMERFUNCTION, self._set_timeout) | |
77 | self.setopt(pycurl.M_SOCKETFUNCTION, self._handle_socket) |
|
78 | self.setopt(pycurl.M_SOCKETFUNCTION, self._handle_socket) | |
78 |
|
79 | |||
79 | def __getattr__(self, item): |
|
80 | def __getattr__(self, item): | |
80 | """ |
|
81 | """ | |
81 | The pycurl.CurlMulti class is final and we cannot subclass it. |
|
82 | The pycurl.CurlMulti class is final and we cannot subclass it. | |
82 | Therefore we are wrapping it and forward everything to it here. |
|
83 | Therefore we are wrapping it and forward everything to it here. | |
83 | """ |
|
84 | """ | |
84 | return getattr(self._curl_multi, item) |
|
85 | return getattr(self._curl_multi, item) | |
85 |
|
86 | |||
86 | def add_handle(self, curl): |
|
87 | def add_handle(self, curl): | |
87 | """ |
|
88 | """ | |
88 | Add handle variant that also takes care about the initial invocation of |
|
89 | Add handle variant that also takes care about the initial invocation of | |
89 | socket action method. This is done by setting an immediate timeout. |
|
90 | socket action method. This is done by setting an immediate timeout. | |
90 | """ |
|
91 | """ | |
91 | result = self._curl_multi.add_handle(curl) |
|
92 | result = self._curl_multi.add_handle(curl) | |
92 | self._set_timeout(0) |
|
93 | self._set_timeout(0) | |
93 | return result |
|
94 | return result | |
94 |
|
95 | |||
95 | def _handle_socket(self, event, fd, multi, data): |
|
96 | def _handle_socket(self, event, fd, multi, data): | |
96 | """ |
|
97 | """ | |
97 | Called by libcurl when it wants to change the file descriptors it cares |
|
98 | Called by libcurl when it wants to change the file descriptors it cares | |
98 | about. |
|
99 | about. | |
99 | """ |
|
100 | """ | |
100 | event_map = { |
|
101 | event_map = { | |
101 | pycurl.POLL_NONE: core.NONE, |
|
102 | pycurl.POLL_NONE: core.NONE, | |
102 | pycurl.POLL_IN: core.READ, |
|
103 | pycurl.POLL_IN: core.READ, | |
103 | pycurl.POLL_OUT: core.WRITE, |
|
104 | pycurl.POLL_OUT: core.WRITE, | |
104 | pycurl.POLL_INOUT: core.READ | core.WRITE |
|
105 | pycurl.POLL_INOUT: core.READ | core.WRITE | |
105 | } |
|
106 | } | |
106 |
|
107 | |||
107 | if event == pycurl.POLL_REMOVE: |
|
108 | if event == pycurl.POLL_REMOVE: | |
108 | watcher = self._watchers.pop(fd, None) |
|
109 | watcher = self._watchers.pop(fd, None) | |
109 | if watcher is not None: |
|
110 | if watcher is not None: | |
110 | watcher.stop() |
|
111 | watcher.stop() | |
111 | else: |
|
112 | else: | |
112 | gloop_event = event_map[event] |
|
113 | gloop_event = event_map[event] | |
113 | watcher = self._watchers.get(fd) |
|
114 | watcher = self._watchers.get(fd) | |
114 | if watcher is None: |
|
115 | if watcher is None: | |
115 | watcher = self.loop.io(fd, gloop_event) |
|
116 | watcher = self.loop.io(fd, gloop_event) | |
116 | watcher.start(self._handle_events, fd, pass_events=True) |
|
117 | watcher.start(self._handle_events, fd, pass_events=True) | |
117 | self._watchers[fd] = watcher |
|
118 | self._watchers[fd] = watcher | |
118 | else: |
|
119 | else: | |
119 | if watcher.events != gloop_event: |
|
120 | if watcher.events != gloop_event: | |
120 | watcher.stop() |
|
121 | watcher.stop() | |
121 | watcher.events = gloop_event |
|
122 | watcher.events = gloop_event | |
122 | watcher.start(self._handle_events, fd, pass_events=True) |
|
123 | watcher.start(self._handle_events, fd, pass_events=True) | |
123 |
|
124 | |||
124 | def _set_timeout(self, msecs): |
|
125 | def _set_timeout(self, msecs): | |
125 | """ |
|
126 | """ | |
126 | Called by libcurl to schedule a timeout. |
|
127 | Called by libcurl to schedule a timeout. | |
127 | """ |
|
128 | """ | |
128 | if self._timeout is not None: |
|
129 | if self._timeout is not None: | |
129 | self._timeout.stop() |
|
130 | self._timeout.stop() | |
130 | self._timeout = self.loop.timer(msecs/1000.0) |
|
131 | self._timeout = self.loop.timer(msecs/1000.0) | |
131 | self._timeout.start(self._handle_timeout) |
|
132 | self._timeout.start(self._handle_timeout) | |
132 |
|
133 | |||
133 | def _handle_events(self, events, fd): |
|
134 | def _handle_events(self, events, fd): | |
134 | action = 0 |
|
135 | action = 0 | |
135 | if events & core.READ: |
|
136 | if events & core.READ: | |
136 | action |= pycurl.CSELECT_IN |
|
137 | action |= pycurl.CSELECT_IN | |
137 | if events & core.WRITE: |
|
138 | if events & core.WRITE: | |
138 | action |= pycurl.CSELECT_OUT |
|
139 | action |= pycurl.CSELECT_OUT | |
139 | while True: |
|
140 | while True: | |
140 | try: |
|
141 | try: | |
141 | ret, num_handles = self._curl_multi.socket_action(fd, action) |
|
142 | ret, num_handles = self._curl_multi.socket_action(fd, action) | |
142 | except pycurl.error as e: |
|
143 | except pycurl.error as e: | |
143 | ret = e.args[0] |
|
144 | ret = e.args[0] | |
144 | if ret != pycurl.E_CALL_MULTI_PERFORM: |
|
145 | if ret != pycurl.E_CALL_MULTI_PERFORM: | |
145 | break |
|
146 | break | |
146 | self._finish_pending_requests() |
|
147 | self._finish_pending_requests() | |
147 |
|
148 | |||
148 | def _handle_timeout(self): |
|
149 | def _handle_timeout(self): | |
149 | """ |
|
150 | """ | |
150 | Called by IOLoop when the requested timeout has passed. |
|
151 | Called by IOLoop when the requested timeout has passed. | |
151 | """ |
|
152 | """ | |
152 | if self._timeout is not None: |
|
153 | if self._timeout is not None: | |
153 | self._timeout.stop() |
|
154 | self._timeout.stop() | |
154 | self._timeout = None |
|
155 | self._timeout = None | |
155 | while True: |
|
156 | while True: | |
156 | try: |
|
157 | try: | |
157 | ret, num_handles = self._curl_multi.socket_action( |
|
158 | ret, num_handles = self._curl_multi.socket_action( | |
158 | pycurl.SOCKET_TIMEOUT, 0) |
|
159 | pycurl.SOCKET_TIMEOUT, 0) | |
159 | except pycurl.error as e: |
|
160 | except pycurl.error as e: | |
160 | ret = e.args[0] |
|
161 | ret = e.args[0] | |
161 | if ret != pycurl.E_CALL_MULTI_PERFORM: |
|
162 | if ret != pycurl.E_CALL_MULTI_PERFORM: | |
162 | break |
|
163 | break | |
163 | self._finish_pending_requests() |
|
164 | self._finish_pending_requests() | |
164 |
|
165 | |||
165 | # In theory, we shouldn't have to do this because curl will call |
|
166 | # In theory, we shouldn't have to do this because curl will call | |
166 | # _set_timeout whenever the timeout changes. However, sometimes after |
|
167 | # _set_timeout whenever the timeout changes. However, sometimes after | |
167 | # _handle_timeout we will need to reschedule immediately even though |
|
168 | # _handle_timeout we will need to reschedule immediately even though | |
168 | # nothing has changed from curl's perspective. This is because when |
|
169 | # nothing has changed from curl's perspective. This is because when | |
169 | # socket_action is called with SOCKET_TIMEOUT, libcurl decides |
|
170 | # socket_action is called with SOCKET_TIMEOUT, libcurl decides | |
170 | # internally which timeouts need to be processed by using a monotonic |
|
171 | # internally which timeouts need to be processed by using a monotonic | |
171 | # clock (where available) while tornado uses python's time.time() to |
|
172 | # clock (where available) while tornado uses python's time.time() to | |
172 | # decide when timeouts have occurred. When those clocks disagree on |
|
173 | # decide when timeouts have occurred. When those clocks disagree on | |
173 | # elapsed time (as they will whenever there is an NTP adjustment), |
|
174 | # elapsed time (as they will whenever there is an NTP adjustment), | |
174 | # tornado might call _handle_timeout before libcurl is ready. After |
|
175 | # tornado might call _handle_timeout before libcurl is ready. After | |
175 | # each timeout, resync the scheduled timeout with libcurl's current |
|
176 | # each timeout, resync the scheduled timeout with libcurl's current | |
176 | # state. |
|
177 | # state. | |
177 | new_timeout = self._curl_multi.timeout() |
|
178 | new_timeout = self._curl_multi.timeout() | |
178 | if new_timeout >= 0: |
|
179 | if new_timeout >= 0: | |
179 | self._set_timeout(new_timeout) |
|
180 | self._set_timeout(new_timeout) | |
180 |
|
181 | |||
181 | def _finish_pending_requests(self): |
|
182 | def _finish_pending_requests(self): | |
182 | """ |
|
183 | """ | |
183 | Process any requests that were completed by the last call to |
|
184 | Process any requests that were completed by the last call to | |
184 | multi.socket_action. |
|
185 | multi.socket_action. | |
185 | """ |
|
186 | """ | |
186 | while True: |
|
187 | while True: | |
187 | num_q, ok_list, err_list = self._curl_multi.info_read() |
|
188 | num_q, ok_list, err_list = self._curl_multi.info_read() | |
188 | for curl in ok_list: |
|
189 | for curl in ok_list: | |
189 | curl.waiter.switch(None) |
|
190 | curl.waiter.switch(None) | |
190 | for curl, errnum, errmsg in err_list: |
|
191 | for curl, errnum, errmsg in err_list: | |
191 | curl.waiter.throw(Exception('%s %s' % (errnum, errmsg))) |
|
192 | curl.waiter.throw(Exception('%s %s' % (errnum, errmsg))) | |
192 | if num_q == 0: |
|
193 | if num_q == 0: | |
193 | break |
|
194 | break | |
194 |
|
195 | |||
195 |
|
196 | |||
196 | class GeventCurl(object): |
|
197 | class GeventCurl(object): | |
197 | """ |
|
198 | """ | |
198 | Gevent compatible implementation of the pycurl.Curl class. Essentially a |
|
199 | Gevent compatible implementation of the pycurl.Curl class. Essentially a | |
199 | wrapper around pycurl.Curl with a customized perform method. It uses the |
|
200 | wrapper around pycurl.Curl with a customized perform method. It uses the | |
200 | GeventCurlMulti class to implement a blocking API to libcurl's "easy" |
|
201 | GeventCurlMulti class to implement a blocking API to libcurl's "easy" | |
201 | interface. |
|
202 | interface. | |
202 | """ |
|
203 | """ | |
203 |
|
204 | |||
204 | # Reference to the GeventCurlMulti instance. |
|
205 | # Reference to the GeventCurlMulti instance. | |
205 | _multi_instance = None |
|
206 | _multi_instance = None | |
206 |
|
207 | |||
207 | def __init__(self): |
|
208 | def __init__(self): | |
208 | self._curl = pycurl.Curl() |
|
209 | self._curl = pycurl.Curl() | |
209 |
|
210 | |||
210 | def __getattr__(self, item): |
|
211 | def __getattr__(self, item): | |
211 | """ |
|
212 | """ | |
212 | The pycurl.Curl class is final and we cannot subclass it. Therefore we |
|
213 | The pycurl.Curl class is final and we cannot subclass it. Therefore we | |
213 | are wrapping it and forward everything to it here. |
|
214 | are wrapping it and forward everything to it here. | |
214 | """ |
|
215 | """ | |
215 | return getattr(self._curl, item) |
|
216 | return getattr(self._curl, item) | |
216 |
|
217 | |||
217 | @property |
|
218 | @property | |
218 | def _multi(self): |
|
219 | def _multi(self): | |
219 | """ |
|
220 | """ | |
220 | Lazy property that returns the GeventCurlMulti instance. The value is |
|
221 | Lazy property that returns the GeventCurlMulti instance. The value is | |
221 | cached as a class attribute. Therefore only one instance per process |
|
222 | cached as a class attribute. Therefore only one instance per process | |
222 | exists. |
|
223 | exists. | |
223 | """ |
|
224 | """ | |
224 | if GeventCurl._multi_instance is None: |
|
225 | if GeventCurl._multi_instance is None: | |
225 | GeventCurl._multi_instance = GeventCurlMulti() |
|
226 | GeventCurl._multi_instance = GeventCurlMulti() | |
226 | return GeventCurl._multi_instance |
|
227 | return GeventCurl._multi_instance | |
227 |
|
228 | |||
228 | def perform(self): |
|
229 | def perform(self): | |
229 | """ |
|
230 | """ | |
230 | This perform method is compatible with gevent because it uses gevent |
|
231 | This perform method is compatible with gevent because it uses gevent | |
231 | synchronization mechanisms to wait for the request to finish. |
|
232 | synchronization mechanisms to wait for the request to finish. | |
232 | """ |
|
233 | """ | |
|
234 | if getattr(self._curl, 'waiter', None) is not None: | |||
|
235 | current = greenlet.getcurrent() | |||
|
236 | msg = 'This curl object is already used by another greenlet, {}, \n' \ | |||
|
237 | 'this is {}'.format(self._curl.waiter, current) | |||
|
238 | raise Exception(msg) | |||
|
239 | ||||
233 | waiter = self._curl.waiter = Waiter() |
|
240 | waiter = self._curl.waiter = Waiter() | |
234 | try: |
|
241 | try: | |
235 | self._multi.add_handle(self._curl) |
|
242 | self._multi.add_handle(self._curl) | |
236 | try: |
|
243 | try: | |
237 | return waiter.get() |
|
244 | return waiter.get() | |
238 | finally: |
|
245 | finally: | |
239 | self._multi.remove_handle(self._curl) |
|
246 | self._multi.remove_handle(self._curl) | |
240 | finally: |
|
247 | finally: | |
241 | del self._curl.waiter |
|
248 | del self._curl.waiter | |
242 |
|
249 | |||
243 |
|
250 | |||
244 | # Curl is originally imported from pycurl. At this point we override it with |
|
251 | # Curl is originally imported from pycurl. At this point we override it with | |
245 | # our custom implementation. |
|
252 | # our custom implementation. | |
246 | Curl = GeventCurl |
|
253 | Curl = GeventCurl |
1 | NO CONTENT: modified file |
|
NO CONTENT: modified file | ||
The requested commit or file is too big and content was truncated. Show full diff |
General Comments 0
You need to be logged in to leave comments.
Login now