##// END OF EJS Templates
vcs: Use more specific merge error reason (either target or source ref missing)
Martin Bornhold -
r1080:1f73dd90 default
parent child Browse files
Show More
@@ -1,928 +1,928 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2014-2016 RhodeCode GmbH
3 # Copyright (C) 2014-2016 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 import shutil
28 import shutil
29 import time
29 import time
30
30
31 from zope.cachedescriptors.property import Lazy as LazyProperty
31 from zope.cachedescriptors.property import Lazy as LazyProperty
32
32
33 from rhodecode.lib.compat import OrderedDict
33 from rhodecode.lib.compat import OrderedDict
34 from rhodecode.lib.datelib import makedate, utcdate_fromtimestamp
34 from rhodecode.lib.datelib import makedate, utcdate_fromtimestamp
35 from rhodecode.lib.utils import safe_unicode, safe_str
35 from rhodecode.lib.utils import safe_unicode, safe_str
36 from rhodecode.lib.vcs import connection, path as vcspath
36 from rhodecode.lib.vcs import connection, path as vcspath
37 from rhodecode.lib.vcs.backends.base import (
37 from rhodecode.lib.vcs.backends.base import (
38 BaseRepository, CollectionGenerator, Config, MergeResponse,
38 BaseRepository, CollectionGenerator, Config, MergeResponse,
39 MergeFailureReason, Reference)
39 MergeFailureReason, Reference)
40 from rhodecode.lib.vcs.backends.git.commit import GitCommit
40 from rhodecode.lib.vcs.backends.git.commit import GitCommit
41 from rhodecode.lib.vcs.backends.git.diff import GitDiff
41 from rhodecode.lib.vcs.backends.git.diff import GitDiff
42 from rhodecode.lib.vcs.backends.git.inmemory import GitInMemoryCommit
42 from rhodecode.lib.vcs.backends.git.inmemory import GitInMemoryCommit
43 from rhodecode.lib.vcs.exceptions import (
43 from rhodecode.lib.vcs.exceptions import (
44 CommitDoesNotExistError, EmptyRepositoryError,
44 CommitDoesNotExistError, EmptyRepositoryError,
45 RepositoryError, TagAlreadyExistError, TagDoesNotExistError, VCSError)
45 RepositoryError, TagAlreadyExistError, TagDoesNotExistError, VCSError)
46
46
47
47
48 SHA_PATTERN = re.compile(r'^[[0-9a-fA-F]{12}|[0-9a-fA-F]{40}]$')
48 SHA_PATTERN = re.compile(r'^[[0-9a-fA-F]{12}|[0-9a-fA-F]{40}]$')
49
49
50 log = logging.getLogger(__name__)
50 log = logging.getLogger(__name__)
51
51
52
52
53 class GitRepository(BaseRepository):
53 class GitRepository(BaseRepository):
54 """
54 """
55 Git repository backend.
55 Git repository backend.
56 """
56 """
57 DEFAULT_BRANCH_NAME = 'master'
57 DEFAULT_BRANCH_NAME = 'master'
58
58
59 contact = BaseRepository.DEFAULT_CONTACT
59 contact = BaseRepository.DEFAULT_CONTACT
60
60
61 def __init__(self, repo_path, config=None, create=False, src_url=None,
61 def __init__(self, repo_path, config=None, create=False, src_url=None,
62 update_after_clone=False, with_wire=None, bare=False):
62 update_after_clone=False, with_wire=None, bare=False):
63
63
64 self.path = safe_str(os.path.abspath(repo_path))
64 self.path = safe_str(os.path.abspath(repo_path))
65 self.config = config if config else Config()
65 self.config = config if config else Config()
66 self._remote = connection.Git(
66 self._remote = connection.Git(
67 self.path, self.config, with_wire=with_wire)
67 self.path, self.config, with_wire=with_wire)
68
68
69 self._init_repo(create, src_url, update_after_clone, bare)
69 self._init_repo(create, src_url, update_after_clone, bare)
70
70
71 # caches
71 # caches
72 self._commit_ids = {}
72 self._commit_ids = {}
73
73
74 self.bookmarks = {}
74 self.bookmarks = {}
75
75
76 @LazyProperty
76 @LazyProperty
77 def bare(self):
77 def bare(self):
78 return self._remote.bare()
78 return self._remote.bare()
79
79
80 @LazyProperty
80 @LazyProperty
81 def head(self):
81 def head(self):
82 return self._remote.head()
82 return self._remote.head()
83
83
84 @LazyProperty
84 @LazyProperty
85 def commit_ids(self):
85 def commit_ids(self):
86 """
86 """
87 Returns list of commit ids, in ascending order. Being lazy
87 Returns list of commit ids, in ascending order. Being lazy
88 attribute allows external tools to inject commit ids from cache.
88 attribute allows external tools to inject commit ids from cache.
89 """
89 """
90 commit_ids = self._get_all_commit_ids()
90 commit_ids = self._get_all_commit_ids()
91 self._rebuild_cache(commit_ids)
91 self._rebuild_cache(commit_ids)
92 return commit_ids
92 return commit_ids
93
93
94 def _rebuild_cache(self, commit_ids):
94 def _rebuild_cache(self, commit_ids):
95 self._commit_ids = dict((commit_id, index)
95 self._commit_ids = dict((commit_id, index)
96 for index, commit_id in enumerate(commit_ids))
96 for index, commit_id in enumerate(commit_ids))
97
97
98 def run_git_command(self, cmd, **opts):
98 def run_git_command(self, cmd, **opts):
99 """
99 """
100 Runs given ``cmd`` as git command and returns tuple
100 Runs given ``cmd`` as git command and returns tuple
101 (stdout, stderr).
101 (stdout, stderr).
102
102
103 :param cmd: git command to be executed
103 :param cmd: git command to be executed
104 :param opts: env options to pass into Subprocess command
104 :param opts: env options to pass into Subprocess command
105 """
105 """
106 if not isinstance(cmd, list):
106 if not isinstance(cmd, list):
107 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))
108
108
109 out, err = self._remote.run_git_command(cmd, **opts)
109 out, err = self._remote.run_git_command(cmd, **opts)
110 log.debug('Stderr output of git command "%s":\n%s', cmd, err)
110 log.debug('Stderr output of git command "%s":\n%s', cmd, err)
111 return out, err
111 return out, err
112
112
113 @staticmethod
113 @staticmethod
114 def check_url(url, config):
114 def check_url(url, config):
115 """
115 """
116 Function will check given url and try to verify if it's a valid
116 Function will check given url and try to verify if it's a valid
117 link. Sometimes it may happened that git will issue basic
117 link. Sometimes it may happened that git will issue basic
118 auth request that can cause whole API to hang when used from python
118 auth request that can cause whole API to hang when used from python
119 or other external calls.
119 or other external calls.
120
120
121 On failures it'll raise urllib2.HTTPError, exception is also thrown
121 On failures it'll raise urllib2.HTTPError, exception is also thrown
122 when the return code is non 200
122 when the return code is non 200
123 """
123 """
124 # check first if it's not an url
124 # check first if it's not an url
125 if os.path.isdir(url) or url.startswith('file:'):
125 if os.path.isdir(url) or url.startswith('file:'):
126 return True
126 return True
127
127
128 if '+' in url.split('://', 1)[0]:
128 if '+' in url.split('://', 1)[0]:
129 url = url.split('+', 1)[1]
129 url = url.split('+', 1)[1]
130
130
131 # Request the _remote to verify the url
131 # Request the _remote to verify the url
132 return connection.Git.check_url(url, config.serialize())
132 return connection.Git.check_url(url, config.serialize())
133
133
134 @staticmethod
134 @staticmethod
135 def is_valid_repository(path):
135 def is_valid_repository(path):
136 if os.path.isdir(os.path.join(path, '.git')):
136 if os.path.isdir(os.path.join(path, '.git')):
137 return True
137 return True
138 # check case of bare repository
138 # check case of bare repository
139 try:
139 try:
140 GitRepository(path)
140 GitRepository(path)
141 return True
141 return True
142 except VCSError:
142 except VCSError:
143 pass
143 pass
144 return False
144 return False
145
145
146 def _init_repo(self, create, src_url=None, update_after_clone=False,
146 def _init_repo(self, create, src_url=None, update_after_clone=False,
147 bare=False):
147 bare=False):
148 if create and os.path.exists(self.path):
148 if create and os.path.exists(self.path):
149 raise RepositoryError(
149 raise RepositoryError(
150 "Cannot create repository at %s, location already exist"
150 "Cannot create repository at %s, location already exist"
151 % self.path)
151 % self.path)
152
152
153 try:
153 try:
154 if create and src_url:
154 if create and src_url:
155 GitRepository.check_url(src_url, self.config)
155 GitRepository.check_url(src_url, self.config)
156 self.clone(src_url, update_after_clone, bare)
156 self.clone(src_url, update_after_clone, bare)
157 elif create:
157 elif create:
158 os.makedirs(self.path, mode=0755)
158 os.makedirs(self.path, mode=0755)
159
159
160 if bare:
160 if bare:
161 self._remote.init_bare()
161 self._remote.init_bare()
162 else:
162 else:
163 self._remote.init()
163 self._remote.init()
164 else:
164 else:
165 self._remote.assert_correct_path()
165 self._remote.assert_correct_path()
166 # TODO: johbo: check if we have to translate the OSError here
166 # TODO: johbo: check if we have to translate the OSError here
167 except OSError as err:
167 except OSError as err:
168 raise RepositoryError(err)
168 raise RepositoryError(err)
169
169
170 def _get_all_commit_ids(self, filters=None):
170 def _get_all_commit_ids(self, filters=None):
171 # we must check if this repo is not empty, since later command
171 # we must check if this repo is not empty, since later command
172 # fails if it is. And it's cheaper to ask than throw the subprocess
172 # fails if it is. And it's cheaper to ask than throw the subprocess
173 # errors
173 # errors
174 try:
174 try:
175 self._remote.head()
175 self._remote.head()
176 except KeyError:
176 except KeyError:
177 return []
177 return []
178
178
179 rev_filter = ['--branches', '--tags']
179 rev_filter = ['--branches', '--tags']
180 extra_filter = []
180 extra_filter = []
181
181
182 if filters:
182 if filters:
183 if filters.get('since'):
183 if filters.get('since'):
184 extra_filter.append('--since=%s' % (filters['since']))
184 extra_filter.append('--since=%s' % (filters['since']))
185 if filters.get('until'):
185 if filters.get('until'):
186 extra_filter.append('--until=%s' % (filters['until']))
186 extra_filter.append('--until=%s' % (filters['until']))
187 if filters.get('branch_name'):
187 if filters.get('branch_name'):
188 rev_filter = ['--tags']
188 rev_filter = ['--tags']
189 extra_filter.append(filters['branch_name'])
189 extra_filter.append(filters['branch_name'])
190 rev_filter.extend(extra_filter)
190 rev_filter.extend(extra_filter)
191
191
192 # if filters.get('start') or filters.get('end'):
192 # if filters.get('start') or filters.get('end'):
193 # # skip is offset, max-count is limit
193 # # skip is offset, max-count is limit
194 # if filters.get('start'):
194 # if filters.get('start'):
195 # extra_filter += ' --skip=%s' % filters['start']
195 # extra_filter += ' --skip=%s' % filters['start']
196 # if filters.get('end'):
196 # if filters.get('end'):
197 # extra_filter += ' --max-count=%s' % (filters['end'] - (filters['start'] or 0))
197 # extra_filter += ' --max-count=%s' % (filters['end'] - (filters['start'] or 0))
198
198
199 cmd = ['rev-list', '--reverse', '--date-order'] + rev_filter
199 cmd = ['rev-list', '--reverse', '--date-order'] + rev_filter
200 try:
200 try:
201 output, __ = self.run_git_command(cmd)
201 output, __ = self.run_git_command(cmd)
202 except RepositoryError:
202 except RepositoryError:
203 # Can be raised for empty repositories
203 # Can be raised for empty repositories
204 return []
204 return []
205 return output.splitlines()
205 return output.splitlines()
206
206
207 def _get_commit_id(self, commit_id_or_idx):
207 def _get_commit_id(self, commit_id_or_idx):
208 def is_null(value):
208 def is_null(value):
209 return len(value) == commit_id_or_idx.count('0')
209 return len(value) == commit_id_or_idx.count('0')
210
210
211 if self.is_empty():
211 if self.is_empty():
212 raise EmptyRepositoryError("There are no commits yet")
212 raise EmptyRepositoryError("There are no commits yet")
213
213
214 if commit_id_or_idx in (None, '', 'tip', 'HEAD', 'head', -1):
214 if commit_id_or_idx in (None, '', 'tip', 'HEAD', 'head', -1):
215 return self.commit_ids[-1]
215 return self.commit_ids[-1]
216
216
217 is_bstr = isinstance(commit_id_or_idx, (str, unicode))
217 is_bstr = isinstance(commit_id_or_idx, (str, unicode))
218 if ((is_bstr and commit_id_or_idx.isdigit() and len(commit_id_or_idx) < 12)
218 if ((is_bstr and commit_id_or_idx.isdigit() and len(commit_id_or_idx) < 12)
219 or isinstance(commit_id_or_idx, int) or is_null(commit_id_or_idx)):
219 or isinstance(commit_id_or_idx, int) or is_null(commit_id_or_idx)):
220 try:
220 try:
221 commit_id_or_idx = self.commit_ids[int(commit_id_or_idx)]
221 commit_id_or_idx = self.commit_ids[int(commit_id_or_idx)]
222 except Exception:
222 except Exception:
223 msg = "Commit %s does not exist for %s" % (
223 msg = "Commit %s does not exist for %s" % (
224 commit_id_or_idx, self)
224 commit_id_or_idx, self)
225 raise CommitDoesNotExistError(msg)
225 raise CommitDoesNotExistError(msg)
226
226
227 elif is_bstr:
227 elif is_bstr:
228 # check full path ref, eg. refs/heads/master
228 # check full path ref, eg. refs/heads/master
229 ref_id = self._refs.get(commit_id_or_idx)
229 ref_id = self._refs.get(commit_id_or_idx)
230 if ref_id:
230 if ref_id:
231 return ref_id
231 return ref_id
232
232
233 # check branch name
233 # check branch name
234 branch_ids = self.branches.values()
234 branch_ids = self.branches.values()
235 ref_id = self._refs.get('refs/heads/%s' % commit_id_or_idx)
235 ref_id = self._refs.get('refs/heads/%s' % commit_id_or_idx)
236 if ref_id:
236 if ref_id:
237 return ref_id
237 return ref_id
238
238
239 # check tag name
239 # check tag name
240 ref_id = self._refs.get('refs/tags/%s' % commit_id_or_idx)
240 ref_id = self._refs.get('refs/tags/%s' % commit_id_or_idx)
241 if ref_id:
241 if ref_id:
242 return ref_id
242 return ref_id
243
243
244 if (not SHA_PATTERN.match(commit_id_or_idx) or
244 if (not SHA_PATTERN.match(commit_id_or_idx) or
245 commit_id_or_idx not in self.commit_ids):
245 commit_id_or_idx not in self.commit_ids):
246 msg = "Commit %s does not exist for %s" % (
246 msg = "Commit %s does not exist for %s" % (
247 commit_id_or_idx, self)
247 commit_id_or_idx, self)
248 raise CommitDoesNotExistError(msg)
248 raise CommitDoesNotExistError(msg)
249
249
250 # Ensure we return full id
250 # Ensure we return full id
251 if not SHA_PATTERN.match(str(commit_id_or_idx)):
251 if not SHA_PATTERN.match(str(commit_id_or_idx)):
252 raise CommitDoesNotExistError(
252 raise CommitDoesNotExistError(
253 "Given commit id %s not recognized" % commit_id_or_idx)
253 "Given commit id %s not recognized" % commit_id_or_idx)
254 return commit_id_or_idx
254 return commit_id_or_idx
255
255
256 def get_hook_location(self):
256 def get_hook_location(self):
257 """
257 """
258 returns absolute path to location where hooks are stored
258 returns absolute path to location where hooks are stored
259 """
259 """
260 loc = os.path.join(self.path, 'hooks')
260 loc = os.path.join(self.path, 'hooks')
261 if not self.bare:
261 if not self.bare:
262 loc = os.path.join(self.path, '.git', 'hooks')
262 loc = os.path.join(self.path, '.git', 'hooks')
263 return loc
263 return loc
264
264
265 @LazyProperty
265 @LazyProperty
266 def last_change(self):
266 def last_change(self):
267 """
267 """
268 Returns last change made on this repository as
268 Returns last change made on this repository as
269 `datetime.datetime` object.
269 `datetime.datetime` object.
270 """
270 """
271 return utcdate_fromtimestamp(self._get_mtime(), makedate()[1])
271 return utcdate_fromtimestamp(self._get_mtime(), makedate()[1])
272
272
273 def _get_mtime(self):
273 def _get_mtime(self):
274 try:
274 try:
275 return time.mktime(self.get_commit().date.timetuple())
275 return time.mktime(self.get_commit().date.timetuple())
276 except RepositoryError:
276 except RepositoryError:
277 idx_loc = '' if self.bare else '.git'
277 idx_loc = '' if self.bare else '.git'
278 # fallback to filesystem
278 # fallback to filesystem
279 in_path = os.path.join(self.path, idx_loc, "index")
279 in_path = os.path.join(self.path, idx_loc, "index")
280 he_path = os.path.join(self.path, idx_loc, "HEAD")
280 he_path = os.path.join(self.path, idx_loc, "HEAD")
281 if os.path.exists(in_path):
281 if os.path.exists(in_path):
282 return os.stat(in_path).st_mtime
282 return os.stat(in_path).st_mtime
283 else:
283 else:
284 return os.stat(he_path).st_mtime
284 return os.stat(he_path).st_mtime
285
285
286 @LazyProperty
286 @LazyProperty
287 def description(self):
287 def description(self):
288 description = self._remote.get_description()
288 description = self._remote.get_description()
289 return safe_unicode(description or self.DEFAULT_DESCRIPTION)
289 return safe_unicode(description or self.DEFAULT_DESCRIPTION)
290
290
291 def _get_refs_entries(self, prefix='', reverse=False, strip_prefix=True):
291 def _get_refs_entries(self, prefix='', reverse=False, strip_prefix=True):
292 if self.is_empty():
292 if self.is_empty():
293 return OrderedDict()
293 return OrderedDict()
294
294
295 result = []
295 result = []
296 for ref, sha in self._refs.iteritems():
296 for ref, sha in self._refs.iteritems():
297 if ref.startswith(prefix):
297 if ref.startswith(prefix):
298 ref_name = ref
298 ref_name = ref
299 if strip_prefix:
299 if strip_prefix:
300 ref_name = ref[len(prefix):]
300 ref_name = ref[len(prefix):]
301 result.append((safe_unicode(ref_name), sha))
301 result.append((safe_unicode(ref_name), sha))
302
302
303 def get_name(entry):
303 def get_name(entry):
304 return entry[0]
304 return entry[0]
305
305
306 return OrderedDict(sorted(result, key=get_name, reverse=reverse))
306 return OrderedDict(sorted(result, key=get_name, reverse=reverse))
307
307
308 def _get_branches(self):
308 def _get_branches(self):
309 return self._get_refs_entries(prefix='refs/heads/', strip_prefix=True)
309 return self._get_refs_entries(prefix='refs/heads/', strip_prefix=True)
310
310
311 @LazyProperty
311 @LazyProperty
312 def branches(self):
312 def branches(self):
313 return self._get_branches()
313 return self._get_branches()
314
314
315 @LazyProperty
315 @LazyProperty
316 def branches_closed(self):
316 def branches_closed(self):
317 return {}
317 return {}
318
318
319 @LazyProperty
319 @LazyProperty
320 def branches_all(self):
320 def branches_all(self):
321 all_branches = {}
321 all_branches = {}
322 all_branches.update(self.branches)
322 all_branches.update(self.branches)
323 all_branches.update(self.branches_closed)
323 all_branches.update(self.branches_closed)
324 return all_branches
324 return all_branches
325
325
326 @LazyProperty
326 @LazyProperty
327 def tags(self):
327 def tags(self):
328 return self._get_tags()
328 return self._get_tags()
329
329
330 def _get_tags(self):
330 def _get_tags(self):
331 return self._get_refs_entries(
331 return self._get_refs_entries(
332 prefix='refs/tags/', strip_prefix=True, reverse=True)
332 prefix='refs/tags/', strip_prefix=True, reverse=True)
333
333
334 def tag(self, name, user, commit_id=None, message=None, date=None,
334 def tag(self, name, user, commit_id=None, message=None, date=None,
335 **kwargs):
335 **kwargs):
336 # TODO: fix this method to apply annotated tags correct with message
336 # TODO: fix this method to apply annotated tags correct with message
337 """
337 """
338 Creates and returns a tag for the given ``commit_id``.
338 Creates and returns a tag for the given ``commit_id``.
339
339
340 :param name: name for new tag
340 :param name: name for new tag
341 :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
341 :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
342 :param commit_id: commit id for which new tag would be created
342 :param commit_id: commit id for which new tag would be created
343 :param message: message of the tag's commit
343 :param message: message of the tag's commit
344 :param date: date of tag's commit
344 :param date: date of tag's commit
345
345
346 :raises TagAlreadyExistError: if tag with same name already exists
346 :raises TagAlreadyExistError: if tag with same name already exists
347 """
347 """
348 if name in self.tags:
348 if name in self.tags:
349 raise TagAlreadyExistError("Tag %s already exists" % name)
349 raise TagAlreadyExistError("Tag %s already exists" % name)
350 commit = self.get_commit(commit_id=commit_id)
350 commit = self.get_commit(commit_id=commit_id)
351 message = message or "Added tag %s for commit %s" % (
351 message = message or "Added tag %s for commit %s" % (
352 name, commit.raw_id)
352 name, commit.raw_id)
353 self._remote.set_refs('refs/tags/%s' % name, commit._commit['id'])
353 self._remote.set_refs('refs/tags/%s' % name, commit._commit['id'])
354
354
355 self._refs = self._get_refs()
355 self._refs = self._get_refs()
356 self.tags = self._get_tags()
356 self.tags = self._get_tags()
357 return commit
357 return commit
358
358
359 def remove_tag(self, name, user, message=None, date=None):
359 def remove_tag(self, name, user, message=None, date=None):
360 """
360 """
361 Removes tag with the given ``name``.
361 Removes tag with the given ``name``.
362
362
363 :param name: name of the tag to be removed
363 :param name: name of the tag to be removed
364 :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
364 :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
365 :param message: message of the tag's removal commit
365 :param message: message of the tag's removal commit
366 :param date: date of tag's removal commit
366 :param date: date of tag's removal commit
367
367
368 :raises TagDoesNotExistError: if tag with given name does not exists
368 :raises TagDoesNotExistError: if tag with given name does not exists
369 """
369 """
370 if name not in self.tags:
370 if name not in self.tags:
371 raise TagDoesNotExistError("Tag %s does not exist" % name)
371 raise TagDoesNotExistError("Tag %s does not exist" % name)
372 tagpath = vcspath.join(
372 tagpath = vcspath.join(
373 self._remote.get_refs_path(), 'refs', 'tags', name)
373 self._remote.get_refs_path(), 'refs', 'tags', name)
374 try:
374 try:
375 os.remove(tagpath)
375 os.remove(tagpath)
376 self._refs = self._get_refs()
376 self._refs = self._get_refs()
377 self.tags = self._get_tags()
377 self.tags = self._get_tags()
378 except OSError as e:
378 except OSError as e:
379 raise RepositoryError(e.strerror)
379 raise RepositoryError(e.strerror)
380
380
381 def _get_refs(self):
381 def _get_refs(self):
382 return self._remote.get_refs()
382 return self._remote.get_refs()
383
383
384 @LazyProperty
384 @LazyProperty
385 def _refs(self):
385 def _refs(self):
386 return self._get_refs()
386 return self._get_refs()
387
387
388 @property
388 @property
389 def _ref_tree(self):
389 def _ref_tree(self):
390 node = tree = {}
390 node = tree = {}
391 for ref, sha in self._refs.iteritems():
391 for ref, sha in self._refs.iteritems():
392 path = ref.split('/')
392 path = ref.split('/')
393 for bit in path[:-1]:
393 for bit in path[:-1]:
394 node = node.setdefault(bit, {})
394 node = node.setdefault(bit, {})
395 node[path[-1]] = sha
395 node[path[-1]] = sha
396 node = tree
396 node = tree
397 return tree
397 return tree
398
398
399 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
399 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
400 """
400 """
401 Returns `GitCommit` object representing commit from git repository
401 Returns `GitCommit` object representing commit from git repository
402 at the given `commit_id` or head (most recent commit) if None given.
402 at the given `commit_id` or head (most recent commit) if None given.
403 """
403 """
404 if commit_id is not None:
404 if commit_id is not None:
405 self._validate_commit_id(commit_id)
405 self._validate_commit_id(commit_id)
406 elif commit_idx is not None:
406 elif commit_idx is not None:
407 self._validate_commit_idx(commit_idx)
407 self._validate_commit_idx(commit_idx)
408 commit_id = commit_idx
408 commit_id = commit_idx
409 commit_id = self._get_commit_id(commit_id)
409 commit_id = self._get_commit_id(commit_id)
410 try:
410 try:
411 # Need to call remote to translate id for tagging scenario
411 # Need to call remote to translate id for tagging scenario
412 commit_id = self._remote.get_object(commit_id)["commit_id"]
412 commit_id = self._remote.get_object(commit_id)["commit_id"]
413 idx = self._commit_ids[commit_id]
413 idx = self._commit_ids[commit_id]
414 except KeyError:
414 except KeyError:
415 raise RepositoryError("Cannot get object with id %s" % commit_id)
415 raise RepositoryError("Cannot get object with id %s" % commit_id)
416
416
417 return GitCommit(self, commit_id, idx, pre_load=pre_load)
417 return GitCommit(self, commit_id, idx, pre_load=pre_load)
418
418
419 def get_commits(
419 def get_commits(
420 self, start_id=None, end_id=None, start_date=None, end_date=None,
420 self, start_id=None, end_id=None, start_date=None, end_date=None,
421 branch_name=None, pre_load=None):
421 branch_name=None, pre_load=None):
422 """
422 """
423 Returns generator of `GitCommit` objects from start to end (both
423 Returns generator of `GitCommit` objects from start to end (both
424 are inclusive), in ascending date order.
424 are inclusive), in ascending date order.
425
425
426 :param start_id: None, str(commit_id)
426 :param start_id: None, str(commit_id)
427 :param end_id: None, str(commit_id)
427 :param end_id: None, str(commit_id)
428 :param start_date: if specified, commits with commit date less than
428 :param start_date: if specified, commits with commit date less than
429 ``start_date`` would be filtered out from returned set
429 ``start_date`` would be filtered out from returned set
430 :param end_date: if specified, commits with commit date greater than
430 :param end_date: if specified, commits with commit date greater than
431 ``end_date`` would be filtered out from returned set
431 ``end_date`` would be filtered out from returned set
432 :param branch_name: if specified, commits not reachable from given
432 :param branch_name: if specified, commits not reachable from given
433 branch would be filtered out from returned set
433 branch would be filtered out from returned set
434
434
435 :raise BranchDoesNotExistError: If given `branch_name` does not
435 :raise BranchDoesNotExistError: If given `branch_name` does not
436 exist.
436 exist.
437 :raise CommitDoesNotExistError: If commits for given `start` or
437 :raise CommitDoesNotExistError: If commits for given `start` or
438 `end` could not be found.
438 `end` could not be found.
439
439
440 """
440 """
441 if self.is_empty():
441 if self.is_empty():
442 raise EmptyRepositoryError("There are no commits yet")
442 raise EmptyRepositoryError("There are no commits yet")
443 self._validate_branch_name(branch_name)
443 self._validate_branch_name(branch_name)
444
444
445 if start_id is not None:
445 if start_id is not None:
446 self._validate_commit_id(start_id)
446 self._validate_commit_id(start_id)
447 if end_id is not None:
447 if end_id is not None:
448 self._validate_commit_id(end_id)
448 self._validate_commit_id(end_id)
449
449
450 start_raw_id = self._get_commit_id(start_id)
450 start_raw_id = self._get_commit_id(start_id)
451 start_pos = self._commit_ids[start_raw_id] if start_id else None
451 start_pos = self._commit_ids[start_raw_id] if start_id else None
452 end_raw_id = self._get_commit_id(end_id)
452 end_raw_id = self._get_commit_id(end_id)
453 end_pos = max(0, self._commit_ids[end_raw_id]) if end_id else None
453 end_pos = max(0, self._commit_ids[end_raw_id]) if end_id else None
454
454
455 if None not in [start_id, end_id] and start_pos > end_pos:
455 if None not in [start_id, end_id] and start_pos > end_pos:
456 raise RepositoryError(
456 raise RepositoryError(
457 "Start commit '%s' cannot be after end commit '%s'" %
457 "Start commit '%s' cannot be after end commit '%s'" %
458 (start_id, end_id))
458 (start_id, end_id))
459
459
460 if end_pos is not None:
460 if end_pos is not None:
461 end_pos += 1
461 end_pos += 1
462
462
463 filter_ = []
463 filter_ = []
464 if branch_name:
464 if branch_name:
465 filter_.append({'branch_name': branch_name})
465 filter_.append({'branch_name': branch_name})
466 if start_date and not end_date:
466 if start_date and not end_date:
467 filter_.append({'since': start_date})
467 filter_.append({'since': start_date})
468 if end_date and not start_date:
468 if end_date and not start_date:
469 filter_.append({'until': end_date})
469 filter_.append({'until': end_date})
470 if start_date and end_date:
470 if start_date and end_date:
471 filter_.append({'since': start_date})
471 filter_.append({'since': start_date})
472 filter_.append({'until': end_date})
472 filter_.append({'until': end_date})
473
473
474 # if start_pos or end_pos:
474 # if start_pos or end_pos:
475 # filter_.append({'start': start_pos})
475 # filter_.append({'start': start_pos})
476 # filter_.append({'end': end_pos})
476 # filter_.append({'end': end_pos})
477
477
478 if filter_:
478 if filter_:
479 revfilters = {
479 revfilters = {
480 'branch_name': branch_name,
480 'branch_name': branch_name,
481 'since': start_date.strftime('%m/%d/%y %H:%M:%S') if start_date else None,
481 'since': start_date.strftime('%m/%d/%y %H:%M:%S') if start_date else None,
482 'until': end_date.strftime('%m/%d/%y %H:%M:%S') if end_date else None,
482 'until': end_date.strftime('%m/%d/%y %H:%M:%S') if end_date else None,
483 'start': start_pos,
483 'start': start_pos,
484 'end': end_pos,
484 'end': end_pos,
485 }
485 }
486 commit_ids = self._get_all_commit_ids(filters=revfilters)
486 commit_ids = self._get_all_commit_ids(filters=revfilters)
487
487
488 # pure python stuff, it's slow due to walker walking whole repo
488 # pure python stuff, it's slow due to walker walking whole repo
489 # def get_revs(walker):
489 # def get_revs(walker):
490 # for walker_entry in walker:
490 # for walker_entry in walker:
491 # yield walker_entry.commit.id
491 # yield walker_entry.commit.id
492 # revfilters = {}
492 # revfilters = {}
493 # commit_ids = list(reversed(list(get_revs(self._repo.get_walker(**revfilters)))))
493 # commit_ids = list(reversed(list(get_revs(self._repo.get_walker(**revfilters)))))
494 else:
494 else:
495 commit_ids = self.commit_ids
495 commit_ids = self.commit_ids
496
496
497 if start_pos or end_pos:
497 if start_pos or end_pos:
498 commit_ids = commit_ids[start_pos: end_pos]
498 commit_ids = commit_ids[start_pos: end_pos]
499
499
500 return CollectionGenerator(self, commit_ids, pre_load=pre_load)
500 return CollectionGenerator(self, commit_ids, pre_load=pre_load)
501
501
502 def get_diff(
502 def get_diff(
503 self, commit1, commit2, path='', ignore_whitespace=False,
503 self, commit1, commit2, path='', ignore_whitespace=False,
504 context=3, path1=None):
504 context=3, path1=None):
505 """
505 """
506 Returns (git like) *diff*, as plain text. Shows changes introduced by
506 Returns (git like) *diff*, as plain text. Shows changes introduced by
507 ``commit2`` since ``commit1``.
507 ``commit2`` since ``commit1``.
508
508
509 :param commit1: Entry point from which diff is shown. Can be
509 :param commit1: Entry point from which diff is shown. Can be
510 ``self.EMPTY_COMMIT`` - in this case, patch showing all
510 ``self.EMPTY_COMMIT`` - in this case, patch showing all
511 the changes since empty state of the repository until ``commit2``
511 the changes since empty state of the repository until ``commit2``
512 :param commit2: Until which commits changes should be shown.
512 :param commit2: Until which commits changes should be shown.
513 :param ignore_whitespace: If set to ``True``, would not show whitespace
513 :param ignore_whitespace: If set to ``True``, would not show whitespace
514 changes. Defaults to ``False``.
514 changes. Defaults to ``False``.
515 :param context: How many lines before/after changed lines should be
515 :param context: How many lines before/after changed lines should be
516 shown. Defaults to ``3``.
516 shown. Defaults to ``3``.
517 """
517 """
518 self._validate_diff_commits(commit1, commit2)
518 self._validate_diff_commits(commit1, commit2)
519 if path1 is not None and path1 != path:
519 if path1 is not None and path1 != path:
520 raise ValueError("Diff of two different paths not supported.")
520 raise ValueError("Diff of two different paths not supported.")
521
521
522 flags = [
522 flags = [
523 '-U%s' % context, '--full-index', '--binary', '-p',
523 '-U%s' % context, '--full-index', '--binary', '-p',
524 '-M', '--abbrev=40']
524 '-M', '--abbrev=40']
525 if ignore_whitespace:
525 if ignore_whitespace:
526 flags.append('-w')
526 flags.append('-w')
527
527
528 if commit1 == self.EMPTY_COMMIT:
528 if commit1 == self.EMPTY_COMMIT:
529 cmd = ['show'] + flags + [commit2.raw_id]
529 cmd = ['show'] + flags + [commit2.raw_id]
530 else:
530 else:
531 cmd = ['diff'] + flags + [commit1.raw_id, commit2.raw_id]
531 cmd = ['diff'] + flags + [commit1.raw_id, commit2.raw_id]
532
532
533 if path:
533 if path:
534 cmd.extend(['--', path])
534 cmd.extend(['--', path])
535
535
536 stdout, __ = self.run_git_command(cmd)
536 stdout, __ = self.run_git_command(cmd)
537 # If we used 'show' command, strip first few lines (until actual diff
537 # If we used 'show' command, strip first few lines (until actual diff
538 # starts)
538 # starts)
539 if commit1 == self.EMPTY_COMMIT:
539 if commit1 == self.EMPTY_COMMIT:
540 lines = stdout.splitlines()
540 lines = stdout.splitlines()
541 x = 0
541 x = 0
542 for line in lines:
542 for line in lines:
543 if line.startswith('diff'):
543 if line.startswith('diff'):
544 break
544 break
545 x += 1
545 x += 1
546 # Append new line just like 'diff' command do
546 # Append new line just like 'diff' command do
547 stdout = '\n'.join(lines[x:]) + '\n'
547 stdout = '\n'.join(lines[x:]) + '\n'
548 return GitDiff(stdout)
548 return GitDiff(stdout)
549
549
550 def strip(self, commit_id, branch_name):
550 def strip(self, commit_id, branch_name):
551 commit = self.get_commit(commit_id=commit_id)
551 commit = self.get_commit(commit_id=commit_id)
552 if commit.merge:
552 if commit.merge:
553 raise Exception('Cannot reset to merge commit')
553 raise Exception('Cannot reset to merge commit')
554
554
555 # parent is going to be the new head now
555 # parent is going to be the new head now
556 commit = commit.parents[0]
556 commit = commit.parents[0]
557 self._remote.set_refs('refs/heads/%s' % branch_name, commit.raw_id)
557 self._remote.set_refs('refs/heads/%s' % branch_name, commit.raw_id)
558
558
559 self.commit_ids = self._get_all_commit_ids()
559 self.commit_ids = self._get_all_commit_ids()
560 self._rebuild_cache(self.commit_ids)
560 self._rebuild_cache(self.commit_ids)
561
561
562 def get_common_ancestor(self, commit_id1, commit_id2, repo2):
562 def get_common_ancestor(self, commit_id1, commit_id2, repo2):
563 if commit_id1 == commit_id2:
563 if commit_id1 == commit_id2:
564 return commit_id1
564 return commit_id1
565
565
566 if self != repo2:
566 if self != repo2:
567 commits = self._remote.get_missing_revs(
567 commits = self._remote.get_missing_revs(
568 commit_id1, commit_id2, repo2.path)
568 commit_id1, commit_id2, repo2.path)
569 if commits:
569 if commits:
570 commit = repo2.get_commit(commits[-1])
570 commit = repo2.get_commit(commits[-1])
571 if commit.parents:
571 if commit.parents:
572 ancestor_id = commit.parents[0].raw_id
572 ancestor_id = commit.parents[0].raw_id
573 else:
573 else:
574 ancestor_id = None
574 ancestor_id = None
575 else:
575 else:
576 # no commits from other repo, ancestor_id is the commit_id2
576 # no commits from other repo, ancestor_id is the commit_id2
577 ancestor_id = commit_id2
577 ancestor_id = commit_id2
578 else:
578 else:
579 output, __ = self.run_git_command(
579 output, __ = self.run_git_command(
580 ['merge-base', commit_id1, commit_id2])
580 ['merge-base', commit_id1, commit_id2])
581 ancestor_id = re.findall(r'[0-9a-fA-F]{40}', output)[0]
581 ancestor_id = re.findall(r'[0-9a-fA-F]{40}', output)[0]
582
582
583 return ancestor_id
583 return ancestor_id
584
584
585 def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
585 def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
586 repo1 = self
586 repo1 = self
587 ancestor_id = None
587 ancestor_id = None
588
588
589 if commit_id1 == commit_id2:
589 if commit_id1 == commit_id2:
590 commits = []
590 commits = []
591 elif repo1 != repo2:
591 elif repo1 != repo2:
592 missing_ids = self._remote.get_missing_revs(commit_id1, commit_id2,
592 missing_ids = self._remote.get_missing_revs(commit_id1, commit_id2,
593 repo2.path)
593 repo2.path)
594 commits = [
594 commits = [
595 repo2.get_commit(commit_id=commit_id, pre_load=pre_load)
595 repo2.get_commit(commit_id=commit_id, pre_load=pre_load)
596 for commit_id in reversed(missing_ids)]
596 for commit_id in reversed(missing_ids)]
597 else:
597 else:
598 output, __ = repo1.run_git_command(
598 output, __ = repo1.run_git_command(
599 ['log', '--reverse', '--pretty=format: %H', '-s',
599 ['log', '--reverse', '--pretty=format: %H', '-s',
600 '%s..%s' % (commit_id1, commit_id2)])
600 '%s..%s' % (commit_id1, commit_id2)])
601 commits = [
601 commits = [
602 repo1.get_commit(commit_id=commit_id, pre_load=pre_load)
602 repo1.get_commit(commit_id=commit_id, pre_load=pre_load)
603 for commit_id in re.findall(r'[0-9a-fA-F]{40}', output)]
603 for commit_id in re.findall(r'[0-9a-fA-F]{40}', output)]
604
604
605 return commits
605 return commits
606
606
607 @LazyProperty
607 @LazyProperty
608 def in_memory_commit(self):
608 def in_memory_commit(self):
609 """
609 """
610 Returns ``GitInMemoryCommit`` object for this repository.
610 Returns ``GitInMemoryCommit`` object for this repository.
611 """
611 """
612 return GitInMemoryCommit(self)
612 return GitInMemoryCommit(self)
613
613
614 def clone(self, url, update_after_clone=True, bare=False):
614 def clone(self, url, update_after_clone=True, bare=False):
615 """
615 """
616 Tries to clone commits from external location.
616 Tries to clone commits from external location.
617
617
618 :param update_after_clone: If set to ``False``, git won't checkout
618 :param update_after_clone: If set to ``False``, git won't checkout
619 working directory
619 working directory
620 :param bare: If set to ``True``, repository would be cloned into
620 :param bare: If set to ``True``, repository would be cloned into
621 *bare* git repository (no working directory at all).
621 *bare* git repository (no working directory at all).
622 """
622 """
623 # init_bare and init expect empty dir created to proceed
623 # init_bare and init expect empty dir created to proceed
624 if not os.path.exists(self.path):
624 if not os.path.exists(self.path):
625 os.mkdir(self.path)
625 os.mkdir(self.path)
626
626
627 if bare:
627 if bare:
628 self._remote.init_bare()
628 self._remote.init_bare()
629 else:
629 else:
630 self._remote.init()
630 self._remote.init()
631
631
632 deferred = '^{}'
632 deferred = '^{}'
633 valid_refs = ('refs/heads', 'refs/tags', 'HEAD')
633 valid_refs = ('refs/heads', 'refs/tags', 'HEAD')
634
634
635 return self._remote.clone(
635 return self._remote.clone(
636 url, deferred, valid_refs, update_after_clone)
636 url, deferred, valid_refs, update_after_clone)
637
637
638 def pull(self, url, commit_ids=None):
638 def pull(self, url, commit_ids=None):
639 """
639 """
640 Tries to pull changes from external location. We use fetch here since
640 Tries to pull changes from external location. We use fetch here since
641 pull in get does merges and we want to be compatible with hg backend so
641 pull in get does merges and we want to be compatible with hg backend so
642 pull == fetch in this case
642 pull == fetch in this case
643 """
643 """
644 self.fetch(url, commit_ids=commit_ids)
644 self.fetch(url, commit_ids=commit_ids)
645
645
646 def fetch(self, url, commit_ids=None):
646 def fetch(self, url, commit_ids=None):
647 """
647 """
648 Tries to fetch changes from external location.
648 Tries to fetch changes from external location.
649 """
649 """
650 refs = None
650 refs = None
651
651
652 if commit_ids is not None:
652 if commit_ids is not None:
653 remote_refs = self._remote.get_remote_refs(url)
653 remote_refs = self._remote.get_remote_refs(url)
654 refs = [
654 refs = [
655 ref for ref in remote_refs if remote_refs[ref] in commit_ids]
655 ref for ref in remote_refs if remote_refs[ref] in commit_ids]
656 self._remote.fetch(url, refs=refs)
656 self._remote.fetch(url, refs=refs)
657
657
658 def set_refs(self, ref_name, commit_id):
658 def set_refs(self, ref_name, commit_id):
659 self._remote.set_refs(ref_name, commit_id)
659 self._remote.set_refs(ref_name, commit_id)
660
660
661 def remove_ref(self, ref_name):
661 def remove_ref(self, ref_name):
662 self._remote.remove_ref(ref_name)
662 self._remote.remove_ref(ref_name)
663
663
664 def _update_server_info(self):
664 def _update_server_info(self):
665 """
665 """
666 runs gits update-server-info command in this repo instance
666 runs gits update-server-info command in this repo instance
667 """
667 """
668 self._remote.update_server_info()
668 self._remote.update_server_info()
669
669
670 def _current_branch(self):
670 def _current_branch(self):
671 """
671 """
672 Return the name of the current branch.
672 Return the name of the current branch.
673
673
674 It only works for non bare repositories (i.e. repositories with a
674 It only works for non bare repositories (i.e. repositories with a
675 working copy)
675 working copy)
676 """
676 """
677 if self.bare:
677 if self.bare:
678 raise RepositoryError('Bare git repos do not have active branches')
678 raise RepositoryError('Bare git repos do not have active branches')
679
679
680 if self.is_empty():
680 if self.is_empty():
681 return None
681 return None
682
682
683 stdout, _ = self.run_git_command(['rev-parse', '--abbrev-ref', 'HEAD'])
683 stdout, _ = self.run_git_command(['rev-parse', '--abbrev-ref', 'HEAD'])
684 return stdout.strip()
684 return stdout.strip()
685
685
686 def _checkout(self, branch_name, create=False):
686 def _checkout(self, branch_name, create=False):
687 """
687 """
688 Checkout a branch in the working directory.
688 Checkout a branch in the working directory.
689
689
690 It tries to create the branch if create is True, failing if the branch
690 It tries to create the branch if create is True, failing if the branch
691 already exists.
691 already exists.
692
692
693 It only works for non bare repositories (i.e. repositories with a
693 It only works for non bare repositories (i.e. repositories with a
694 working copy)
694 working copy)
695 """
695 """
696 if self.bare:
696 if self.bare:
697 raise RepositoryError('Cannot checkout branches in a bare git repo')
697 raise RepositoryError('Cannot checkout branches in a bare git repo')
698
698
699 cmd = ['checkout']
699 cmd = ['checkout']
700 if create:
700 if create:
701 cmd.append('-b')
701 cmd.append('-b')
702 cmd.append(branch_name)
702 cmd.append(branch_name)
703 self.run_git_command(cmd, fail_on_stderr=False)
703 self.run_git_command(cmd, fail_on_stderr=False)
704
704
705 def _local_clone(self, clone_path, branch_name):
705 def _local_clone(self, clone_path, branch_name):
706 """
706 """
707 Create a local clone of the current repo.
707 Create a local clone of the current repo.
708 """
708 """
709 # N.B.(skreft): the --branch option is required as otherwise the shallow
709 # N.B.(skreft): the --branch option is required as otherwise the shallow
710 # clone will only fetch the active branch.
710 # clone will only fetch the active branch.
711 cmd = ['clone', '--branch', branch_name, '--single-branch',
711 cmd = ['clone', '--branch', branch_name, '--single-branch',
712 self.path, os.path.abspath(clone_path)]
712 self.path, os.path.abspath(clone_path)]
713 self.run_git_command(cmd, fail_on_stderr=False)
713 self.run_git_command(cmd, fail_on_stderr=False)
714
714
715 def _local_fetch(self, repository_path, branch_name):
715 def _local_fetch(self, repository_path, branch_name):
716 """
716 """
717 Fetch a branch from a local repository.
717 Fetch a branch from a local repository.
718 """
718 """
719 repository_path = os.path.abspath(repository_path)
719 repository_path = os.path.abspath(repository_path)
720 if repository_path == self.path:
720 if repository_path == self.path:
721 raise ValueError('Cannot fetch from the same repository')
721 raise ValueError('Cannot fetch from the same repository')
722
722
723 cmd = ['fetch', '--no-tags', repository_path, branch_name]
723 cmd = ['fetch', '--no-tags', repository_path, branch_name]
724 self.run_git_command(cmd, fail_on_stderr=False)
724 self.run_git_command(cmd, fail_on_stderr=False)
725
725
726 def _last_fetch_heads(self):
726 def _last_fetch_heads(self):
727 """
727 """
728 Return the last fetched heads that need merging.
728 Return the last fetched heads that need merging.
729
729
730 The algorithm is defined at
730 The algorithm is defined at
731 https://github.com/git/git/blob/v2.1.3/git-pull.sh#L283
731 https://github.com/git/git/blob/v2.1.3/git-pull.sh#L283
732 """
732 """
733 if not self.bare:
733 if not self.bare:
734 fetch_heads_path = os.path.join(self.path, '.git', 'FETCH_HEAD')
734 fetch_heads_path = os.path.join(self.path, '.git', 'FETCH_HEAD')
735 else:
735 else:
736 fetch_heads_path = os.path.join(self.path, 'FETCH_HEAD')
736 fetch_heads_path = os.path.join(self.path, 'FETCH_HEAD')
737
737
738 heads = []
738 heads = []
739 with open(fetch_heads_path) as f:
739 with open(fetch_heads_path) as f:
740 for line in f:
740 for line in f:
741 if ' not-for-merge ' in line:
741 if ' not-for-merge ' in line:
742 continue
742 continue
743 line = re.sub('\t.*', '', line, flags=re.DOTALL)
743 line = re.sub('\t.*', '', line, flags=re.DOTALL)
744 heads.append(line)
744 heads.append(line)
745
745
746 return heads
746 return heads
747
747
748 def _local_pull(self, repository_path, branch_name):
748 def _local_pull(self, repository_path, branch_name):
749 """
749 """
750 Pull a branch from a local repository.
750 Pull a branch from a local repository.
751 """
751 """
752 if self.bare:
752 if self.bare:
753 raise RepositoryError('Cannot pull into a bare git repository')
753 raise RepositoryError('Cannot pull into a bare git repository')
754 # N.B.(skreft): The --ff-only option is to make sure this is a
754 # N.B.(skreft): The --ff-only option is to make sure this is a
755 # fast-forward (i.e., we are only pulling new changes and there are no
755 # fast-forward (i.e., we are only pulling new changes and there are no
756 # conflicts with our current branch)
756 # conflicts with our current branch)
757 # Additionally, that option needs to go before --no-tags, otherwise git
757 # Additionally, that option needs to go before --no-tags, otherwise git
758 # pull complains about it being an unknown flag.
758 # pull complains about it being an unknown flag.
759 cmd = ['pull', '--ff-only', '--no-tags', repository_path, branch_name]
759 cmd = ['pull', '--ff-only', '--no-tags', repository_path, branch_name]
760 self.run_git_command(cmd, fail_on_stderr=False)
760 self.run_git_command(cmd, fail_on_stderr=False)
761
761
762 def _local_merge(self, merge_message, user_name, user_email, heads):
762 def _local_merge(self, merge_message, user_name, user_email, heads):
763 """
763 """
764 Merge the given head into the checked out branch.
764 Merge the given head into the checked out branch.
765
765
766 It will force a merge commit.
766 It will force a merge commit.
767
767
768 Currently it raises an error if the repo is empty, as it is not possible
768 Currently it raises an error if the repo is empty, as it is not possible
769 to create a merge commit in an empty repo.
769 to create a merge commit in an empty repo.
770
770
771 :param merge_message: The message to use for the merge commit.
771 :param merge_message: The message to use for the merge commit.
772 :param heads: the heads to merge.
772 :param heads: the heads to merge.
773 """
773 """
774 if self.bare:
774 if self.bare:
775 raise RepositoryError('Cannot merge into a bare git repository')
775 raise RepositoryError('Cannot merge into a bare git repository')
776
776
777 if not heads:
777 if not heads:
778 return
778 return
779
779
780 if self.is_empty():
780 if self.is_empty():
781 # TODO(skreft): do somehting more robust in this case.
781 # TODO(skreft): do somehting more robust in this case.
782 raise RepositoryError(
782 raise RepositoryError(
783 'Do not know how to merge into empty repositories yet')
783 'Do not know how to merge into empty repositories yet')
784
784
785 # N.B.(skreft): the --no-ff option is used to enforce the creation of a
785 # N.B.(skreft): the --no-ff option is used to enforce the creation of a
786 # commit message. We also specify the user who is doing the merge.
786 # commit message. We also specify the user who is doing the merge.
787 cmd = ['-c', 'user.name=%s' % safe_str(user_name),
787 cmd = ['-c', 'user.name=%s' % safe_str(user_name),
788 '-c', 'user.email=%s' % safe_str(user_email),
788 '-c', 'user.email=%s' % safe_str(user_email),
789 'merge', '--no-ff', '-m', safe_str(merge_message)]
789 'merge', '--no-ff', '-m', safe_str(merge_message)]
790 cmd.extend(heads)
790 cmd.extend(heads)
791 try:
791 try:
792 self.run_git_command(cmd, fail_on_stderr=False)
792 self.run_git_command(cmd, fail_on_stderr=False)
793 except RepositoryError:
793 except RepositoryError:
794 # Cleanup any merge leftovers
794 # Cleanup any merge leftovers
795 self.run_git_command(['merge', '--abort'], fail_on_stderr=False)
795 self.run_git_command(['merge', '--abort'], fail_on_stderr=False)
796 raise
796 raise
797
797
798 def _local_push(
798 def _local_push(
799 self, source_branch, repository_path, target_branch,
799 self, source_branch, repository_path, target_branch,
800 enable_hooks=False, rc_scm_data=None):
800 enable_hooks=False, rc_scm_data=None):
801 """
801 """
802 Push the source_branch to the given repository and target_branch.
802 Push the source_branch to the given repository and target_branch.
803
803
804 Currently it if the target_branch is not master and the target repo is
804 Currently it if the target_branch is not master and the target repo is
805 empty, the push will work, but then GitRepository won't be able to find
805 empty, the push will work, but then GitRepository won't be able to find
806 the pushed branch or the commits. As the HEAD will be corrupted (i.e.,
806 the pushed branch or the commits. As the HEAD will be corrupted (i.e.,
807 pointing to master, which does not exist).
807 pointing to master, which does not exist).
808
808
809 It does not run the hooks in the target repo.
809 It does not run the hooks in the target repo.
810 """
810 """
811 # TODO(skreft): deal with the case in which the target repo is empty,
811 # TODO(skreft): deal with the case in which the target repo is empty,
812 # and the target_branch is not master.
812 # and the target_branch is not master.
813 target_repo = GitRepository(repository_path)
813 target_repo = GitRepository(repository_path)
814 if (not target_repo.bare and
814 if (not target_repo.bare and
815 target_repo._current_branch() == target_branch):
815 target_repo._current_branch() == target_branch):
816 # Git prevents pushing to the checked out branch, so simulate it by
816 # Git prevents pushing to the checked out branch, so simulate it by
817 # pulling into the target repository.
817 # pulling into the target repository.
818 target_repo._local_pull(self.path, source_branch)
818 target_repo._local_pull(self.path, source_branch)
819 else:
819 else:
820 cmd = ['push', os.path.abspath(repository_path),
820 cmd = ['push', os.path.abspath(repository_path),
821 '%s:%s' % (source_branch, target_branch)]
821 '%s:%s' % (source_branch, target_branch)]
822 gitenv = {}
822 gitenv = {}
823 if rc_scm_data:
823 if rc_scm_data:
824 gitenv.update({'RC_SCM_DATA': rc_scm_data})
824 gitenv.update({'RC_SCM_DATA': rc_scm_data})
825
825
826 if not enable_hooks:
826 if not enable_hooks:
827 gitenv['RC_SKIP_HOOKS'] = '1'
827 gitenv['RC_SKIP_HOOKS'] = '1'
828 self.run_git_command(cmd, fail_on_stderr=False, extra_env=gitenv)
828 self.run_git_command(cmd, fail_on_stderr=False, extra_env=gitenv)
829
829
830 def _get_new_pr_branch(self, source_branch, target_branch):
830 def _get_new_pr_branch(self, source_branch, target_branch):
831 prefix = 'pr_%s-%s_' % (source_branch, target_branch)
831 prefix = 'pr_%s-%s_' % (source_branch, target_branch)
832 pr_branches = []
832 pr_branches = []
833 for branch in self.branches:
833 for branch in self.branches:
834 if branch.startswith(prefix):
834 if branch.startswith(prefix):
835 pr_branches.append(int(branch[len(prefix):]))
835 pr_branches.append(int(branch[len(prefix):]))
836
836
837 if not pr_branches:
837 if not pr_branches:
838 branch_id = 0
838 branch_id = 0
839 else:
839 else:
840 branch_id = max(pr_branches) + 1
840 branch_id = max(pr_branches) + 1
841
841
842 return '%s%d' % (prefix, branch_id)
842 return '%s%d' % (prefix, branch_id)
843
843
844 def _merge_repo(self, shadow_repository_path, target_ref,
844 def _merge_repo(self, shadow_repository_path, target_ref,
845 source_repo, source_ref, merge_message,
845 source_repo, source_ref, merge_message,
846 merger_name, merger_email, dry_run=False,
846 merger_name, merger_email, dry_run=False,
847 use_rebase=False):
847 use_rebase=False):
848 if target_ref.commit_id != self.branches[target_ref.name]:
848 if target_ref.commit_id != self.branches[target_ref.name]:
849 return MergeResponse(
849 return MergeResponse(
850 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
850 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
851
851
852 shadow_repo = GitRepository(shadow_repository_path)
852 shadow_repo = GitRepository(shadow_repository_path)
853 shadow_repo._checkout(target_ref.name)
853 shadow_repo._checkout(target_ref.name)
854 shadow_repo._local_pull(self.path, target_ref.name)
854 shadow_repo._local_pull(self.path, target_ref.name)
855 # Need to reload repo to invalidate the cache, or otherwise we cannot
855 # Need to reload repo to invalidate the cache, or otherwise we cannot
856 # retrieve the last target commit.
856 # retrieve the last target commit.
857 shadow_repo = GitRepository(shadow_repository_path)
857 shadow_repo = GitRepository(shadow_repository_path)
858 if target_ref.commit_id != shadow_repo.branches[target_ref.name]:
858 if target_ref.commit_id != shadow_repo.branches[target_ref.name]:
859 return MergeResponse(
859 return MergeResponse(
860 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
860 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
861
861
862 pr_branch = shadow_repo._get_new_pr_branch(
862 pr_branch = shadow_repo._get_new_pr_branch(
863 source_ref.name, target_ref.name)
863 source_ref.name, target_ref.name)
864 shadow_repo._checkout(pr_branch, create=True)
864 shadow_repo._checkout(pr_branch, create=True)
865 try:
865 try:
866 shadow_repo._local_fetch(source_repo.path, source_ref.name)
866 shadow_repo._local_fetch(source_repo.path, source_ref.name)
867 except RepositoryError:
867 except RepositoryError:
868 log.exception('Failure when doing local fetch on git shadow repo')
868 log.exception('Failure when doing local fetch on git shadow repo')
869 return MergeResponse(
869 return MergeResponse(
870 False, False, None, MergeFailureReason.MISSING_COMMIT)
870 False, False, None, MergeFailureReason.MISSING_SOURCE_REF)
871
871
872 merge_ref = None
872 merge_ref = None
873 merge_failure_reason = MergeFailureReason.NONE
873 merge_failure_reason = MergeFailureReason.NONE
874 try:
874 try:
875 shadow_repo._local_merge(merge_message, merger_name, merger_email,
875 shadow_repo._local_merge(merge_message, merger_name, merger_email,
876 [source_ref.commit_id])
876 [source_ref.commit_id])
877 merge_possible = True
877 merge_possible = True
878
878
879 # Need to reload repo to invalidate the cache, or otherwise we
879 # Need to reload repo to invalidate the cache, or otherwise we
880 # cannot retrieve the merge commit.
880 # cannot retrieve the merge commit.
881 shadow_repo = GitRepository(shadow_repository_path)
881 shadow_repo = GitRepository(shadow_repository_path)
882 merge_commit_id = shadow_repo.branches[pr_branch]
882 merge_commit_id = shadow_repo.branches[pr_branch]
883
883
884 # Set a reference pointing to the merge commit. This reference may
884 # Set a reference pointing to the merge commit. This reference may
885 # be used to easily identify the last successful merge commit in
885 # be used to easily identify the last successful merge commit in
886 # the shadow repository.
886 # the shadow repository.
887 shadow_repo.set_refs('refs/heads/pr-merge', merge_commit_id)
887 shadow_repo.set_refs('refs/heads/pr-merge', merge_commit_id)
888 merge_ref = Reference('branch', 'pr-merge', merge_commit_id)
888 merge_ref = Reference('branch', 'pr-merge', merge_commit_id)
889 except RepositoryError:
889 except RepositoryError:
890 log.exception('Failure when doing local merge on git shadow repo')
890 log.exception('Failure when doing local merge on git shadow repo')
891 merge_possible = False
891 merge_possible = False
892 merge_failure_reason = MergeFailureReason.MERGE_FAILED
892 merge_failure_reason = MergeFailureReason.MERGE_FAILED
893
893
894 if merge_possible and not dry_run:
894 if merge_possible and not dry_run:
895 try:
895 try:
896 shadow_repo._local_push(
896 shadow_repo._local_push(
897 pr_branch, self.path, target_ref.name, enable_hooks=True,
897 pr_branch, self.path, target_ref.name, enable_hooks=True,
898 rc_scm_data=self.config.get('rhodecode', 'RC_SCM_DATA'))
898 rc_scm_data=self.config.get('rhodecode', 'RC_SCM_DATA'))
899 merge_succeeded = True
899 merge_succeeded = True
900 except RepositoryError:
900 except RepositoryError:
901 log.exception(
901 log.exception(
902 'Failure when doing local push on git shadow repo')
902 'Failure when doing local push on git shadow repo')
903 merge_succeeded = False
903 merge_succeeded = False
904 merge_failure_reason = MergeFailureReason.PUSH_FAILED
904 merge_failure_reason = MergeFailureReason.PUSH_FAILED
905 else:
905 else:
906 merge_succeeded = False
906 merge_succeeded = False
907
907
908 return MergeResponse(
908 return MergeResponse(
909 merge_possible, merge_succeeded, merge_ref,
909 merge_possible, merge_succeeded, merge_ref,
910 merge_failure_reason)
910 merge_failure_reason)
911
911
912 def _get_shadow_repository_path(self, workspace_id):
912 def _get_shadow_repository_path(self, workspace_id):
913 # The name of the shadow repository must start with '.', so it is
913 # The name of the shadow repository must start with '.', so it is
914 # skipped by 'rhodecode.lib.utils.get_filesystem_repos'.
914 # skipped by 'rhodecode.lib.utils.get_filesystem_repos'.
915 return os.path.join(
915 return os.path.join(
916 os.path.dirname(self.path),
916 os.path.dirname(self.path),
917 '.__shadow_%s_%s' % (os.path.basename(self.path), workspace_id))
917 '.__shadow_%s_%s' % (os.path.basename(self.path), workspace_id))
918
918
919 def _maybe_prepare_merge_workspace(self, workspace_id, target_ref):
919 def _maybe_prepare_merge_workspace(self, workspace_id, target_ref):
920 shadow_repository_path = self._get_shadow_repository_path(workspace_id)
920 shadow_repository_path = self._get_shadow_repository_path(workspace_id)
921 if not os.path.exists(shadow_repository_path):
921 if not os.path.exists(shadow_repository_path):
922 self._local_clone(shadow_repository_path, target_ref.name)
922 self._local_clone(shadow_repository_path, target_ref.name)
923
923
924 return shadow_repository_path
924 return shadow_repository_path
925
925
926 def cleanup_merge_workspace(self, workspace_id):
926 def cleanup_merge_workspace(self, workspace_id):
927 shadow_repository_path = self._get_shadow_repository_path(workspace_id)
927 shadow_repository_path = self._get_shadow_repository_path(workspace_id)
928 shutil.rmtree(shadow_repository_path, ignore_errors=True)
928 shutil.rmtree(shadow_repository_path, ignore_errors=True)
@@ -1,798 +1,803 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2014-2016 RhodeCode GmbH
3 # Copyright (C) 2014-2016 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
24
25 import logging
25 import logging
26 import binascii
26 import binascii
27 import os
27 import os
28 import shutil
28 import shutil
29 import urllib
29 import urllib
30
30
31 from zope.cachedescriptors.property import Lazy as LazyProperty
31 from zope.cachedescriptors.property import Lazy as LazyProperty
32
32
33 from rhodecode.lib.compat import OrderedDict
33 from rhodecode.lib.compat import OrderedDict
34 from rhodecode.lib.datelib import (
34 from rhodecode.lib.datelib import (
35 date_to_timestamp_plus_offset, utcdate_fromtimestamp, makedate,
35 date_to_timestamp_plus_offset, utcdate_fromtimestamp, makedate,
36 date_astimestamp)
36 date_astimestamp)
37 from rhodecode.lib.utils import safe_unicode, safe_str
37 from rhodecode.lib.utils import safe_unicode, safe_str
38 from rhodecode.lib.vcs import connection
38 from rhodecode.lib.vcs import connection
39 from rhodecode.lib.vcs.backends.base import (
39 from rhodecode.lib.vcs.backends.base import (
40 BaseRepository, CollectionGenerator, Config, MergeResponse,
40 BaseRepository, CollectionGenerator, Config, MergeResponse,
41 MergeFailureReason, Reference)
41 MergeFailureReason, Reference)
42 from rhodecode.lib.vcs.backends.hg.commit import MercurialCommit
42 from rhodecode.lib.vcs.backends.hg.commit import MercurialCommit
43 from rhodecode.lib.vcs.backends.hg.diff import MercurialDiff
43 from rhodecode.lib.vcs.backends.hg.diff import MercurialDiff
44 from rhodecode.lib.vcs.backends.hg.inmemory import MercurialInMemoryCommit
44 from rhodecode.lib.vcs.backends.hg.inmemory import MercurialInMemoryCommit
45 from rhodecode.lib.vcs.exceptions import (
45 from rhodecode.lib.vcs.exceptions import (
46 EmptyRepositoryError, RepositoryError, TagAlreadyExistError,
46 EmptyRepositoryError, RepositoryError, TagAlreadyExistError,
47 TagDoesNotExistError, CommitDoesNotExistError)
47 TagDoesNotExistError, CommitDoesNotExistError)
48
48
49 hexlify = binascii.hexlify
49 hexlify = binascii.hexlify
50 nullid = "\0" * 20
50 nullid = "\0" * 20
51
51
52 log = logging.getLogger(__name__)
52 log = logging.getLogger(__name__)
53
53
54
54
55 class MercurialRepository(BaseRepository):
55 class MercurialRepository(BaseRepository):
56 """
56 """
57 Mercurial repository backend
57 Mercurial repository backend
58 """
58 """
59 DEFAULT_BRANCH_NAME = 'default'
59 DEFAULT_BRANCH_NAME = 'default'
60
60
61 def __init__(self, repo_path, config=None, create=False, src_url=None,
61 def __init__(self, repo_path, config=None, create=False, src_url=None,
62 update_after_clone=False, with_wire=None):
62 update_after_clone=False, with_wire=None):
63 """
63 """
64 Raises RepositoryError if repository could not be find at the given
64 Raises RepositoryError if repository could not be find at the given
65 ``repo_path``.
65 ``repo_path``.
66
66
67 :param repo_path: local path of the repository
67 :param repo_path: local path of the repository
68 :param config: config object containing the repo configuration
68 :param config: config object containing the repo configuration
69 :param create=False: if set to True, would try to create repository if
69 :param create=False: if set to True, would try to create repository if
70 it does not exist rather than raising exception
70 it does not exist rather than raising exception
71 :param src_url=None: would try to clone repository from given location
71 :param src_url=None: would try to clone repository from given location
72 :param update_after_clone=False: sets update of working copy after
72 :param update_after_clone=False: sets update of working copy after
73 making a clone
73 making a clone
74 """
74 """
75 self.path = safe_str(os.path.abspath(repo_path))
75 self.path = safe_str(os.path.abspath(repo_path))
76 self.config = config if config else Config()
76 self.config = config if config else Config()
77 self._remote = connection.Hg(
77 self._remote = connection.Hg(
78 self.path, self.config, with_wire=with_wire)
78 self.path, self.config, with_wire=with_wire)
79
79
80 self._init_repo(create, src_url, update_after_clone)
80 self._init_repo(create, src_url, update_after_clone)
81
81
82 # caches
82 # caches
83 self._commit_ids = {}
83 self._commit_ids = {}
84
84
85 @LazyProperty
85 @LazyProperty
86 def commit_ids(self):
86 def commit_ids(self):
87 """
87 """
88 Returns list of commit ids, in ascending order. Being lazy
88 Returns list of commit ids, in ascending order. Being lazy
89 attribute allows external tools to inject shas from cache.
89 attribute allows external tools to inject shas from cache.
90 """
90 """
91 commit_ids = self._get_all_commit_ids()
91 commit_ids = self._get_all_commit_ids()
92 self._rebuild_cache(commit_ids)
92 self._rebuild_cache(commit_ids)
93 return commit_ids
93 return commit_ids
94
94
95 def _rebuild_cache(self, commit_ids):
95 def _rebuild_cache(self, commit_ids):
96 self._commit_ids = dict((commit_id, index)
96 self._commit_ids = dict((commit_id, index)
97 for index, commit_id in enumerate(commit_ids))
97 for index, commit_id in enumerate(commit_ids))
98
98
99 @LazyProperty
99 @LazyProperty
100 def branches(self):
100 def branches(self):
101 return self._get_branches()
101 return self._get_branches()
102
102
103 @LazyProperty
103 @LazyProperty
104 def branches_closed(self):
104 def branches_closed(self):
105 return self._get_branches(active=False, closed=True)
105 return self._get_branches(active=False, closed=True)
106
106
107 @LazyProperty
107 @LazyProperty
108 def branches_all(self):
108 def branches_all(self):
109 all_branches = {}
109 all_branches = {}
110 all_branches.update(self.branches)
110 all_branches.update(self.branches)
111 all_branches.update(self.branches_closed)
111 all_branches.update(self.branches_closed)
112 return all_branches
112 return all_branches
113
113
114 def _get_branches(self, active=True, closed=False):
114 def _get_branches(self, active=True, closed=False):
115 """
115 """
116 Gets branches for this repository
116 Gets branches for this repository
117 Returns only not closed active branches by default
117 Returns only not closed active branches by default
118
118
119 :param active: return also active branches
119 :param active: return also active branches
120 :param closed: return also closed branches
120 :param closed: return also closed branches
121
121
122 """
122 """
123 if self.is_empty():
123 if self.is_empty():
124 return {}
124 return {}
125
125
126 def get_name(ctx):
126 def get_name(ctx):
127 return ctx[0]
127 return ctx[0]
128
128
129 _branches = [(safe_unicode(n), hexlify(h),) for n, h in
129 _branches = [(safe_unicode(n), hexlify(h),) for n, h in
130 self._remote.branches(active, closed).items()]
130 self._remote.branches(active, closed).items()]
131
131
132 return OrderedDict(sorted(_branches, key=get_name, reverse=False))
132 return OrderedDict(sorted(_branches, key=get_name, reverse=False))
133
133
134 @LazyProperty
134 @LazyProperty
135 def tags(self):
135 def tags(self):
136 """
136 """
137 Gets tags for this repository
137 Gets tags for this repository
138 """
138 """
139 return self._get_tags()
139 return self._get_tags()
140
140
141 def _get_tags(self):
141 def _get_tags(self):
142 if self.is_empty():
142 if self.is_empty():
143 return {}
143 return {}
144
144
145 def get_name(ctx):
145 def get_name(ctx):
146 return ctx[0]
146 return ctx[0]
147
147
148 _tags = [(safe_unicode(n), hexlify(h),) for n, h in
148 _tags = [(safe_unicode(n), hexlify(h),) for n, h in
149 self._remote.tags().items()]
149 self._remote.tags().items()]
150
150
151 return OrderedDict(sorted(_tags, key=get_name, reverse=True))
151 return OrderedDict(sorted(_tags, key=get_name, reverse=True))
152
152
153 def tag(self, name, user, commit_id=None, message=None, date=None,
153 def tag(self, name, user, commit_id=None, message=None, date=None,
154 **kwargs):
154 **kwargs):
155 """
155 """
156 Creates and returns a tag for the given ``commit_id``.
156 Creates and returns a tag for the given ``commit_id``.
157
157
158 :param name: name for new tag
158 :param name: name for new tag
159 :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
159 :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
160 :param commit_id: commit id for which new tag would be created
160 :param commit_id: commit id for which new tag would be created
161 :param message: message of the tag's commit
161 :param message: message of the tag's commit
162 :param date: date of tag's commit
162 :param date: date of tag's commit
163
163
164 :raises TagAlreadyExistError: if tag with same name already exists
164 :raises TagAlreadyExistError: if tag with same name already exists
165 """
165 """
166 if name in self.tags:
166 if name in self.tags:
167 raise TagAlreadyExistError("Tag %s already exists" % name)
167 raise TagAlreadyExistError("Tag %s already exists" % name)
168 commit = self.get_commit(commit_id=commit_id)
168 commit = self.get_commit(commit_id=commit_id)
169 local = kwargs.setdefault('local', False)
169 local = kwargs.setdefault('local', False)
170
170
171 if message is None:
171 if message is None:
172 message = "Added tag %s for commit %s" % (name, commit.short_id)
172 message = "Added tag %s for commit %s" % (name, commit.short_id)
173
173
174 date, tz = date_to_timestamp_plus_offset(date)
174 date, tz = date_to_timestamp_plus_offset(date)
175
175
176 self._remote.tag(
176 self._remote.tag(
177 name, commit.raw_id, message, local, user, date, tz)
177 name, commit.raw_id, message, local, user, date, tz)
178 self._remote.invalidate_vcs_cache()
178 self._remote.invalidate_vcs_cache()
179
179
180 # Reinitialize tags
180 # Reinitialize tags
181 self.tags = self._get_tags()
181 self.tags = self._get_tags()
182 tag_id = self.tags[name]
182 tag_id = self.tags[name]
183
183
184 return self.get_commit(commit_id=tag_id)
184 return self.get_commit(commit_id=tag_id)
185
185
186 def remove_tag(self, name, user, message=None, date=None):
186 def remove_tag(self, name, user, message=None, date=None):
187 """
187 """
188 Removes tag with the given `name`.
188 Removes tag with the given `name`.
189
189
190 :param name: name of the tag to be removed
190 :param name: name of the tag to be removed
191 :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
191 :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
192 :param message: message of the tag's removal commit
192 :param message: message of the tag's removal commit
193 :param date: date of tag's removal commit
193 :param date: date of tag's removal commit
194
194
195 :raises TagDoesNotExistError: if tag with given name does not exists
195 :raises TagDoesNotExistError: if tag with given name does not exists
196 """
196 """
197 if name not in self.tags:
197 if name not in self.tags:
198 raise TagDoesNotExistError("Tag %s does not exist" % name)
198 raise TagDoesNotExistError("Tag %s does not exist" % name)
199 if message is None:
199 if message is None:
200 message = "Removed tag %s" % name
200 message = "Removed tag %s" % name
201 local = False
201 local = False
202
202
203 date, tz = date_to_timestamp_plus_offset(date)
203 date, tz = date_to_timestamp_plus_offset(date)
204
204
205 self._remote.tag(name, nullid, message, local, user, date, tz)
205 self._remote.tag(name, nullid, message, local, user, date, tz)
206 self._remote.invalidate_vcs_cache()
206 self._remote.invalidate_vcs_cache()
207 self.tags = self._get_tags()
207 self.tags = self._get_tags()
208
208
209 @LazyProperty
209 @LazyProperty
210 def bookmarks(self):
210 def bookmarks(self):
211 """
211 """
212 Gets bookmarks for this repository
212 Gets bookmarks for this repository
213 """
213 """
214 return self._get_bookmarks()
214 return self._get_bookmarks()
215
215
216 def _get_bookmarks(self):
216 def _get_bookmarks(self):
217 if self.is_empty():
217 if self.is_empty():
218 return {}
218 return {}
219
219
220 def get_name(ctx):
220 def get_name(ctx):
221 return ctx[0]
221 return ctx[0]
222
222
223 _bookmarks = [
223 _bookmarks = [
224 (safe_unicode(n), hexlify(h)) for n, h in
224 (safe_unicode(n), hexlify(h)) for n, h in
225 self._remote.bookmarks().items()]
225 self._remote.bookmarks().items()]
226
226
227 return OrderedDict(sorted(_bookmarks, key=get_name))
227 return OrderedDict(sorted(_bookmarks, key=get_name))
228
228
229 def _get_all_commit_ids(self):
229 def _get_all_commit_ids(self):
230 return self._remote.get_all_commit_ids('visible')
230 return self._remote.get_all_commit_ids('visible')
231
231
232 def get_diff(
232 def get_diff(
233 self, commit1, commit2, path='', ignore_whitespace=False,
233 self, commit1, commit2, path='', ignore_whitespace=False,
234 context=3, path1=None):
234 context=3, path1=None):
235 """
235 """
236 Returns (git like) *diff*, as plain text. Shows changes introduced by
236 Returns (git like) *diff*, as plain text. Shows changes introduced by
237 `commit2` since `commit1`.
237 `commit2` since `commit1`.
238
238
239 :param commit1: Entry point from which diff is shown. Can be
239 :param commit1: Entry point from which diff is shown. Can be
240 ``self.EMPTY_COMMIT`` - in this case, patch showing all
240 ``self.EMPTY_COMMIT`` - in this case, patch showing all
241 the changes since empty state of the repository until `commit2`
241 the changes since empty state of the repository until `commit2`
242 :param commit2: Until which commit changes should be shown.
242 :param commit2: Until which commit changes should be shown.
243 :param ignore_whitespace: If set to ``True``, would not show whitespace
243 :param ignore_whitespace: If set to ``True``, would not show whitespace
244 changes. Defaults to ``False``.
244 changes. Defaults to ``False``.
245 :param context: How many lines before/after changed lines should be
245 :param context: How many lines before/after changed lines should be
246 shown. Defaults to ``3``.
246 shown. Defaults to ``3``.
247 """
247 """
248 self._validate_diff_commits(commit1, commit2)
248 self._validate_diff_commits(commit1, commit2)
249 if path1 is not None and path1 != path:
249 if path1 is not None and path1 != path:
250 raise ValueError("Diff of two different paths not supported.")
250 raise ValueError("Diff of two different paths not supported.")
251
251
252 if path:
252 if path:
253 file_filter = [self.path, path]
253 file_filter = [self.path, path]
254 else:
254 else:
255 file_filter = None
255 file_filter = None
256
256
257 diff = self._remote.diff(
257 diff = self._remote.diff(
258 commit1.raw_id, commit2.raw_id, file_filter=file_filter,
258 commit1.raw_id, commit2.raw_id, file_filter=file_filter,
259 opt_git=True, opt_ignorews=ignore_whitespace,
259 opt_git=True, opt_ignorews=ignore_whitespace,
260 context=context)
260 context=context)
261 return MercurialDiff(diff)
261 return MercurialDiff(diff)
262
262
263 def strip(self, commit_id, branch=None):
263 def strip(self, commit_id, branch=None):
264 self._remote.strip(commit_id, update=False, backup="none")
264 self._remote.strip(commit_id, update=False, backup="none")
265
265
266 self._remote.invalidate_vcs_cache()
266 self._remote.invalidate_vcs_cache()
267 self.commit_ids = self._get_all_commit_ids()
267 self.commit_ids = self._get_all_commit_ids()
268 self._rebuild_cache(self.commit_ids)
268 self._rebuild_cache(self.commit_ids)
269
269
270 def get_common_ancestor(self, commit_id1, commit_id2, repo2):
270 def get_common_ancestor(self, commit_id1, commit_id2, repo2):
271 if commit_id1 == commit_id2:
271 if commit_id1 == commit_id2:
272 return commit_id1
272 return commit_id1
273
273
274 ancestors = self._remote.revs_from_revspec(
274 ancestors = self._remote.revs_from_revspec(
275 "ancestor(id(%s), id(%s))", commit_id1, commit_id2,
275 "ancestor(id(%s), id(%s))", commit_id1, commit_id2,
276 other_path=repo2.path)
276 other_path=repo2.path)
277 return repo2[ancestors[0]].raw_id if ancestors else None
277 return repo2[ancestors[0]].raw_id if ancestors else None
278
278
279 def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
279 def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
280 if commit_id1 == commit_id2:
280 if commit_id1 == commit_id2:
281 commits = []
281 commits = []
282 else:
282 else:
283 if merge:
283 if merge:
284 indexes = self._remote.revs_from_revspec(
284 indexes = self._remote.revs_from_revspec(
285 "ancestors(id(%s)) - ancestors(id(%s)) - id(%s)",
285 "ancestors(id(%s)) - ancestors(id(%s)) - id(%s)",
286 commit_id2, commit_id1, commit_id1, other_path=repo2.path)
286 commit_id2, commit_id1, commit_id1, other_path=repo2.path)
287 else:
287 else:
288 indexes = self._remote.revs_from_revspec(
288 indexes = self._remote.revs_from_revspec(
289 "id(%s)..id(%s) - id(%s)", commit_id1, commit_id2,
289 "id(%s)..id(%s) - id(%s)", commit_id1, commit_id2,
290 commit_id1, other_path=repo2.path)
290 commit_id1, other_path=repo2.path)
291
291
292 commits = [repo2.get_commit(commit_idx=idx, pre_load=pre_load)
292 commits = [repo2.get_commit(commit_idx=idx, pre_load=pre_load)
293 for idx in indexes]
293 for idx in indexes]
294
294
295 return commits
295 return commits
296
296
297 @staticmethod
297 @staticmethod
298 def check_url(url, config):
298 def check_url(url, config):
299 """
299 """
300 Function will check given url and try to verify if it's a valid
300 Function will check given url and try to verify if it's a valid
301 link. Sometimes it may happened that mercurial will issue basic
301 link. Sometimes it may happened that mercurial will issue basic
302 auth request that can cause whole API to hang when used from python
302 auth request that can cause whole API to hang when used from python
303 or other external calls.
303 or other external calls.
304
304
305 On failures it'll raise urllib2.HTTPError, exception is also thrown
305 On failures it'll raise urllib2.HTTPError, exception is also thrown
306 when the return code is non 200
306 when the return code is non 200
307 """
307 """
308 # check first if it's not an local url
308 # check first if it's not an local url
309 if os.path.isdir(url) or url.startswith('file:'):
309 if os.path.isdir(url) or url.startswith('file:'):
310 return True
310 return True
311
311
312 # Request the _remote to verify the url
312 # Request the _remote to verify the url
313 return connection.Hg.check_url(url, config.serialize())
313 return connection.Hg.check_url(url, config.serialize())
314
314
315 @staticmethod
315 @staticmethod
316 def is_valid_repository(path):
316 def is_valid_repository(path):
317 return os.path.isdir(os.path.join(path, '.hg'))
317 return os.path.isdir(os.path.join(path, '.hg'))
318
318
319 def _init_repo(self, create, src_url=None, update_after_clone=False):
319 def _init_repo(self, create, src_url=None, update_after_clone=False):
320 """
320 """
321 Function will check for mercurial repository in given path. If there
321 Function will check for mercurial repository in given path. If there
322 is no repository in that path it will raise an exception unless
322 is no repository in that path it will raise an exception unless
323 `create` parameter is set to True - in that case repository would
323 `create` parameter is set to True - in that case repository would
324 be created.
324 be created.
325
325
326 If `src_url` is given, would try to clone repository from the
326 If `src_url` is given, would try to clone repository from the
327 location at given clone_point. Additionally it'll make update to
327 location at given clone_point. Additionally it'll make update to
328 working copy accordingly to `update_after_clone` flag.
328 working copy accordingly to `update_after_clone` flag.
329 """
329 """
330 if create and os.path.exists(self.path):
330 if create and os.path.exists(self.path):
331 raise RepositoryError(
331 raise RepositoryError(
332 "Cannot create repository at %s, location already exist"
332 "Cannot create repository at %s, location already exist"
333 % self.path)
333 % self.path)
334
334
335 if src_url:
335 if src_url:
336 url = str(self._get_url(src_url))
336 url = str(self._get_url(src_url))
337 MercurialRepository.check_url(url, self.config)
337 MercurialRepository.check_url(url, self.config)
338
338
339 self._remote.clone(url, self.path, update_after_clone)
339 self._remote.clone(url, self.path, update_after_clone)
340
340
341 # Don't try to create if we've already cloned repo
341 # Don't try to create if we've already cloned repo
342 create = False
342 create = False
343
343
344 if create:
344 if create:
345 os.makedirs(self.path, mode=0755)
345 os.makedirs(self.path, mode=0755)
346
346
347 self._remote.localrepository(create)
347 self._remote.localrepository(create)
348
348
349 @LazyProperty
349 @LazyProperty
350 def in_memory_commit(self):
350 def in_memory_commit(self):
351 return MercurialInMemoryCommit(self)
351 return MercurialInMemoryCommit(self)
352
352
353 @LazyProperty
353 @LazyProperty
354 def description(self):
354 def description(self):
355 description = self._remote.get_config_value(
355 description = self._remote.get_config_value(
356 'web', 'description', untrusted=True)
356 'web', 'description', untrusted=True)
357 return safe_unicode(description or self.DEFAULT_DESCRIPTION)
357 return safe_unicode(description or self.DEFAULT_DESCRIPTION)
358
358
359 @LazyProperty
359 @LazyProperty
360 def contact(self):
360 def contact(self):
361 contact = (
361 contact = (
362 self._remote.get_config_value("web", "contact") or
362 self._remote.get_config_value("web", "contact") or
363 self._remote.get_config_value("ui", "username"))
363 self._remote.get_config_value("ui", "username"))
364 return safe_unicode(contact or self.DEFAULT_CONTACT)
364 return safe_unicode(contact or self.DEFAULT_CONTACT)
365
365
366 @LazyProperty
366 @LazyProperty
367 def last_change(self):
367 def last_change(self):
368 """
368 """
369 Returns last change made on this repository as
369 Returns last change made on this repository as
370 `datetime.datetime` object
370 `datetime.datetime` object
371 """
371 """
372 return utcdate_fromtimestamp(self._get_mtime(), makedate()[1])
372 return utcdate_fromtimestamp(self._get_mtime(), makedate()[1])
373
373
374 def _get_mtime(self):
374 def _get_mtime(self):
375 try:
375 try:
376 return date_astimestamp(self.get_commit().date)
376 return date_astimestamp(self.get_commit().date)
377 except RepositoryError:
377 except RepositoryError:
378 # fallback to filesystem
378 # fallback to filesystem
379 cl_path = os.path.join(self.path, '.hg', "00changelog.i")
379 cl_path = os.path.join(self.path, '.hg', "00changelog.i")
380 st_path = os.path.join(self.path, '.hg', "store")
380 st_path = os.path.join(self.path, '.hg', "store")
381 if os.path.exists(cl_path):
381 if os.path.exists(cl_path):
382 return os.stat(cl_path).st_mtime
382 return os.stat(cl_path).st_mtime
383 else:
383 else:
384 return os.stat(st_path).st_mtime
384 return os.stat(st_path).st_mtime
385
385
386 def _sanitize_commit_idx(self, idx):
386 def _sanitize_commit_idx(self, idx):
387 # Note: Mercurial has ``int(-1)`` reserved as not existing id_or_idx
387 # Note: Mercurial has ``int(-1)`` reserved as not existing id_or_idx
388 # number. A `long` is treated in the correct way though. So we convert
388 # number. A `long` is treated in the correct way though. So we convert
389 # `int` to `long` here to make sure it is handled correctly.
389 # `int` to `long` here to make sure it is handled correctly.
390 if isinstance(idx, int):
390 if isinstance(idx, int):
391 return long(idx)
391 return long(idx)
392 return idx
392 return idx
393
393
394 def _get_url(self, url):
394 def _get_url(self, url):
395 """
395 """
396 Returns normalized url. If schema is not given, would fall
396 Returns normalized url. If schema is not given, would fall
397 to filesystem
397 to filesystem
398 (``file:///``) schema.
398 (``file:///``) schema.
399 """
399 """
400 url = url.encode('utf8')
400 url = url.encode('utf8')
401 if url != 'default' and '://' not in url:
401 if url != 'default' and '://' not in url:
402 url = "file:" + urllib.pathname2url(url)
402 url = "file:" + urllib.pathname2url(url)
403 return url
403 return url
404
404
405 def get_hook_location(self):
405 def get_hook_location(self):
406 """
406 """
407 returns absolute path to location where hooks are stored
407 returns absolute path to location where hooks are stored
408 """
408 """
409 return os.path.join(self.path, '.hg', '.hgrc')
409 return os.path.join(self.path, '.hg', '.hgrc')
410
410
411 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
411 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
412 """
412 """
413 Returns ``MercurialCommit`` object representing repository's
413 Returns ``MercurialCommit`` object representing repository's
414 commit at the given `commit_id` or `commit_idx`.
414 commit at the given `commit_id` or `commit_idx`.
415 """
415 """
416 if self.is_empty():
416 if self.is_empty():
417 raise EmptyRepositoryError("There are no commits yet")
417 raise EmptyRepositoryError("There are no commits yet")
418
418
419 if commit_id is not None:
419 if commit_id is not None:
420 self._validate_commit_id(commit_id)
420 self._validate_commit_id(commit_id)
421 try:
421 try:
422 idx = self._commit_ids[commit_id]
422 idx = self._commit_ids[commit_id]
423 return MercurialCommit(self, commit_id, idx, pre_load=pre_load)
423 return MercurialCommit(self, commit_id, idx, pre_load=pre_load)
424 except KeyError:
424 except KeyError:
425 pass
425 pass
426 elif commit_idx is not None:
426 elif commit_idx is not None:
427 self._validate_commit_idx(commit_idx)
427 self._validate_commit_idx(commit_idx)
428 commit_idx = self._sanitize_commit_idx(commit_idx)
428 commit_idx = self._sanitize_commit_idx(commit_idx)
429 try:
429 try:
430 id_ = self.commit_ids[commit_idx]
430 id_ = self.commit_ids[commit_idx]
431 if commit_idx < 0:
431 if commit_idx < 0:
432 commit_idx += len(self.commit_ids)
432 commit_idx += len(self.commit_ids)
433 return MercurialCommit(
433 return MercurialCommit(
434 self, id_, commit_idx, pre_load=pre_load)
434 self, id_, commit_idx, pre_load=pre_load)
435 except IndexError:
435 except IndexError:
436 commit_id = commit_idx
436 commit_id = commit_idx
437 else:
437 else:
438 commit_id = "tip"
438 commit_id = "tip"
439
439
440 # TODO Paris: Ugly hack to "serialize" long for msgpack
440 # TODO Paris: Ugly hack to "serialize" long for msgpack
441 if isinstance(commit_id, long):
441 if isinstance(commit_id, long):
442 commit_id = float(commit_id)
442 commit_id = float(commit_id)
443
443
444 if isinstance(commit_id, unicode):
444 if isinstance(commit_id, unicode):
445 commit_id = safe_str(commit_id)
445 commit_id = safe_str(commit_id)
446
446
447 raw_id, idx = self._remote.lookup(commit_id, both=True)
447 raw_id, idx = self._remote.lookup(commit_id, both=True)
448
448
449 return MercurialCommit(self, raw_id, idx, pre_load=pre_load)
449 return MercurialCommit(self, raw_id, idx, pre_load=pre_load)
450
450
451 def get_commits(
451 def get_commits(
452 self, start_id=None, end_id=None, start_date=None, end_date=None,
452 self, start_id=None, end_id=None, start_date=None, end_date=None,
453 branch_name=None, pre_load=None):
453 branch_name=None, pre_load=None):
454 """
454 """
455 Returns generator of ``MercurialCommit`` objects from start to end
455 Returns generator of ``MercurialCommit`` objects from start to end
456 (both are inclusive)
456 (both are inclusive)
457
457
458 :param start_id: None, str(commit_id)
458 :param start_id: None, str(commit_id)
459 :param end_id: None, str(commit_id)
459 :param end_id: None, str(commit_id)
460 :param start_date: if specified, commits with commit date less than
460 :param start_date: if specified, commits with commit date less than
461 ``start_date`` would be filtered out from returned set
461 ``start_date`` would be filtered out from returned set
462 :param end_date: if specified, commits with commit date greater than
462 :param end_date: if specified, commits with commit date greater than
463 ``end_date`` would be filtered out from returned set
463 ``end_date`` would be filtered out from returned set
464 :param branch_name: if specified, commits not reachable from given
464 :param branch_name: if specified, commits not reachable from given
465 branch would be filtered out from returned set
465 branch would be filtered out from returned set
466
466
467 :raise BranchDoesNotExistError: If given ``branch_name`` does not
467 :raise BranchDoesNotExistError: If given ``branch_name`` does not
468 exist.
468 exist.
469 :raise CommitDoesNotExistError: If commit for given ``start`` or
469 :raise CommitDoesNotExistError: If commit for given ``start`` or
470 ``end`` could not be found.
470 ``end`` could not be found.
471 """
471 """
472 # actually we should check now if it's not an empty repo
472 # actually we should check now if it's not an empty repo
473 branch_ancestors = False
473 branch_ancestors = False
474 if self.is_empty():
474 if self.is_empty():
475 raise EmptyRepositoryError("There are no commits yet")
475 raise EmptyRepositoryError("There are no commits yet")
476 self._validate_branch_name(branch_name)
476 self._validate_branch_name(branch_name)
477
477
478 if start_id is not None:
478 if start_id is not None:
479 self._validate_commit_id(start_id)
479 self._validate_commit_id(start_id)
480 c_start = self.get_commit(commit_id=start_id)
480 c_start = self.get_commit(commit_id=start_id)
481 start_pos = self._commit_ids[c_start.raw_id]
481 start_pos = self._commit_ids[c_start.raw_id]
482 else:
482 else:
483 start_pos = None
483 start_pos = None
484
484
485 if end_id is not None:
485 if end_id is not None:
486 self._validate_commit_id(end_id)
486 self._validate_commit_id(end_id)
487 c_end = self.get_commit(commit_id=end_id)
487 c_end = self.get_commit(commit_id=end_id)
488 end_pos = max(0, self._commit_ids[c_end.raw_id])
488 end_pos = max(0, self._commit_ids[c_end.raw_id])
489 else:
489 else:
490 end_pos = None
490 end_pos = None
491
491
492 if None not in [start_id, end_id] and start_pos > end_pos:
492 if None not in [start_id, end_id] and start_pos > end_pos:
493 raise RepositoryError(
493 raise RepositoryError(
494 "Start commit '%s' cannot be after end commit '%s'" %
494 "Start commit '%s' cannot be after end commit '%s'" %
495 (start_id, end_id))
495 (start_id, end_id))
496
496
497 if end_pos is not None:
497 if end_pos is not None:
498 end_pos += 1
498 end_pos += 1
499
499
500 commit_filter = []
500 commit_filter = []
501 if branch_name and not branch_ancestors:
501 if branch_name and not branch_ancestors:
502 commit_filter.append('branch("%s")' % branch_name)
502 commit_filter.append('branch("%s")' % branch_name)
503 elif branch_name and branch_ancestors:
503 elif branch_name and branch_ancestors:
504 commit_filter.append('ancestors(branch("%s"))' % branch_name)
504 commit_filter.append('ancestors(branch("%s"))' % branch_name)
505 if start_date and not end_date:
505 if start_date and not end_date:
506 commit_filter.append('date(">%s")' % start_date)
506 commit_filter.append('date(">%s")' % start_date)
507 if end_date and not start_date:
507 if end_date and not start_date:
508 commit_filter.append('date("<%s")' % end_date)
508 commit_filter.append('date("<%s")' % end_date)
509 if start_date and end_date:
509 if start_date and end_date:
510 commit_filter.append(
510 commit_filter.append(
511 'date(">%s") and date("<%s")' % (start_date, end_date))
511 'date(">%s") and date("<%s")' % (start_date, end_date))
512
512
513 # TODO: johbo: Figure out a simpler way for this solution
513 # TODO: johbo: Figure out a simpler way for this solution
514 collection_generator = CollectionGenerator
514 collection_generator = CollectionGenerator
515 if commit_filter:
515 if commit_filter:
516 commit_filter = map(safe_str, commit_filter)
516 commit_filter = map(safe_str, commit_filter)
517 revisions = self._remote.rev_range(commit_filter)
517 revisions = self._remote.rev_range(commit_filter)
518 collection_generator = MercurialIndexBasedCollectionGenerator
518 collection_generator = MercurialIndexBasedCollectionGenerator
519 else:
519 else:
520 revisions = self.commit_ids
520 revisions = self.commit_ids
521
521
522 if start_pos or end_pos:
522 if start_pos or end_pos:
523 revisions = revisions[start_pos:end_pos]
523 revisions = revisions[start_pos:end_pos]
524
524
525 return collection_generator(self, revisions, pre_load=pre_load)
525 return collection_generator(self, revisions, pre_load=pre_load)
526
526
527 def pull(self, url, commit_ids=None):
527 def pull(self, url, commit_ids=None):
528 """
528 """
529 Tries to pull changes from external location.
529 Tries to pull changes from external location.
530
530
531 :param commit_ids: Optional. Can be set to a list of commit ids
531 :param commit_ids: Optional. Can be set to a list of commit ids
532 which shall be pulled from the other repository.
532 which shall be pulled from the other repository.
533 """
533 """
534 url = self._get_url(url)
534 url = self._get_url(url)
535 self._remote.pull(url, commit_ids=commit_ids)
535 self._remote.pull(url, commit_ids=commit_ids)
536 self._remote.invalidate_vcs_cache()
536 self._remote.invalidate_vcs_cache()
537
537
538 def _local_clone(self, clone_path):
538 def _local_clone(self, clone_path):
539 """
539 """
540 Create a local clone of the current repo.
540 Create a local clone of the current repo.
541 """
541 """
542 self._remote.clone(self.path, clone_path, update_after_clone=True,
542 self._remote.clone(self.path, clone_path, update_after_clone=True,
543 hooks=False)
543 hooks=False)
544
544
545 def _update(self, revision, clean=False):
545 def _update(self, revision, clean=False):
546 """
546 """
547 Update the working copty to the specified revision.
547 Update the working copty to the specified revision.
548 """
548 """
549 self._remote.update(revision, clean=clean)
549 self._remote.update(revision, clean=clean)
550
550
551 def _identify(self):
551 def _identify(self):
552 """
552 """
553 Return the current state of the working directory.
553 Return the current state of the working directory.
554 """
554 """
555 return self._remote.identify().strip().rstrip('+')
555 return self._remote.identify().strip().rstrip('+')
556
556
557 def _heads(self, branch=None):
557 def _heads(self, branch=None):
558 """
558 """
559 Return the commit ids of the repository heads.
559 Return the commit ids of the repository heads.
560 """
560 """
561 return self._remote.heads(branch=branch).strip().split(' ')
561 return self._remote.heads(branch=branch).strip().split(' ')
562
562
563 def _ancestor(self, revision1, revision2):
563 def _ancestor(self, revision1, revision2):
564 """
564 """
565 Return the common ancestor of the two revisions.
565 Return the common ancestor of the two revisions.
566 """
566 """
567 return self._remote.ancestor(
567 return self._remote.ancestor(
568 revision1, revision2).strip().split(':')[-1]
568 revision1, revision2).strip().split(':')[-1]
569
569
570 def _local_push(
570 def _local_push(
571 self, revision, repository_path, push_branches=False,
571 self, revision, repository_path, push_branches=False,
572 enable_hooks=False):
572 enable_hooks=False):
573 """
573 """
574 Push the given revision to the specified repository.
574 Push the given revision to the specified repository.
575
575
576 :param push_branches: allow to create branches in the target repo.
576 :param push_branches: allow to create branches in the target repo.
577 """
577 """
578 self._remote.push(
578 self._remote.push(
579 [revision], repository_path, hooks=enable_hooks,
579 [revision], repository_path, hooks=enable_hooks,
580 push_branches=push_branches)
580 push_branches=push_branches)
581
581
582 def _local_merge(self, target_ref, merge_message, user_name, user_email,
582 def _local_merge(self, target_ref, merge_message, user_name, user_email,
583 source_ref, use_rebase=False):
583 source_ref, use_rebase=False):
584 """
584 """
585 Merge the given source_revision into the checked out revision.
585 Merge the given source_revision into the checked out revision.
586
586
587 Returns the commit id of the merge and a boolean indicating if the
587 Returns the commit id of the merge and a boolean indicating if the
588 commit needs to be pushed.
588 commit needs to be pushed.
589 """
589 """
590 self._update(target_ref.commit_id)
590 self._update(target_ref.commit_id)
591
591
592 ancestor = self._ancestor(target_ref.commit_id, source_ref.commit_id)
592 ancestor = self._ancestor(target_ref.commit_id, source_ref.commit_id)
593 is_the_same_branch = self._is_the_same_branch(target_ref, source_ref)
593 is_the_same_branch = self._is_the_same_branch(target_ref, source_ref)
594
594
595 if ancestor == source_ref.commit_id:
595 if ancestor == source_ref.commit_id:
596 # Nothing to do, the changes were already integrated
596 # Nothing to do, the changes were already integrated
597 return target_ref.commit_id, False
597 return target_ref.commit_id, False
598
598
599 elif ancestor == target_ref.commit_id and is_the_same_branch:
599 elif ancestor == target_ref.commit_id and is_the_same_branch:
600 # In this case we should force a commit message
600 # In this case we should force a commit message
601 return source_ref.commit_id, True
601 return source_ref.commit_id, True
602
602
603 if use_rebase:
603 if use_rebase:
604 try:
604 try:
605 bookmark_name = 'rcbook%s%s' % (source_ref.commit_id,
605 bookmark_name = 'rcbook%s%s' % (source_ref.commit_id,
606 target_ref.commit_id)
606 target_ref.commit_id)
607 self.bookmark(bookmark_name, revision=source_ref.commit_id)
607 self.bookmark(bookmark_name, revision=source_ref.commit_id)
608 self._remote.rebase(
608 self._remote.rebase(
609 source=source_ref.commit_id, dest=target_ref.commit_id)
609 source=source_ref.commit_id, dest=target_ref.commit_id)
610 self._remote.invalidate_vcs_cache()
610 self._remote.invalidate_vcs_cache()
611 self._update(bookmark_name)
611 self._update(bookmark_name)
612 return self._identify(), True
612 return self._identify(), True
613 except RepositoryError:
613 except RepositoryError:
614 # The rebase-abort may raise another exception which 'hides'
614 # The rebase-abort may raise another exception which 'hides'
615 # the original one, therefore we log it here.
615 # the original one, therefore we log it here.
616 log.exception('Error while rebasing shadow repo during merge.')
616 log.exception('Error while rebasing shadow repo during merge.')
617
617
618 # Cleanup any rebase leftovers
618 # Cleanup any rebase leftovers
619 self._remote.invalidate_vcs_cache()
619 self._remote.invalidate_vcs_cache()
620 self._remote.rebase(abort=True)
620 self._remote.rebase(abort=True)
621 self._remote.invalidate_vcs_cache()
621 self._remote.invalidate_vcs_cache()
622 self._remote.update(clean=True)
622 self._remote.update(clean=True)
623 raise
623 raise
624 else:
624 else:
625 try:
625 try:
626 self._remote.merge(source_ref.commit_id)
626 self._remote.merge(source_ref.commit_id)
627 self._remote.invalidate_vcs_cache()
627 self._remote.invalidate_vcs_cache()
628 self._remote.commit(
628 self._remote.commit(
629 message=safe_str(merge_message),
629 message=safe_str(merge_message),
630 username=safe_str('%s <%s>' % (user_name, user_email)))
630 username=safe_str('%s <%s>' % (user_name, user_email)))
631 self._remote.invalidate_vcs_cache()
631 self._remote.invalidate_vcs_cache()
632 return self._identify(), True
632 return self._identify(), True
633 except RepositoryError:
633 except RepositoryError:
634 # Cleanup any merge leftovers
634 # Cleanup any merge leftovers
635 self._remote.update(clean=True)
635 self._remote.update(clean=True)
636 raise
636 raise
637
637
638 def _is_the_same_branch(self, target_ref, source_ref):
638 def _is_the_same_branch(self, target_ref, source_ref):
639 return (
639 return (
640 self._get_branch_name(target_ref) ==
640 self._get_branch_name(target_ref) ==
641 self._get_branch_name(source_ref))
641 self._get_branch_name(source_ref))
642
642
643 def _get_branch_name(self, ref):
643 def _get_branch_name(self, ref):
644 if ref.type == 'branch':
644 if ref.type == 'branch':
645 return ref.name
645 return ref.name
646 return self._remote.ctx_branch(ref.commit_id)
646 return self._remote.ctx_branch(ref.commit_id)
647
647
648 def _get_shadow_repository_path(self, workspace_id):
648 def _get_shadow_repository_path(self, workspace_id):
649 # The name of the shadow repository must start with '.', so it is
649 # The name of the shadow repository must start with '.', so it is
650 # skipped by 'rhodecode.lib.utils.get_filesystem_repos'.
650 # skipped by 'rhodecode.lib.utils.get_filesystem_repos'.
651 return os.path.join(
651 return os.path.join(
652 os.path.dirname(self.path),
652 os.path.dirname(self.path),
653 '.__shadow_%s_%s' % (os.path.basename(self.path), workspace_id))
653 '.__shadow_%s_%s' % (os.path.basename(self.path), workspace_id))
654
654
655 def _maybe_prepare_merge_workspace(self, workspace_id, unused_target_ref):
655 def _maybe_prepare_merge_workspace(self, workspace_id, unused_target_ref):
656 shadow_repository_path = self._get_shadow_repository_path(workspace_id)
656 shadow_repository_path = self._get_shadow_repository_path(workspace_id)
657 if not os.path.exists(shadow_repository_path):
657 if not os.path.exists(shadow_repository_path):
658 self._local_clone(shadow_repository_path)
658 self._local_clone(shadow_repository_path)
659 log.debug(
659 log.debug(
660 'Prepared shadow repository in %s', shadow_repository_path)
660 'Prepared shadow repository in %s', shadow_repository_path)
661
661
662 return shadow_repository_path
662 return shadow_repository_path
663
663
664 def cleanup_merge_workspace(self, workspace_id):
664 def cleanup_merge_workspace(self, workspace_id):
665 shadow_repository_path = self._get_shadow_repository_path(workspace_id)
665 shadow_repository_path = self._get_shadow_repository_path(workspace_id)
666 shutil.rmtree(shadow_repository_path, ignore_errors=True)
666 shutil.rmtree(shadow_repository_path, ignore_errors=True)
667
667
668 def _merge_repo(self, shadow_repository_path, target_ref,
668 def _merge_repo(self, shadow_repository_path, target_ref,
669 source_repo, source_ref, merge_message,
669 source_repo, source_ref, merge_message,
670 merger_name, merger_email, dry_run=False,
670 merger_name, merger_email, dry_run=False,
671 use_rebase=False):
671 use_rebase=False):
672 if target_ref.commit_id not in self._heads():
672 if target_ref.commit_id not in self._heads():
673 return MergeResponse(
673 return MergeResponse(
674 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
674 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
675
675
676 try:
676 if (target_ref.type == 'branch' and
677 if (target_ref.type == 'branch' and
677 len(self._heads(target_ref.name)) != 1):
678 len(self._heads(target_ref.name)) != 1):
678 return MergeResponse(
679 return MergeResponse(
679 False, False, None,
680 False, False, None,
680 MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS)
681 MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS)
682 except CommitDoesNotExistError as e:
683 log.exception('Failure when looking up branch heads on hg target')
684 return MergeResponse(
685 False, False, None, MergeFailureReason.MISSING_TARGET_REF)
681
686
682 shadow_repo = self._get_shadow_instance(shadow_repository_path)
687 shadow_repo = self._get_shadow_instance(shadow_repository_path)
683
688
684 log.debug('Pulling in target reference %s', target_ref)
689 log.debug('Pulling in target reference %s', target_ref)
685 self._validate_pull_reference(target_ref)
690 self._validate_pull_reference(target_ref)
686 shadow_repo._local_pull(self.path, target_ref)
691 shadow_repo._local_pull(self.path, target_ref)
687 try:
692 try:
688 log.debug('Pulling in source reference %s', source_ref)
693 log.debug('Pulling in source reference %s', source_ref)
689 source_repo._validate_pull_reference(source_ref)
694 source_repo._validate_pull_reference(source_ref)
690 shadow_repo._local_pull(source_repo.path, source_ref)
695 shadow_repo._local_pull(source_repo.path, source_ref)
691 except CommitDoesNotExistError:
696 except CommitDoesNotExistError:
692 log.exception('Failure when doing local pull on hg shadow repo')
697 log.exception('Failure when doing local pull on hg shadow repo')
693 return MergeResponse(
698 return MergeResponse(
694 False, False, None, MergeFailureReason.MISSING_COMMIT)
699 False, False, None, MergeFailureReason.MISSING_SOURCE_REF)
695
700
696 merge_ref = None
701 merge_ref = None
697 merge_failure_reason = MergeFailureReason.NONE
702 merge_failure_reason = MergeFailureReason.NONE
698
703
699 try:
704 try:
700 merge_commit_id, needs_push = shadow_repo._local_merge(
705 merge_commit_id, needs_push = shadow_repo._local_merge(
701 target_ref, merge_message, merger_name, merger_email,
706 target_ref, merge_message, merger_name, merger_email,
702 source_ref, use_rebase=use_rebase)
707 source_ref, use_rebase=use_rebase)
703 merge_possible = True
708 merge_possible = True
704
709
705 # Set a bookmark pointing to the merge commit. This bookmark may be
710 # Set a bookmark pointing to the merge commit. This bookmark may be
706 # used to easily identify the last successful merge commit in the
711 # used to easily identify the last successful merge commit in the
707 # shadow repository.
712 # shadow repository.
708 shadow_repo.bookmark('pr-merge', revision=merge_commit_id)
713 shadow_repo.bookmark('pr-merge', revision=merge_commit_id)
709 merge_ref = Reference('book', 'pr-merge', merge_commit_id)
714 merge_ref = Reference('book', 'pr-merge', merge_commit_id)
710 except RepositoryError:
715 except RepositoryError:
711 log.exception('Failure when doing local merge on hg shadow repo')
716 log.exception('Failure when doing local merge on hg shadow repo')
712 merge_possible = False
717 merge_possible = False
713 merge_failure_reason = MergeFailureReason.MERGE_FAILED
718 merge_failure_reason = MergeFailureReason.MERGE_FAILED
714
719
715 if merge_possible and not dry_run:
720 if merge_possible and not dry_run:
716 if needs_push:
721 if needs_push:
717 # In case the target is a bookmark, update it, so after pushing
722 # In case the target is a bookmark, update it, so after pushing
718 # the bookmarks is also updated in the target.
723 # the bookmarks is also updated in the target.
719 if target_ref.type == 'book':
724 if target_ref.type == 'book':
720 shadow_repo.bookmark(
725 shadow_repo.bookmark(
721 target_ref.name, revision=merge_commit_id)
726 target_ref.name, revision=merge_commit_id)
722
727
723 try:
728 try:
724 shadow_repo_with_hooks = self._get_shadow_instance(
729 shadow_repo_with_hooks = self._get_shadow_instance(
725 shadow_repository_path,
730 shadow_repository_path,
726 enable_hooks=True)
731 enable_hooks=True)
727 # Note: the push_branches option will push any new branch
732 # Note: the push_branches option will push any new branch
728 # defined in the source repository to the target. This may
733 # defined in the source repository to the target. This may
729 # be dangerous as branches are permanent in Mercurial.
734 # be dangerous as branches are permanent in Mercurial.
730 # This feature was requested in issue #441.
735 # This feature was requested in issue #441.
731 shadow_repo_with_hooks._local_push(
736 shadow_repo_with_hooks._local_push(
732 merge_commit_id, self.path, push_branches=True,
737 merge_commit_id, self.path, push_branches=True,
733 enable_hooks=True)
738 enable_hooks=True)
734 merge_succeeded = True
739 merge_succeeded = True
735 except RepositoryError:
740 except RepositoryError:
736 log.exception(
741 log.exception(
737 'Failure when doing local push from the shadow '
742 'Failure when doing local push from the shadow '
738 'repository to the target repository.')
743 'repository to the target repository.')
739 merge_succeeded = False
744 merge_succeeded = False
740 merge_failure_reason = MergeFailureReason.PUSH_FAILED
745 merge_failure_reason = MergeFailureReason.PUSH_FAILED
741 else:
746 else:
742 merge_succeeded = True
747 merge_succeeded = True
743 else:
748 else:
744 merge_succeeded = False
749 merge_succeeded = False
745
750
746 return MergeResponse(
751 return MergeResponse(
747 merge_possible, merge_succeeded, merge_ref, merge_failure_reason)
752 merge_possible, merge_succeeded, merge_ref, merge_failure_reason)
748
753
749 def _get_shadow_instance(
754 def _get_shadow_instance(
750 self, shadow_repository_path, enable_hooks=False):
755 self, shadow_repository_path, enable_hooks=False):
751 config = self.config.copy()
756 config = self.config.copy()
752 if not enable_hooks:
757 if not enable_hooks:
753 config.clear_section('hooks')
758 config.clear_section('hooks')
754 return MercurialRepository(shadow_repository_path, config)
759 return MercurialRepository(shadow_repository_path, config)
755
760
756 def _validate_pull_reference(self, reference):
761 def _validate_pull_reference(self, reference):
757 if not (reference.name in self.bookmarks or
762 if not (reference.name in self.bookmarks or
758 reference.name in self.branches or
763 reference.name in self.branches or
759 self.get_commit(reference.commit_id)):
764 self.get_commit(reference.commit_id)):
760 raise CommitDoesNotExistError(
765 raise CommitDoesNotExistError(
761 'Unknown branch, bookmark or commit id')
766 'Unknown branch, bookmark or commit id')
762
767
763 def _local_pull(self, repository_path, reference):
768 def _local_pull(self, repository_path, reference):
764 """
769 """
765 Fetch a branch, bookmark or commit from a local repository.
770 Fetch a branch, bookmark or commit from a local repository.
766 """
771 """
767 repository_path = os.path.abspath(repository_path)
772 repository_path = os.path.abspath(repository_path)
768 if repository_path == self.path:
773 if repository_path == self.path:
769 raise ValueError('Cannot pull from the same repository')
774 raise ValueError('Cannot pull from the same repository')
770
775
771 reference_type_to_option_name = {
776 reference_type_to_option_name = {
772 'book': 'bookmark',
777 'book': 'bookmark',
773 'branch': 'branch',
778 'branch': 'branch',
774 }
779 }
775 option_name = reference_type_to_option_name.get(
780 option_name = reference_type_to_option_name.get(
776 reference.type, 'revision')
781 reference.type, 'revision')
777
782
778 if option_name == 'revision':
783 if option_name == 'revision':
779 ref = reference.commit_id
784 ref = reference.commit_id
780 else:
785 else:
781 ref = reference.name
786 ref = reference.name
782
787
783 options = {option_name: [ref]}
788 options = {option_name: [ref]}
784 self._remote.pull_cmd(repository_path, hooks=False, **options)
789 self._remote.pull_cmd(repository_path, hooks=False, **options)
785 self._remote.invalidate_vcs_cache()
790 self._remote.invalidate_vcs_cache()
786
791
787 def bookmark(self, bookmark, revision=None):
792 def bookmark(self, bookmark, revision=None):
788 if isinstance(bookmark, unicode):
793 if isinstance(bookmark, unicode):
789 bookmark = safe_str(bookmark)
794 bookmark = safe_str(bookmark)
790 self._remote.bookmark(bookmark, revision=revision)
795 self._remote.bookmark(bookmark, revision=revision)
791 self._remote.invalidate_vcs_cache()
796 self._remote.invalidate_vcs_cache()
792
797
793
798
794 class MercurialIndexBasedCollectionGenerator(CollectionGenerator):
799 class MercurialIndexBasedCollectionGenerator(CollectionGenerator):
795
800
796 def _commit_factory(self, commit_id):
801 def _commit_factory(self, commit_id):
797 return self.repo.get_commit(
802 return self.repo.get_commit(
798 commit_idx=commit_id, pre_load=self.pre_load)
803 commit_idx=commit_id, pre_load=self.pre_load)
@@ -1,532 +1,532 b''
1 # -*- coding: utf-8 -*-
1 # -*- coding: utf-8 -*-
2
2
3 # Copyright (C) 2010-2016 RhodeCode GmbH
3 # Copyright (C) 2010-2016 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 import datetime
21 import datetime
22 from urllib2 import URLError
22 from urllib2 import URLError
23
23
24 import mock
24 import mock
25 import pytest
25 import pytest
26
26
27 from rhodecode.lib.vcs import backends
27 from rhodecode.lib.vcs import backends
28 from rhodecode.lib.vcs.backends.base import (
28 from rhodecode.lib.vcs.backends.base import (
29 Config, BaseInMemoryCommit, Reference, MergeResponse, MergeFailureReason)
29 Config, BaseInMemoryCommit, Reference, MergeResponse, MergeFailureReason)
30 from rhodecode.lib.vcs.exceptions import VCSError, RepositoryError
30 from rhodecode.lib.vcs.exceptions import VCSError, RepositoryError
31 from rhodecode.lib.vcs.nodes import FileNode
31 from rhodecode.lib.vcs.nodes import FileNode
32 from rhodecode.tests.vcs.base import BackendTestMixin
32 from rhodecode.tests.vcs.base import BackendTestMixin
33
33
34
34
35 class TestRepositoryBase(BackendTestMixin):
35 class TestRepositoryBase(BackendTestMixin):
36 recreate_repo_per_test = False
36 recreate_repo_per_test = False
37
37
38 def test_init_accepts_unicode_path(self, tmpdir):
38 def test_init_accepts_unicode_path(self, tmpdir):
39 path = unicode(tmpdir.join(u'unicode Γ€'))
39 path = unicode(tmpdir.join(u'unicode Γ€'))
40 self.Backend(path, create=True)
40 self.Backend(path, create=True)
41
41
42 def test_init_accepts_str_path(self, tmpdir):
42 def test_init_accepts_str_path(self, tmpdir):
43 path = str(tmpdir.join('str Γ€'))
43 path = str(tmpdir.join('str Γ€'))
44 self.Backend(path, create=True)
44 self.Backend(path, create=True)
45
45
46 def test_init_fails_if_path_does_not_exist(self, tmpdir):
46 def test_init_fails_if_path_does_not_exist(self, tmpdir):
47 path = unicode(tmpdir.join('i-do-not-exist'))
47 path = unicode(tmpdir.join('i-do-not-exist'))
48 with pytest.raises(VCSError):
48 with pytest.raises(VCSError):
49 self.Backend(path)
49 self.Backend(path)
50
50
51 def test_init_fails_if_path_is_not_a_valid_repository(self, tmpdir):
51 def test_init_fails_if_path_is_not_a_valid_repository(self, tmpdir):
52 path = unicode(tmpdir.mkdir(u'unicode Γ€'))
52 path = unicode(tmpdir.mkdir(u'unicode Γ€'))
53 with pytest.raises(VCSError):
53 with pytest.raises(VCSError):
54 self.Backend(path)
54 self.Backend(path)
55
55
56 def test_has_commits_attribute(self):
56 def test_has_commits_attribute(self):
57 self.repo.commit_ids
57 self.repo.commit_ids
58
58
59 def test_name(self):
59 def test_name(self):
60 assert self.repo.name.startswith('vcs-test')
60 assert self.repo.name.startswith('vcs-test')
61
61
62 @pytest.mark.backends("hg", "git")
62 @pytest.mark.backends("hg", "git")
63 def test_has_default_branch_name(self):
63 def test_has_default_branch_name(self):
64 assert self.repo.DEFAULT_BRANCH_NAME is not None
64 assert self.repo.DEFAULT_BRANCH_NAME is not None
65
65
66 @pytest.mark.backends("svn")
66 @pytest.mark.backends("svn")
67 def test_has_no_default_branch_name(self):
67 def test_has_no_default_branch_name(self):
68 assert self.repo.DEFAULT_BRANCH_NAME is None
68 assert self.repo.DEFAULT_BRANCH_NAME is None
69
69
70 def test_has_empty_commit(self):
70 def test_has_empty_commit(self):
71 assert self.repo.EMPTY_COMMIT_ID is not None
71 assert self.repo.EMPTY_COMMIT_ID is not None
72 assert self.repo.EMPTY_COMMIT is not None
72 assert self.repo.EMPTY_COMMIT is not None
73
73
74 def test_empty_changeset_is_deprecated(self):
74 def test_empty_changeset_is_deprecated(self):
75 def get_empty_changeset(repo):
75 def get_empty_changeset(repo):
76 return repo.EMPTY_CHANGESET
76 return repo.EMPTY_CHANGESET
77 pytest.deprecated_call(get_empty_changeset, self.repo)
77 pytest.deprecated_call(get_empty_changeset, self.repo)
78
78
79 def test_bookmarks(self):
79 def test_bookmarks(self):
80 assert len(self.repo.bookmarks) == 0
80 assert len(self.repo.bookmarks) == 0
81
81
82 # TODO: Cover two cases: Local repo path, remote URL
82 # TODO: Cover two cases: Local repo path, remote URL
83 def test_check_url(self):
83 def test_check_url(self):
84 config = Config()
84 config = Config()
85 assert self.Backend.check_url(self.repo.path, config)
85 assert self.Backend.check_url(self.repo.path, config)
86
86
87 def test_check_url_invalid(self):
87 def test_check_url_invalid(self):
88 config = Config()
88 config = Config()
89 with pytest.raises(URLError):
89 with pytest.raises(URLError):
90 self.Backend.check_url(self.repo.path + "invalid", config)
90 self.Backend.check_url(self.repo.path + "invalid", config)
91
91
92 def test_get_contact(self):
92 def test_get_contact(self):
93 self.repo.contact
93 self.repo.contact
94
94
95 def test_get_description(self):
95 def test_get_description(self):
96 self.repo.description
96 self.repo.description
97
97
98 def test_get_hook_location(self):
98 def test_get_hook_location(self):
99 assert len(self.repo.get_hook_location()) != 0
99 assert len(self.repo.get_hook_location()) != 0
100
100
101 def test_last_change(self):
101 def test_last_change(self):
102 assert self.repo.last_change >= datetime.datetime(2010, 1, 1, 21, 0)
102 assert self.repo.last_change >= datetime.datetime(2010, 1, 1, 21, 0)
103
103
104 def test_last_change_in_empty_repository(self, vcsbackend):
104 def test_last_change_in_empty_repository(self, vcsbackend):
105 delta = datetime.timedelta(seconds=1)
105 delta = datetime.timedelta(seconds=1)
106 start = datetime.datetime.now()
106 start = datetime.datetime.now()
107 empty_repo = vcsbackend.create_repo()
107 empty_repo = vcsbackend.create_repo()
108 now = datetime.datetime.now()
108 now = datetime.datetime.now()
109 assert empty_repo.last_change >= start - delta
109 assert empty_repo.last_change >= start - delta
110 assert empty_repo.last_change <= now + delta
110 assert empty_repo.last_change <= now + delta
111
111
112 def test_repo_equality(self):
112 def test_repo_equality(self):
113 assert self.repo == self.repo
113 assert self.repo == self.repo
114
114
115 def test_repo_equality_broken_object(self):
115 def test_repo_equality_broken_object(self):
116 import copy
116 import copy
117 _repo = copy.copy(self.repo)
117 _repo = copy.copy(self.repo)
118 delattr(_repo, 'path')
118 delattr(_repo, 'path')
119 assert self.repo != _repo
119 assert self.repo != _repo
120
120
121 def test_repo_equality_other_object(self):
121 def test_repo_equality_other_object(self):
122 class dummy(object):
122 class dummy(object):
123 path = self.repo.path
123 path = self.repo.path
124 assert self.repo != dummy()
124 assert self.repo != dummy()
125
125
126 def test_get_commit_is_implemented(self):
126 def test_get_commit_is_implemented(self):
127 self.repo.get_commit()
127 self.repo.get_commit()
128
128
129 def test_get_commits_is_implemented(self):
129 def test_get_commits_is_implemented(self):
130 commit_iter = iter(self.repo.get_commits())
130 commit_iter = iter(self.repo.get_commits())
131 commit = next(commit_iter)
131 commit = next(commit_iter)
132 assert commit.idx == 0
132 assert commit.idx == 0
133
133
134 def test_supports_iteration(self):
134 def test_supports_iteration(self):
135 repo_iter = iter(self.repo)
135 repo_iter = iter(self.repo)
136 commit = next(repo_iter)
136 commit = next(repo_iter)
137 assert commit.idx == 0
137 assert commit.idx == 0
138
138
139 def test_in_memory_commit(self):
139 def test_in_memory_commit(self):
140 imc = self.repo.in_memory_commit
140 imc = self.repo.in_memory_commit
141 assert isinstance(imc, BaseInMemoryCommit)
141 assert isinstance(imc, BaseInMemoryCommit)
142
142
143 @pytest.mark.backends("hg")
143 @pytest.mark.backends("hg")
144 def test__get_url_unicode(self):
144 def test__get_url_unicode(self):
145 url = u'/home/repos/malmΓΆ'
145 url = u'/home/repos/malmΓΆ'
146 assert self.repo._get_url(url)
146 assert self.repo._get_url(url)
147
147
148
148
149 class TestDeprecatedRepositoryAPI(BackendTestMixin):
149 class TestDeprecatedRepositoryAPI(BackendTestMixin):
150 recreate_repo_per_test = False
150 recreate_repo_per_test = False
151
151
152 def test_revisions_is_deprecated(self):
152 def test_revisions_is_deprecated(self):
153 def get_revisions(repo):
153 def get_revisions(repo):
154 return repo.revisions
154 return repo.revisions
155 pytest.deprecated_call(get_revisions, self.repo)
155 pytest.deprecated_call(get_revisions, self.repo)
156
156
157 def test_get_changeset_is_deprecated(self):
157 def test_get_changeset_is_deprecated(self):
158 pytest.deprecated_call(self.repo.get_changeset)
158 pytest.deprecated_call(self.repo.get_changeset)
159
159
160 def test_get_changesets_is_deprecated(self):
160 def test_get_changesets_is_deprecated(self):
161 pytest.deprecated_call(self.repo.get_changesets)
161 pytest.deprecated_call(self.repo.get_changesets)
162
162
163 def test_in_memory_changeset_is_deprecated(self):
163 def test_in_memory_changeset_is_deprecated(self):
164 def get_imc(repo):
164 def get_imc(repo):
165 return repo.in_memory_changeset
165 return repo.in_memory_changeset
166 pytest.deprecated_call(get_imc, self.repo)
166 pytest.deprecated_call(get_imc, self.repo)
167
167
168
168
169 # TODO: these tests are incomplete, must check the resulting compare result for
169 # TODO: these tests are incomplete, must check the resulting compare result for
170 # correcteness
170 # correcteness
171 class TestRepositoryCompare:
171 class TestRepositoryCompare:
172
172
173 @pytest.mark.parametrize('merge', [True, False])
173 @pytest.mark.parametrize('merge', [True, False])
174 def test_compare_commits_of_same_repository(self, vcsbackend, merge):
174 def test_compare_commits_of_same_repository(self, vcsbackend, merge):
175 target_repo = vcsbackend.create_repo(number_of_commits=5)
175 target_repo = vcsbackend.create_repo(number_of_commits=5)
176 target_repo.compare(
176 target_repo.compare(
177 target_repo[1].raw_id, target_repo[3].raw_id, target_repo,
177 target_repo[1].raw_id, target_repo[3].raw_id, target_repo,
178 merge=merge)
178 merge=merge)
179
179
180 @pytest.mark.xfail_backends('svn')
180 @pytest.mark.xfail_backends('svn')
181 @pytest.mark.parametrize('merge', [True, False])
181 @pytest.mark.parametrize('merge', [True, False])
182 def test_compare_cloned_repositories(self, vcsbackend, merge):
182 def test_compare_cloned_repositories(self, vcsbackend, merge):
183 target_repo = vcsbackend.create_repo(number_of_commits=5)
183 target_repo = vcsbackend.create_repo(number_of_commits=5)
184 source_repo = vcsbackend.clone_repo(target_repo)
184 source_repo = vcsbackend.clone_repo(target_repo)
185 assert target_repo != source_repo
185 assert target_repo != source_repo
186
186
187 vcsbackend.add_file(source_repo, 'newfile', 'somecontent')
187 vcsbackend.add_file(source_repo, 'newfile', 'somecontent')
188 source_commit = source_repo.get_commit()
188 source_commit = source_repo.get_commit()
189
189
190 target_repo.compare(
190 target_repo.compare(
191 target_repo[1].raw_id, source_repo[3].raw_id, source_repo,
191 target_repo[1].raw_id, source_repo[3].raw_id, source_repo,
192 merge=merge)
192 merge=merge)
193
193
194 @pytest.mark.xfail_backends('svn')
194 @pytest.mark.xfail_backends('svn')
195 @pytest.mark.parametrize('merge', [True, False])
195 @pytest.mark.parametrize('merge', [True, False])
196 def test_compare_unrelated_repositories(self, vcsbackend, merge):
196 def test_compare_unrelated_repositories(self, vcsbackend, merge):
197 orig = vcsbackend.create_repo(number_of_commits=5)
197 orig = vcsbackend.create_repo(number_of_commits=5)
198 unrelated = vcsbackend.create_repo(number_of_commits=5)
198 unrelated = vcsbackend.create_repo(number_of_commits=5)
199 assert orig != unrelated
199 assert orig != unrelated
200
200
201 orig.compare(
201 orig.compare(
202 orig[1].raw_id, unrelated[3].raw_id, unrelated, merge=merge)
202 orig[1].raw_id, unrelated[3].raw_id, unrelated, merge=merge)
203
203
204
204
205 class TestRepositoryGetCommonAncestor:
205 class TestRepositoryGetCommonAncestor:
206
206
207 def test_get_common_ancestor_from_same_repo_existing(self, vcsbackend):
207 def test_get_common_ancestor_from_same_repo_existing(self, vcsbackend):
208 target_repo = vcsbackend.create_repo(number_of_commits=5)
208 target_repo = vcsbackend.create_repo(number_of_commits=5)
209
209
210 expected_ancestor = target_repo[2].raw_id
210 expected_ancestor = target_repo[2].raw_id
211
211
212 assert target_repo.get_common_ancestor(
212 assert target_repo.get_common_ancestor(
213 commit_id1=target_repo[2].raw_id,
213 commit_id1=target_repo[2].raw_id,
214 commit_id2=target_repo[4].raw_id,
214 commit_id2=target_repo[4].raw_id,
215 repo2=target_repo
215 repo2=target_repo
216 ) == expected_ancestor
216 ) == expected_ancestor
217
217
218 assert target_repo.get_common_ancestor(
218 assert target_repo.get_common_ancestor(
219 commit_id1=target_repo[4].raw_id,
219 commit_id1=target_repo[4].raw_id,
220 commit_id2=target_repo[2].raw_id,
220 commit_id2=target_repo[2].raw_id,
221 repo2=target_repo
221 repo2=target_repo
222 ) == expected_ancestor
222 ) == expected_ancestor
223
223
224 @pytest.mark.xfail_backends("svn")
224 @pytest.mark.xfail_backends("svn")
225 def test_get_common_ancestor_from_cloned_repo_existing(self, vcsbackend):
225 def test_get_common_ancestor_from_cloned_repo_existing(self, vcsbackend):
226 target_repo = vcsbackend.create_repo(number_of_commits=5)
226 target_repo = vcsbackend.create_repo(number_of_commits=5)
227 source_repo = vcsbackend.clone_repo(target_repo)
227 source_repo = vcsbackend.clone_repo(target_repo)
228 assert target_repo != source_repo
228 assert target_repo != source_repo
229
229
230 vcsbackend.add_file(source_repo, 'newfile', 'somecontent')
230 vcsbackend.add_file(source_repo, 'newfile', 'somecontent')
231 source_commit = source_repo.get_commit()
231 source_commit = source_repo.get_commit()
232
232
233 expected_ancestor = target_repo[4].raw_id
233 expected_ancestor = target_repo[4].raw_id
234
234
235 assert target_repo.get_common_ancestor(
235 assert target_repo.get_common_ancestor(
236 commit_id1=target_repo[4].raw_id,
236 commit_id1=target_repo[4].raw_id,
237 commit_id2=source_commit.raw_id,
237 commit_id2=source_commit.raw_id,
238 repo2=source_repo
238 repo2=source_repo
239 ) == expected_ancestor
239 ) == expected_ancestor
240
240
241 assert target_repo.get_common_ancestor(
241 assert target_repo.get_common_ancestor(
242 commit_id1=source_commit.raw_id,
242 commit_id1=source_commit.raw_id,
243 commit_id2=target_repo[4].raw_id,
243 commit_id2=target_repo[4].raw_id,
244 repo2=target_repo
244 repo2=target_repo
245 ) == expected_ancestor
245 ) == expected_ancestor
246
246
247 @pytest.mark.xfail_backends("svn")
247 @pytest.mark.xfail_backends("svn")
248 def test_get_common_ancestor_from_unrelated_repo_missing(self, vcsbackend):
248 def test_get_common_ancestor_from_unrelated_repo_missing(self, vcsbackend):
249 original = vcsbackend.create_repo(number_of_commits=5)
249 original = vcsbackend.create_repo(number_of_commits=5)
250 unrelated = vcsbackend.create_repo(number_of_commits=5)
250 unrelated = vcsbackend.create_repo(number_of_commits=5)
251 assert original != unrelated
251 assert original != unrelated
252
252
253 assert original.get_common_ancestor(
253 assert original.get_common_ancestor(
254 commit_id1=original[0].raw_id,
254 commit_id1=original[0].raw_id,
255 commit_id2=unrelated[0].raw_id,
255 commit_id2=unrelated[0].raw_id,
256 repo2=unrelated
256 repo2=unrelated
257 ) == None
257 ) == None
258
258
259 assert original.get_common_ancestor(
259 assert original.get_common_ancestor(
260 commit_id1=original[-1].raw_id,
260 commit_id1=original[-1].raw_id,
261 commit_id2=unrelated[-1].raw_id,
261 commit_id2=unrelated[-1].raw_id,
262 repo2=unrelated
262 repo2=unrelated
263 ) == None
263 ) == None
264
264
265
265
266 @pytest.mark.backends("git", "hg")
266 @pytest.mark.backends("git", "hg")
267 class TestRepositoryMerge:
267 class TestRepositoryMerge:
268 def prepare_for_success(self, vcsbackend):
268 def prepare_for_success(self, vcsbackend):
269 self.target_repo = vcsbackend.create_repo(number_of_commits=1)
269 self.target_repo = vcsbackend.create_repo(number_of_commits=1)
270 self.source_repo = vcsbackend.clone_repo(self.target_repo)
270 self.source_repo = vcsbackend.clone_repo(self.target_repo)
271 vcsbackend.add_file(self.target_repo, 'README_MERGE1', 'Version 1')
271 vcsbackend.add_file(self.target_repo, 'README_MERGE1', 'Version 1')
272 vcsbackend.add_file(self.source_repo, 'README_MERGE2', 'Version 2')
272 vcsbackend.add_file(self.source_repo, 'README_MERGE2', 'Version 2')
273 imc = self.source_repo.in_memory_commit
273 imc = self.source_repo.in_memory_commit
274 imc.add(FileNode('file_x', content=self.source_repo.name))
274 imc.add(FileNode('file_x', content=self.source_repo.name))
275 imc.commit(
275 imc.commit(
276 message=u'Automatic commit from repo merge test',
276 message=u'Automatic commit from repo merge test',
277 author=u'Automatic')
277 author=u'Automatic')
278 self.target_commit = self.target_repo.get_commit()
278 self.target_commit = self.target_repo.get_commit()
279 self.source_commit = self.source_repo.get_commit()
279 self.source_commit = self.source_repo.get_commit()
280 # This only works for Git and Mercurial
280 # This only works for Git and Mercurial
281 default_branch = self.target_repo.DEFAULT_BRANCH_NAME
281 default_branch = self.target_repo.DEFAULT_BRANCH_NAME
282 self.target_ref = Reference(
282 self.target_ref = Reference(
283 'branch', default_branch, self.target_commit.raw_id)
283 'branch', default_branch, self.target_commit.raw_id)
284 self.source_ref = Reference(
284 self.source_ref = Reference(
285 'branch', default_branch, self.source_commit.raw_id)
285 'branch', default_branch, self.source_commit.raw_id)
286 self.workspace = 'test-merge'
286 self.workspace = 'test-merge'
287
287
288 def prepare_for_conflict(self, vcsbackend):
288 def prepare_for_conflict(self, vcsbackend):
289 self.target_repo = vcsbackend.create_repo(number_of_commits=1)
289 self.target_repo = vcsbackend.create_repo(number_of_commits=1)
290 self.source_repo = vcsbackend.clone_repo(self.target_repo)
290 self.source_repo = vcsbackend.clone_repo(self.target_repo)
291 vcsbackend.add_file(self.target_repo, 'README_MERGE', 'Version 1')
291 vcsbackend.add_file(self.target_repo, 'README_MERGE', 'Version 1')
292 vcsbackend.add_file(self.source_repo, 'README_MERGE', 'Version 2')
292 vcsbackend.add_file(self.source_repo, 'README_MERGE', 'Version 2')
293 self.target_commit = self.target_repo.get_commit()
293 self.target_commit = self.target_repo.get_commit()
294 self.source_commit = self.source_repo.get_commit()
294 self.source_commit = self.source_repo.get_commit()
295 # This only works for Git and Mercurial
295 # This only works for Git and Mercurial
296 default_branch = self.target_repo.DEFAULT_BRANCH_NAME
296 default_branch = self.target_repo.DEFAULT_BRANCH_NAME
297 self.target_ref = Reference(
297 self.target_ref = Reference(
298 'branch', default_branch, self.target_commit.raw_id)
298 'branch', default_branch, self.target_commit.raw_id)
299 self.source_ref = Reference(
299 self.source_ref = Reference(
300 'branch', default_branch, self.source_commit.raw_id)
300 'branch', default_branch, self.source_commit.raw_id)
301 self.workspace = 'test-merge'
301 self.workspace = 'test-merge'
302
302
303 def test_merge_success(self, vcsbackend):
303 def test_merge_success(self, vcsbackend):
304 self.prepare_for_success(vcsbackend)
304 self.prepare_for_success(vcsbackend)
305
305
306 merge_response = self.target_repo.merge(
306 merge_response = self.target_repo.merge(
307 self.target_ref, self.source_repo, self.source_ref, self.workspace,
307 self.target_ref, self.source_repo, self.source_ref, self.workspace,
308 'test user', 'test@rhodecode.com', 'merge message 1',
308 'test user', 'test@rhodecode.com', 'merge message 1',
309 dry_run=False)
309 dry_run=False)
310 expected_merge_response = MergeResponse(
310 expected_merge_response = MergeResponse(
311 True, True, merge_response.merge_ref,
311 True, True, merge_response.merge_ref,
312 MergeFailureReason.NONE)
312 MergeFailureReason.NONE)
313 assert merge_response == expected_merge_response
313 assert merge_response == expected_merge_response
314
314
315 target_repo = backends.get_backend(vcsbackend.alias)(
315 target_repo = backends.get_backend(vcsbackend.alias)(
316 self.target_repo.path)
316 self.target_repo.path)
317 target_commits = list(target_repo.get_commits())
317 target_commits = list(target_repo.get_commits())
318 commit_ids = [c.raw_id for c in target_commits[:-1]]
318 commit_ids = [c.raw_id for c in target_commits[:-1]]
319 assert self.source_ref.commit_id in commit_ids
319 assert self.source_ref.commit_id in commit_ids
320 assert self.target_ref.commit_id in commit_ids
320 assert self.target_ref.commit_id in commit_ids
321
321
322 merge_commit = target_commits[-1]
322 merge_commit = target_commits[-1]
323 assert merge_commit.raw_id == merge_response.merge_ref.commit_id
323 assert merge_commit.raw_id == merge_response.merge_ref.commit_id
324 assert merge_commit.message.strip() == 'merge message 1'
324 assert merge_commit.message.strip() == 'merge message 1'
325 assert merge_commit.author == 'test user <test@rhodecode.com>'
325 assert merge_commit.author == 'test user <test@rhodecode.com>'
326
326
327 # We call it twice so to make sure we can handle updates
327 # We call it twice so to make sure we can handle updates
328 target_ref = Reference(
328 target_ref = Reference(
329 self.target_ref.type, self.target_ref.name,
329 self.target_ref.type, self.target_ref.name,
330 merge_response.merge_ref.commit_id)
330 merge_response.merge_ref.commit_id)
331
331
332 merge_response = target_repo.merge(
332 merge_response = target_repo.merge(
333 target_ref, self.source_repo, self.source_ref, self.workspace,
333 target_ref, self.source_repo, self.source_ref, self.workspace,
334 'test user', 'test@rhodecode.com', 'merge message 2',
334 'test user', 'test@rhodecode.com', 'merge message 2',
335 dry_run=False)
335 dry_run=False)
336 expected_merge_response = MergeResponse(
336 expected_merge_response = MergeResponse(
337 True, True, merge_response.merge_ref,
337 True, True, merge_response.merge_ref,
338 MergeFailureReason.NONE)
338 MergeFailureReason.NONE)
339 assert merge_response == expected_merge_response
339 assert merge_response == expected_merge_response
340
340
341 target_repo = backends.get_backend(
341 target_repo = backends.get_backend(
342 vcsbackend.alias)(self.target_repo.path)
342 vcsbackend.alias)(self.target_repo.path)
343 merge_commit = target_repo.get_commit(
343 merge_commit = target_repo.get_commit(
344 merge_response.merge_ref.commit_id)
344 merge_response.merge_ref.commit_id)
345 assert merge_commit.message.strip() == 'merge message 1'
345 assert merge_commit.message.strip() == 'merge message 1'
346 assert merge_commit.author == 'test user <test@rhodecode.com>'
346 assert merge_commit.author == 'test user <test@rhodecode.com>'
347
347
348 def test_merge_success_dry_run(self, vcsbackend):
348 def test_merge_success_dry_run(self, vcsbackend):
349 self.prepare_for_success(vcsbackend)
349 self.prepare_for_success(vcsbackend)
350
350
351 merge_response = self.target_repo.merge(
351 merge_response = self.target_repo.merge(
352 self.target_ref, self.source_repo, self.source_ref, self.workspace,
352 self.target_ref, self.source_repo, self.source_ref, self.workspace,
353 dry_run=True)
353 dry_run=True)
354
354
355 # We call it twice so to make sure we can handle updates
355 # We call it twice so to make sure we can handle updates
356 merge_response_update = self.target_repo.merge(
356 merge_response_update = self.target_repo.merge(
357 self.target_ref, self.source_repo, self.source_ref, self.workspace,
357 self.target_ref, self.source_repo, self.source_ref, self.workspace,
358 dry_run=True)
358 dry_run=True)
359
359
360 # Multiple merges may differ in their commit id. Therefore we set the
360 # Multiple merges may differ in their commit id. Therefore we set the
361 # commit id to `None` before comparing the merge responses.
361 # commit id to `None` before comparing the merge responses.
362 merge_response = merge_response._replace(
362 merge_response = merge_response._replace(
363 merge_ref=merge_response.merge_ref._replace(commit_id=None))
363 merge_ref=merge_response.merge_ref._replace(commit_id=None))
364 merge_response_update = merge_response_update._replace(
364 merge_response_update = merge_response_update._replace(
365 merge_ref=merge_response_update.merge_ref._replace(commit_id=None))
365 merge_ref=merge_response_update.merge_ref._replace(commit_id=None))
366
366
367 assert merge_response == merge_response_update
367 assert merge_response == merge_response_update
368 assert merge_response.possible is True
368 assert merge_response.possible is True
369 assert merge_response.executed is False
369 assert merge_response.executed is False
370 assert merge_response.merge_ref
370 assert merge_response.merge_ref
371 assert merge_response.failure_reason is MergeFailureReason.NONE
371 assert merge_response.failure_reason is MergeFailureReason.NONE
372
372
373 @pytest.mark.parametrize('dry_run', [True, False])
373 @pytest.mark.parametrize('dry_run', [True, False])
374 def test_merge_conflict(self, vcsbackend, dry_run):
374 def test_merge_conflict(self, vcsbackend, dry_run):
375 self.prepare_for_conflict(vcsbackend)
375 self.prepare_for_conflict(vcsbackend)
376 expected_merge_response = MergeResponse(
376 expected_merge_response = MergeResponse(
377 False, False, None, MergeFailureReason.MERGE_FAILED)
377 False, False, None, MergeFailureReason.MERGE_FAILED)
378
378
379 merge_response = self.target_repo.merge(
379 merge_response = self.target_repo.merge(
380 self.target_ref, self.source_repo, self.source_ref, self.workspace,
380 self.target_ref, self.source_repo, self.source_ref, self.workspace,
381 'test_user', 'test@rhodecode.com', 'test message', dry_run=dry_run)
381 'test_user', 'test@rhodecode.com', 'test message', dry_run=dry_run)
382 assert merge_response == expected_merge_response
382 assert merge_response == expected_merge_response
383
383
384 # We call it twice so to make sure we can handle updates
384 # We call it twice so to make sure we can handle updates
385 merge_response = self.target_repo.merge(
385 merge_response = self.target_repo.merge(
386 self.target_ref, self.source_repo, self.source_ref, self.workspace,
386 self.target_ref, self.source_repo, self.source_ref, self.workspace,
387 'test_user', 'test@rhodecode.com', 'test message', dry_run=dry_run)
387 'test_user', 'test@rhodecode.com', 'test message', dry_run=dry_run)
388 assert merge_response == expected_merge_response
388 assert merge_response == expected_merge_response
389
389
390 def test_merge_target_is_not_head(self, vcsbackend):
390 def test_merge_target_is_not_head(self, vcsbackend):
391 self.prepare_for_success(vcsbackend)
391 self.prepare_for_success(vcsbackend)
392 expected_merge_response = MergeResponse(
392 expected_merge_response = MergeResponse(
393 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
393 False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
394
394
395 target_ref = Reference(
395 target_ref = Reference(
396 self.target_ref.type, self.target_ref.name, '0' * 40)
396 self.target_ref.type, self.target_ref.name, '0' * 40)
397
397
398 merge_response = self.target_repo.merge(
398 merge_response = self.target_repo.merge(
399 target_ref, self.source_repo, self.source_ref, self.workspace,
399 target_ref, self.source_repo, self.source_ref, self.workspace,
400 dry_run=True)
400 dry_run=True)
401
401
402 assert merge_response == expected_merge_response
402 assert merge_response == expected_merge_response
403
403
404 def test_merge_missing_commit(self, vcsbackend):
404 def test_merge_missing_source_reference(self, vcsbackend):
405 self.prepare_for_success(vcsbackend)
405 self.prepare_for_success(vcsbackend)
406 expected_merge_response = MergeResponse(
406 expected_merge_response = MergeResponse(
407 False, False, None, MergeFailureReason.MISSING_COMMIT)
407 False, False, None, MergeFailureReason.MISSING_SOURCE_REF)
408
408
409 source_ref = Reference(
409 source_ref = Reference(
410 self.source_ref.type, 'not_existing', self.source_ref.commit_id)
410 self.source_ref.type, 'not_existing', self.source_ref.commit_id)
411
411
412 merge_response = self.target_repo.merge(
412 merge_response = self.target_repo.merge(
413 self.target_ref, self.source_repo, source_ref, self.workspace,
413 self.target_ref, self.source_repo, source_ref, self.workspace,
414 dry_run=True)
414 dry_run=True)
415
415
416 assert merge_response == expected_merge_response
416 assert merge_response == expected_merge_response
417
417
418 def test_merge_raises_exception(self, vcsbackend):
418 def test_merge_raises_exception(self, vcsbackend):
419 self.prepare_for_success(vcsbackend)
419 self.prepare_for_success(vcsbackend)
420 expected_merge_response = MergeResponse(
420 expected_merge_response = MergeResponse(
421 False, False, None, MergeFailureReason.UNKNOWN)
421 False, False, None, MergeFailureReason.UNKNOWN)
422
422
423 with mock.patch.object(self.target_repo, '_merge_repo',
423 with mock.patch.object(self.target_repo, '_merge_repo',
424 side_effect=RepositoryError()):
424 side_effect=RepositoryError()):
425 merge_response = self.target_repo.merge(
425 merge_response = self.target_repo.merge(
426 self.target_ref, self.source_repo, self.source_ref,
426 self.target_ref, self.source_repo, self.source_ref,
427 self.workspace, dry_run=True)
427 self.workspace, dry_run=True)
428
428
429 assert merge_response == expected_merge_response
429 assert merge_response == expected_merge_response
430
430
431 def test_merge_invalid_user_name(self, vcsbackend):
431 def test_merge_invalid_user_name(self, vcsbackend):
432 repo = vcsbackend.create_repo(number_of_commits=1)
432 repo = vcsbackend.create_repo(number_of_commits=1)
433 ref = Reference('branch', 'master', 'not_used')
433 ref = Reference('branch', 'master', 'not_used')
434 with pytest.raises(ValueError):
434 with pytest.raises(ValueError):
435 repo.merge(ref, self, ref, 'workspace_id')
435 repo.merge(ref, self, ref, 'workspace_id')
436
436
437 def test_merge_invalid_user_email(self, vcsbackend):
437 def test_merge_invalid_user_email(self, vcsbackend):
438 repo = vcsbackend.create_repo(number_of_commits=1)
438 repo = vcsbackend.create_repo(number_of_commits=1)
439 ref = Reference('branch', 'master', 'not_used')
439 ref = Reference('branch', 'master', 'not_used')
440 with pytest.raises(ValueError):
440 with pytest.raises(ValueError):
441 repo.merge(ref, self, ref, 'workspace_id', 'user name')
441 repo.merge(ref, self, ref, 'workspace_id', 'user name')
442
442
443 def test_merge_invalid_message(self, vcsbackend):
443 def test_merge_invalid_message(self, vcsbackend):
444 repo = vcsbackend.create_repo(number_of_commits=1)
444 repo = vcsbackend.create_repo(number_of_commits=1)
445 ref = Reference('branch', 'master', 'not_used')
445 ref = Reference('branch', 'master', 'not_used')
446 with pytest.raises(ValueError):
446 with pytest.raises(ValueError):
447 repo.merge(
447 repo.merge(
448 ref, self, ref, 'workspace_id', 'user name', 'user@email.com')
448 ref, self, ref, 'workspace_id', 'user name', 'user@email.com')
449
449
450
450
451 class TestRepositoryStrip(BackendTestMixin):
451 class TestRepositoryStrip(BackendTestMixin):
452 recreate_repo_per_test = True
452 recreate_repo_per_test = True
453
453
454 @classmethod
454 @classmethod
455 def _get_commits(cls):
455 def _get_commits(cls):
456 commits = [
456 commits = [
457 {
457 {
458 'message': 'Initial commit',
458 'message': 'Initial commit',
459 'author': 'Joe Doe <joe.doe@example.com>',
459 'author': 'Joe Doe <joe.doe@example.com>',
460 'date': datetime.datetime(2010, 1, 1, 20),
460 'date': datetime.datetime(2010, 1, 1, 20),
461 'branch': 'master',
461 'branch': 'master',
462 'added': [
462 'added': [
463 FileNode('foobar', content='foobar'),
463 FileNode('foobar', content='foobar'),
464 FileNode('foobar2', content='foobar2'),
464 FileNode('foobar2', content='foobar2'),
465 ],
465 ],
466 },
466 },
467 ]
467 ]
468 for x in xrange(10):
468 for x in xrange(10):
469 commit_data = {
469 commit_data = {
470 'message': 'Changed foobar - commit%s' % x,
470 'message': 'Changed foobar - commit%s' % x,
471 'author': 'Jane Doe <jane.doe@example.com>',
471 'author': 'Jane Doe <jane.doe@example.com>',
472 'date': datetime.datetime(2010, 1, 1, 21, x),
472 'date': datetime.datetime(2010, 1, 1, 21, x),
473 'branch': 'master',
473 'branch': 'master',
474 'changed': [
474 'changed': [
475 FileNode('foobar', 'FOOBAR - %s' % x),
475 FileNode('foobar', 'FOOBAR - %s' % x),
476 ],
476 ],
477 }
477 }
478 commits.append(commit_data)
478 commits.append(commit_data)
479 return commits
479 return commits
480
480
481 @pytest.mark.backends("git", "hg")
481 @pytest.mark.backends("git", "hg")
482 def test_strip_commit(self):
482 def test_strip_commit(self):
483 tip = self.repo.get_commit()
483 tip = self.repo.get_commit()
484 assert tip.idx == 10
484 assert tip.idx == 10
485 self.repo.strip(tip.raw_id, self.repo.DEFAULT_BRANCH_NAME)
485 self.repo.strip(tip.raw_id, self.repo.DEFAULT_BRANCH_NAME)
486
486
487 tip = self.repo.get_commit()
487 tip = self.repo.get_commit()
488 assert tip.idx == 9
488 assert tip.idx == 9
489
489
490 @pytest.mark.backends("git", "hg")
490 @pytest.mark.backends("git", "hg")
491 def test_strip_multiple_commits(self):
491 def test_strip_multiple_commits(self):
492 tip = self.repo.get_commit()
492 tip = self.repo.get_commit()
493 assert tip.idx == 10
493 assert tip.idx == 10
494
494
495 old = self.repo.get_commit(commit_idx=5)
495 old = self.repo.get_commit(commit_idx=5)
496 self.repo.strip(old.raw_id, self.repo.DEFAULT_BRANCH_NAME)
496 self.repo.strip(old.raw_id, self.repo.DEFAULT_BRANCH_NAME)
497
497
498 tip = self.repo.get_commit()
498 tip = self.repo.get_commit()
499 assert tip.idx == 4
499 assert tip.idx == 4
500
500
501
501
502 @pytest.mark.backends('hg', 'git')
502 @pytest.mark.backends('hg', 'git')
503 class TestRepositoryPull:
503 class TestRepositoryPull:
504
504
505 def test_pull(self, vcsbackend):
505 def test_pull(self, vcsbackend):
506 source_repo = vcsbackend.repo
506 source_repo = vcsbackend.repo
507 target_repo = vcsbackend.create_repo()
507 target_repo = vcsbackend.create_repo()
508 assert len(source_repo.commit_ids) > len(target_repo.commit_ids)
508 assert len(source_repo.commit_ids) > len(target_repo.commit_ids)
509
509
510 target_repo.pull(source_repo.path)
510 target_repo.pull(source_repo.path)
511 # Note: Get a fresh instance, avoids caching trouble
511 # Note: Get a fresh instance, avoids caching trouble
512 target_repo = vcsbackend.backend(target_repo.path)
512 target_repo = vcsbackend.backend(target_repo.path)
513 assert len(source_repo.commit_ids) == len(target_repo.commit_ids)
513 assert len(source_repo.commit_ids) == len(target_repo.commit_ids)
514
514
515 def test_pull_wrong_path(self, vcsbackend):
515 def test_pull_wrong_path(self, vcsbackend):
516 target_repo = vcsbackend.create_repo()
516 target_repo = vcsbackend.create_repo()
517 with pytest.raises(RepositoryError):
517 with pytest.raises(RepositoryError):
518 target_repo.pull(target_repo.path + "wrong")
518 target_repo.pull(target_repo.path + "wrong")
519
519
520 def test_pull_specific_commits(self, vcsbackend):
520 def test_pull_specific_commits(self, vcsbackend):
521 source_repo = vcsbackend.repo
521 source_repo = vcsbackend.repo
522 target_repo = vcsbackend.create_repo()
522 target_repo = vcsbackend.create_repo()
523
523
524 second_commit = source_repo[1].raw_id
524 second_commit = source_repo[1].raw_id
525 if vcsbackend.alias == 'git':
525 if vcsbackend.alias == 'git':
526 second_commit_ref = 'refs/test-refs/a'
526 second_commit_ref = 'refs/test-refs/a'
527 source_repo.set_refs(second_commit_ref, second_commit)
527 source_repo.set_refs(second_commit_ref, second_commit)
528
528
529 target_repo.pull(source_repo.path, commit_ids=[second_commit])
529 target_repo.pull(source_repo.path, commit_ids=[second_commit])
530 target_repo = vcsbackend.backend(target_repo.path)
530 target_repo = vcsbackend.backend(target_repo.path)
531 assert 2 == len(target_repo.commit_ids)
531 assert 2 == len(target_repo.commit_ids)
532 assert second_commit == target_repo.get_commit().raw_id
532 assert second_commit == target_repo.get_commit().raw_id
General Comments 0
You need to be logged in to leave comments. Login now