blob: ff132b2117c5ed7529d6b1237a9f26069cb4ef8a [file] [log] [blame]
Simon Hausmann86949ee2007-03-19 20:59:12 +01001#!/usr/bin/env python
2#
3# git-p4.py -- A tool for bidirectional operation between a Perforce depot and git.
4#
Simon Hausmannc8cbbee2007-05-28 14:43:25 +02005# Author: Simon Hausmann <simon@lst.de>
6# Copyright: 2007 Simon Hausmann <simon@lst.de>
Simon Hausmann83dce552007-03-19 22:26:36 +01007# 2007 Trolltech ASA
Simon Hausmann86949ee2007-03-19 20:59:12 +01008# License: MIT <http://www.opensource.org/licenses/mit-license.php>
9#
Eric S. Raymonda33faf22012-12-28 11:40:59 -050010import sys
11if sys.hexversion < 0x02040000:
12 # The limiter is the subprocess module
13 sys.stderr.write("git-p4: requires Python 2.4 or later.\n")
14 sys.exit(1)
Pete Wyckofff629fa52013-01-26 22:11:05 -050015import os
16import optparse
17import marshal
18import subprocess
19import tempfile
20import time
21import platform
22import re
23import shutil
Pete Wyckoffd20f0f82013-01-26 22:11:19 -050024import stat
Han-Wen Nienhuys8b41a972007-05-23 18:20:53 -030025
Brandon Caseya235e852013-01-26 11:14:33 -080026try:
27 from subprocess import CalledProcessError
28except ImportError:
29 # from python2.7:subprocess.py
30 # Exception classes used by this module.
31 class CalledProcessError(Exception):
32 """This exception is raised when a process run by check_call() returns
33 a non-zero exit status. The exit status will be stored in the
34 returncode attribute."""
35 def __init__(self, returncode, cmd):
36 self.returncode = returncode
37 self.cmd = cmd
38 def __str__(self):
39 return "Command '%s' returned non-zero exit status %d" % (self.cmd, self.returncode)
40
Han-Wen Nienhuys4addad22007-05-23 18:49:35 -030041verbose = False
Simon Hausmann86949ee2007-03-19 20:59:12 +010042
Luke Diamand06804c72012-04-11 17:21:24 +020043# Only labels/tags matching this will be imported/exported
Luke Diamandc8942a22012-04-11 17:21:24 +020044defaultLabelRegexp = r'[a-zA-Z0-9_\-.]+$'
Anand Kumria21a50752008-08-10 19:26:28 +010045
46def p4_build_cmd(cmd):
47 """Build a suitable p4 command line.
48
49 This consolidates building and returning a p4 command line into one
50 location. It means that hooking into the environment, or other configuration
51 can be done more easily.
52 """
Luke Diamand6de040d2011-10-16 10:47:52 -040053 real_cmd = ["p4"]
Anand Kumriaabcaf072008-08-10 19:26:31 +010054
55 user = gitConfig("git-p4.user")
56 if len(user) > 0:
Luke Diamand6de040d2011-10-16 10:47:52 -040057 real_cmd += ["-u",user]
Anand Kumriaabcaf072008-08-10 19:26:31 +010058
59 password = gitConfig("git-p4.password")
60 if len(password) > 0:
Luke Diamand6de040d2011-10-16 10:47:52 -040061 real_cmd += ["-P", password]
Anand Kumriaabcaf072008-08-10 19:26:31 +010062
63 port = gitConfig("git-p4.port")
64 if len(port) > 0:
Luke Diamand6de040d2011-10-16 10:47:52 -040065 real_cmd += ["-p", port]
Anand Kumriaabcaf072008-08-10 19:26:31 +010066
67 host = gitConfig("git-p4.host")
68 if len(host) > 0:
Russell Myers41799aa2012-02-22 11:16:05 -080069 real_cmd += ["-H", host]
Anand Kumriaabcaf072008-08-10 19:26:31 +010070
71 client = gitConfig("git-p4.client")
72 if len(client) > 0:
Luke Diamand6de040d2011-10-16 10:47:52 -040073 real_cmd += ["-c", client]
Anand Kumriaabcaf072008-08-10 19:26:31 +010074
Luke Diamand6de040d2011-10-16 10:47:52 -040075
76 if isinstance(cmd,basestring):
77 real_cmd = ' '.join(real_cmd) + ' ' + cmd
78 else:
79 real_cmd += cmd
Anand Kumria21a50752008-08-10 19:26:28 +010080 return real_cmd
81
Miklós Fazekasbbd84862013-03-11 17:45:29 -040082def chdir(path, is_client_path=False):
83 """Do chdir to the given path, and set the PWD environment
84 variable for use by P4. It does not look at getcwd() output.
85 Since we're not using the shell, it is necessary to set the
86 PWD environment variable explicitly.
87
88 Normally, expand the path to force it to be absolute. This
89 addresses the use of relative path names inside P4 settings,
90 e.g. P4CONFIG=.p4config. P4 does not simply open the filename
91 as given; it looks for .p4config using PWD.
92
93 If is_client_path, the path was handed to us directly by p4,
94 and may be a symbolic link. Do not call os.getcwd() in this
95 case, because it will cause p4 to think that PWD is not inside
96 the client path.
97 """
98
99 os.chdir(path)
100 if not is_client_path:
101 path = os.getcwd()
102 os.environ['PWD'] = path
Robert Blum053fd0c2008-08-01 12:50:03 -0700103
Han-Wen Nienhuys86dff6b2007-05-23 18:49:35 -0300104def die(msg):
105 if verbose:
106 raise Exception(msg)
107 else:
108 sys.stderr.write(msg + "\n")
109 sys.exit(1)
110
Luke Diamand6de040d2011-10-16 10:47:52 -0400111def write_pipe(c, stdin):
Han-Wen Nienhuys4addad22007-05-23 18:49:35 -0300112 if verbose:
Luke Diamand6de040d2011-10-16 10:47:52 -0400113 sys.stderr.write('Writing pipe: %s\n' % str(c))
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300114
Luke Diamand6de040d2011-10-16 10:47:52 -0400115 expand = isinstance(c,basestring)
116 p = subprocess.Popen(c, stdin=subprocess.PIPE, shell=expand)
117 pipe = p.stdin
118 val = pipe.write(stdin)
119 pipe.close()
120 if p.wait():
121 die('Command failed: %s' % str(c))
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300122
123 return val
124
Luke Diamand6de040d2011-10-16 10:47:52 -0400125def p4_write_pipe(c, stdin):
Anand Kumriad9429192008-08-14 23:40:38 +0100126 real_cmd = p4_build_cmd(c)
Luke Diamand6de040d2011-10-16 10:47:52 -0400127 return write_pipe(real_cmd, stdin)
Anand Kumriad9429192008-08-14 23:40:38 +0100128
Han-Wen Nienhuys4addad22007-05-23 18:49:35 -0300129def read_pipe(c, ignore_error=False):
130 if verbose:
Luke Diamand6de040d2011-10-16 10:47:52 -0400131 sys.stderr.write('Reading pipe: %s\n' % str(c))
Han-Wen Nienhuys8b41a972007-05-23 18:20:53 -0300132
Luke Diamand6de040d2011-10-16 10:47:52 -0400133 expand = isinstance(c,basestring)
134 p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand)
135 pipe = p.stdout
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300136 val = pipe.read()
Luke Diamand6de040d2011-10-16 10:47:52 -0400137 if p.wait() and not ignore_error:
138 die('Command failed: %s' % str(c))
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300139
140 return val
141
Anand Kumriad9429192008-08-14 23:40:38 +0100142def p4_read_pipe(c, ignore_error=False):
143 real_cmd = p4_build_cmd(c)
144 return read_pipe(real_cmd, ignore_error)
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300145
Han-Wen Nienhuysbce4c5f2007-05-23 17:14:33 -0300146def read_pipe_lines(c):
Han-Wen Nienhuys4addad22007-05-23 18:49:35 -0300147 if verbose:
Luke Diamand6de040d2011-10-16 10:47:52 -0400148 sys.stderr.write('Reading pipe: %s\n' % str(c))
149
150 expand = isinstance(c, basestring)
151 p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand)
152 pipe = p.stdout
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300153 val = pipe.readlines()
Luke Diamand6de040d2011-10-16 10:47:52 -0400154 if pipe.close() or p.wait():
155 die('Command failed: %s' % str(c))
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300156
157 return val
Simon Hausmanncaace112007-05-15 14:57:57 +0200158
Anand Kumria23181212008-08-10 19:26:24 +0100159def p4_read_pipe_lines(c):
160 """Specifically invoke p4 on the command supplied. """
Anand Kumria155af832008-08-10 19:26:30 +0100161 real_cmd = p4_build_cmd(c)
Anand Kumria23181212008-08-10 19:26:24 +0100162 return read_pipe_lines(real_cmd)
163
Gary Gibbons8e9497c2012-07-12 19:29:00 -0400164def p4_has_command(cmd):
165 """Ask p4 for help on this command. If it returns an error, the
166 command does not exist in this version of p4."""
167 real_cmd = p4_build_cmd(["help", cmd])
168 p = subprocess.Popen(real_cmd, stdout=subprocess.PIPE,
169 stderr=subprocess.PIPE)
170 p.communicate()
171 return p.returncode == 0
172
Pete Wyckoff249da4c2012-11-23 17:35:35 -0500173def p4_has_move_command():
174 """See if the move command exists, that it supports -k, and that
175 it has not been administratively disabled. The arguments
176 must be correct, but the filenames do not have to exist. Use
177 ones with wildcards so even if they exist, it will fail."""
178
179 if not p4_has_command("move"):
180 return False
181 cmd = p4_build_cmd(["move", "-k", "@from", "@to"])
182 p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
183 (out, err) = p.communicate()
184 # return code will be 1 in either case
185 if err.find("Invalid option") >= 0:
186 return False
187 if err.find("disabled") >= 0:
188 return False
189 # assume it failed because @... was invalid changelist
190 return True
191
Han-Wen Nienhuys6754a292007-05-23 17:41:50 -0300192def system(cmd):
Luke Diamand6de040d2011-10-16 10:47:52 -0400193 expand = isinstance(cmd,basestring)
Han-Wen Nienhuys4addad22007-05-23 18:49:35 -0300194 if verbose:
Luke Diamand6de040d2011-10-16 10:47:52 -0400195 sys.stderr.write("executing %s\n" % str(cmd))
Brandon Caseya235e852013-01-26 11:14:33 -0800196 retcode = subprocess.call(cmd, shell=expand)
197 if retcode:
198 raise CalledProcessError(retcode, cmd)
Han-Wen Nienhuys6754a292007-05-23 17:41:50 -0300199
Anand Kumriabf9320f2008-08-10 19:26:26 +0100200def p4_system(cmd):
201 """Specifically invoke p4 as the system command. """
Anand Kumria155af832008-08-10 19:26:30 +0100202 real_cmd = p4_build_cmd(cmd)
Luke Diamand6de040d2011-10-16 10:47:52 -0400203 expand = isinstance(real_cmd, basestring)
Brandon Caseya235e852013-01-26 11:14:33 -0800204 retcode = subprocess.call(real_cmd, shell=expand)
205 if retcode:
206 raise CalledProcessError(retcode, real_cmd)
Luke Diamand6de040d2011-10-16 10:47:52 -0400207
Pete Wyckoff7f0e5962013-01-26 22:11:13 -0500208_p4_version_string = None
209def p4_version_string():
210 """Read the version string, showing just the last line, which
211 hopefully is the interesting version bit.
212
213 $ p4 -V
214 Perforce - The Fast Software Configuration Management System.
215 Copyright 1995-2011 Perforce Software. All rights reserved.
216 Rev. P4/NTX86/2011.1/393975 (2011/12/16).
217 """
218 global _p4_version_string
219 if not _p4_version_string:
220 a = p4_read_pipe_lines(["-V"])
221 _p4_version_string = a[-1].rstrip()
222 return _p4_version_string
223
Luke Diamand6de040d2011-10-16 10:47:52 -0400224def p4_integrate(src, dest):
Pete Wyckoff9d7d4462012-04-29 20:57:17 -0400225 p4_system(["integrate", "-Dt", wildcard_encode(src), wildcard_encode(dest)])
Luke Diamand6de040d2011-10-16 10:47:52 -0400226
Pete Wyckoff8d7ec362012-04-29 20:57:14 -0400227def p4_sync(f, *options):
Pete Wyckoff9d7d4462012-04-29 20:57:17 -0400228 p4_system(["sync"] + list(options) + [wildcard_encode(f)])
Luke Diamand6de040d2011-10-16 10:47:52 -0400229
230def p4_add(f):
Pete Wyckoff9d7d4462012-04-29 20:57:17 -0400231 # forcibly add file names with wildcards
232 if wildcard_present(f):
233 p4_system(["add", "-f", f])
234 else:
235 p4_system(["add", f])
Luke Diamand6de040d2011-10-16 10:47:52 -0400236
237def p4_delete(f):
Pete Wyckoff9d7d4462012-04-29 20:57:17 -0400238 p4_system(["delete", wildcard_encode(f)])
Luke Diamand6de040d2011-10-16 10:47:52 -0400239
240def p4_edit(f):
Pete Wyckoff9d7d4462012-04-29 20:57:17 -0400241 p4_system(["edit", wildcard_encode(f)])
Luke Diamand6de040d2011-10-16 10:47:52 -0400242
243def p4_revert(f):
Pete Wyckoff9d7d4462012-04-29 20:57:17 -0400244 p4_system(["revert", wildcard_encode(f)])
Luke Diamand6de040d2011-10-16 10:47:52 -0400245
Pete Wyckoff9d7d4462012-04-29 20:57:17 -0400246def p4_reopen(type, f):
247 p4_system(["reopen", "-t", type, wildcard_encode(f)])
Anand Kumriabf9320f2008-08-10 19:26:26 +0100248
Gary Gibbons8e9497c2012-07-12 19:29:00 -0400249def p4_move(src, dest):
250 p4_system(["move", "-k", wildcard_encode(src), wildcard_encode(dest)])
251
Pete Wyckoff18fa13d2012-11-23 17:35:34 -0500252def p4_describe(change):
253 """Make sure it returns a valid result by checking for
254 the presence of field "time". Return a dict of the
255 results."""
256
257 ds = p4CmdList(["describe", "-s", str(change)])
258 if len(ds) != 1:
259 die("p4 describe -s %d did not return 1 result: %s" % (change, str(ds)))
260
261 d = ds[0]
262
263 if "p4ExitCode" in d:
264 die("p4 describe -s %d exited with %d: %s" % (change, d["p4ExitCode"],
265 str(d)))
266 if "code" in d:
267 if d["code"] == "error":
268 die("p4 describe -s %d returned error code: %s" % (change, str(d)))
269
270 if "time" not in d:
271 die("p4 describe -s %d returned no \"time\": %s" % (change, str(d)))
272
273 return d
274
Pete Wyckoff9cffb8c2011-10-16 10:45:01 -0400275#
276# Canonicalize the p4 type and return a tuple of the
277# base type, plus any modifiers. See "p4 help filetypes"
278# for a list and explanation.
279#
280def split_p4_type(p4type):
David Brownb9fc6ea2007-09-19 13:12:48 -0700281
Pete Wyckoff9cffb8c2011-10-16 10:45:01 -0400282 p4_filetypes_historical = {
283 "ctempobj": "binary+Sw",
284 "ctext": "text+C",
285 "cxtext": "text+Cx",
286 "ktext": "text+k",
287 "kxtext": "text+kx",
288 "ltext": "text+F",
289 "tempobj": "binary+FSw",
290 "ubinary": "binary+F",
291 "uresource": "resource+F",
292 "uxbinary": "binary+Fx",
293 "xbinary": "binary+x",
294 "xltext": "text+Fx",
295 "xtempobj": "binary+Swx",
296 "xtext": "text+x",
297 "xunicode": "unicode+x",
298 "xutf16": "utf16+x",
299 }
300 if p4type in p4_filetypes_historical:
301 p4type = p4_filetypes_historical[p4type]
302 mods = ""
303 s = p4type.split("+")
304 base = s[0]
305 mods = ""
306 if len(s) > 1:
307 mods = s[1]
308 return (base, mods)
309
Luke Diamand60df0712012-02-23 07:51:30 +0000310#
311# return the raw p4 type of a file (text, text+ko, etc)
312#
Pete Wyckoff79467e62014-01-21 18:16:45 -0500313def p4_type(f):
314 results = p4CmdList(["fstat", "-T", "headType", wildcard_encode(f)])
Luke Diamand60df0712012-02-23 07:51:30 +0000315 return results[0]['headType']
316
317#
318# Given a type base and modifier, return a regexp matching
319# the keywords that can be expanded in the file
320#
321def p4_keywords_regexp_for_type(base, type_mods):
322 if base in ("text", "unicode", "binary"):
323 kwords = None
324 if "ko" in type_mods:
325 kwords = 'Id|Header'
326 elif "k" in type_mods:
327 kwords = 'Id|Header|Author|Date|DateTime|Change|File|Revision'
328 else:
329 return None
330 pattern = r"""
331 \$ # Starts with a dollar, followed by...
332 (%s) # one of the keywords, followed by...
Pete Wyckoff6b2bf412012-11-04 17:04:02 -0500333 (:[^$\n]+)? # possibly an old expansion, followed by...
Luke Diamand60df0712012-02-23 07:51:30 +0000334 \$ # another dollar
335 """ % kwords
336 return pattern
337 else:
338 return None
339
340#
341# Given a file, return a regexp matching the possible
342# RCS keywords that will be expanded, or None for files
343# with kw expansion turned off.
344#
345def p4_keywords_regexp_for_file(file):
346 if not os.path.exists(file):
347 return None
348 else:
349 (type_base, type_mods) = split_p4_type(p4_type(file))
350 return p4_keywords_regexp_for_type(type_base, type_mods)
David Brownb9fc6ea2007-09-19 13:12:48 -0700351
Chris Pettittc65b6702007-11-01 20:43:14 -0700352def setP4ExecBit(file, mode):
353 # Reopens an already open file and changes the execute bit to match
354 # the execute bit setting in the passed in mode.
355
356 p4Type = "+x"
357
358 if not isModeExec(mode):
359 p4Type = getP4OpenedType(file)
360 p4Type = re.sub('^([cku]?)x(.*)', '\\1\\2', p4Type)
361 p4Type = re.sub('(.*?\+.*?)x(.*?)', '\\1\\2', p4Type)
362 if p4Type[-1] == "+":
363 p4Type = p4Type[0:-1]
364
Luke Diamand6de040d2011-10-16 10:47:52 -0400365 p4_reopen(p4Type, file)
Chris Pettittc65b6702007-11-01 20:43:14 -0700366
367def getP4OpenedType(file):
368 # Returns the perforce file type for the given file.
369
Pete Wyckoff9d7d4462012-04-29 20:57:17 -0400370 result = p4_read_pipe(["opened", wildcard_encode(file)])
Marius Storm-Olsenf3e5ae42008-03-28 15:40:40 +0100371 match = re.match(".*\((.+)\)\r?$", result)
Chris Pettittc65b6702007-11-01 20:43:14 -0700372 if match:
373 return match.group(1)
374 else:
Marius Storm-Olsenf3e5ae42008-03-28 15:40:40 +0100375 die("Could not determine file type for %s (result: '%s')" % (file, result))
Chris Pettittc65b6702007-11-01 20:43:14 -0700376
Luke Diamand06804c72012-04-11 17:21:24 +0200377# Return the set of all p4 labels
378def getP4Labels(depotPaths):
379 labels = set()
380 if isinstance(depotPaths,basestring):
381 depotPaths = [depotPaths]
382
383 for l in p4CmdList(["labels"] + ["%s..." % p for p in depotPaths]):
384 label = l['label']
385 labels.add(label)
386
387 return labels
388
389# Return the set of all git tags
390def getGitTags():
391 gitTags = set()
392 for line in read_pipe_lines(["git", "tag"]):
393 tag = line.strip()
394 gitTags.add(tag)
395 return gitTags
396
Chris Pettittb43b0a32007-11-01 20:43:13 -0700397def diffTreePattern():
398 # This is a simple generator for the diff tree regex pattern. This could be
399 # a class variable if this and parseDiffTreeEntry were a part of a class.
400 pattern = re.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)')
401 while True:
402 yield pattern
403
404def parseDiffTreeEntry(entry):
405 """Parses a single diff tree entry into its component elements.
406
407 See git-diff-tree(1) manpage for details about the format of the diff
408 output. This method returns a dictionary with the following elements:
409
410 src_mode - The mode of the source file
411 dst_mode - The mode of the destination file
412 src_sha1 - The sha1 for the source file
413 dst_sha1 - The sha1 fr the destination file
414 status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc)
415 status_score - The score for the status (applicable for 'C' and 'R'
416 statuses). This is None if there is no score.
417 src - The path for the source file.
418 dst - The path for the destination file. This is only present for
419 copy or renames. If it is not present, this is None.
420
421 If the pattern is not matched, None is returned."""
422
423 match = diffTreePattern().next().match(entry)
424 if match:
425 return {
426 'src_mode': match.group(1),
427 'dst_mode': match.group(2),
428 'src_sha1': match.group(3),
429 'dst_sha1': match.group(4),
430 'status': match.group(5),
431 'status_score': match.group(6),
432 'src': match.group(7),
433 'dst': match.group(10)
434 }
435 return None
436
Chris Pettittc65b6702007-11-01 20:43:14 -0700437def isModeExec(mode):
438 # Returns True if the given git mode represents an executable file,
439 # otherwise False.
440 return mode[-3:] == "755"
441
442def isModeExecChanged(src_mode, dst_mode):
443 return isModeExec(src_mode) != isModeExec(dst_mode)
444
Luke Diamandb9327052009-07-30 00:13:46 +0100445def p4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None):
Luke Diamand6de040d2011-10-16 10:47:52 -0400446
447 if isinstance(cmd,basestring):
448 cmd = "-G " + cmd
449 expand = True
450 else:
451 cmd = ["-G"] + cmd
452 expand = False
453
454 cmd = p4_build_cmd(cmd)
Han-Wen Nienhuys6a49f8e2007-05-23 18:49:35 -0300455 if verbose:
Luke Diamand6de040d2011-10-16 10:47:52 -0400456 sys.stderr.write("Opening pipe: %s\n" % str(cmd))
Scott Lamb9f90c732007-07-15 20:58:10 -0700457
458 # Use a temporary file to avoid deadlocks without
459 # subprocess.communicate(), which would put another copy
460 # of stdout into memory.
461 stdin_file = None
462 if stdin is not None:
463 stdin_file = tempfile.TemporaryFile(prefix='p4-stdin', mode=stdin_mode)
Luke Diamand6de040d2011-10-16 10:47:52 -0400464 if isinstance(stdin,basestring):
465 stdin_file.write(stdin)
466 else:
467 for i in stdin:
468 stdin_file.write(i + '\n')
Scott Lamb9f90c732007-07-15 20:58:10 -0700469 stdin_file.flush()
470 stdin_file.seek(0)
471
Luke Diamand6de040d2011-10-16 10:47:52 -0400472 p4 = subprocess.Popen(cmd,
473 shell=expand,
Scott Lamb9f90c732007-07-15 20:58:10 -0700474 stdin=stdin_file,
475 stdout=subprocess.PIPE)
Simon Hausmann86949ee2007-03-19 20:59:12 +0100476
477 result = []
478 try:
479 while True:
Scott Lamb9f90c732007-07-15 20:58:10 -0700480 entry = marshal.load(p4.stdout)
Andrew Garberc3f61632011-04-07 02:01:21 -0400481 if cb is not None:
482 cb(entry)
483 else:
484 result.append(entry)
Simon Hausmann86949ee2007-03-19 20:59:12 +0100485 except EOFError:
486 pass
Scott Lamb9f90c732007-07-15 20:58:10 -0700487 exitCode = p4.wait()
488 if exitCode != 0:
Simon Hausmannac3e0d72007-05-23 23:32:32 +0200489 entry = {}
490 entry["p4ExitCode"] = exitCode
491 result.append(entry)
Simon Hausmann86949ee2007-03-19 20:59:12 +0100492
493 return result
494
495def p4Cmd(cmd):
496 list = p4CmdList(cmd)
497 result = {}
498 for entry in list:
499 result.update(entry)
500 return result;
501
Simon Hausmanncb2c9db2007-03-24 09:15:11 +0100502def p4Where(depotPath):
503 if not depotPath.endswith("/"):
504 depotPath += "/"
Tor Arvid Lund7f705dc2008-12-04 14:37:33 +0100505 depotPath = depotPath + "..."
Luke Diamand6de040d2011-10-16 10:47:52 -0400506 outputList = p4CmdList(["where", depotPath])
Tor Arvid Lund7f705dc2008-12-04 14:37:33 +0100507 output = None
508 for entry in outputList:
Tor Arvid Lund75bc9572008-12-09 16:41:50 +0100509 if "depotFile" in entry:
510 if entry["depotFile"] == depotPath:
511 output = entry
512 break
513 elif "data" in entry:
514 data = entry.get("data")
515 space = data.find(" ")
516 if data[:space] == depotPath:
517 output = entry
518 break
Tor Arvid Lund7f705dc2008-12-04 14:37:33 +0100519 if output == None:
520 return ""
Simon Hausmanndc524032007-05-21 09:34:56 +0200521 if output["code"] == "error":
522 return ""
Simon Hausmanncb2c9db2007-03-24 09:15:11 +0100523 clientPath = ""
524 if "path" in output:
525 clientPath = output.get("path")
526 elif "data" in output:
527 data = output.get("data")
528 lastSpace = data.rfind(" ")
529 clientPath = data[lastSpace + 1:]
530
531 if clientPath.endswith("..."):
532 clientPath = clientPath[:-3]
533 return clientPath
534
Simon Hausmann86949ee2007-03-19 20:59:12 +0100535def currentGitBranch():
Han-Wen Nienhuysb25b2062007-05-23 18:49:35 -0300536 return read_pipe("git name-rev HEAD").split(" ")[1].strip()
Simon Hausmann86949ee2007-03-19 20:59:12 +0100537
Simon Hausmann4f5cf762007-03-19 22:25:17 +0100538def isValidGitDir(path):
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -0300539 if (os.path.exists(path + "/HEAD")
540 and os.path.exists(path + "/refs") and os.path.exists(path + "/objects")):
Simon Hausmann4f5cf762007-03-19 22:25:17 +0100541 return True;
542 return False
543
Simon Hausmann463e8af2007-05-17 09:13:54 +0200544def parseRevision(ref):
Han-Wen Nienhuysb25b2062007-05-23 18:49:35 -0300545 return read_pipe("git rev-parse %s" % ref).strip()
Simon Hausmann463e8af2007-05-17 09:13:54 +0200546
Pete Wyckoff28755db2011-12-24 21:07:40 -0500547def branchExists(ref):
548 rev = read_pipe(["git", "rev-parse", "-q", "--verify", ref],
549 ignore_error=True)
550 return len(rev) > 0
551
Simon Hausmann6ae8de82007-03-22 21:10:25 +0100552def extractLogMessageFromGitCommit(commit):
553 logMessage = ""
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300554
555 ## fixme: title is first line of commit, not 1st paragraph.
Simon Hausmann6ae8de82007-03-22 21:10:25 +0100556 foundTitle = False
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300557 for log in read_pipe_lines("git cat-file commit %s" % commit):
Simon Hausmann6ae8de82007-03-22 21:10:25 +0100558 if not foundTitle:
559 if len(log) == 1:
Simon Hausmann1c094182007-05-01 23:15:48 +0200560 foundTitle = True
Simon Hausmann6ae8de82007-03-22 21:10:25 +0100561 continue
562
563 logMessage += log
564 return logMessage
565
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -0300566def extractSettingsGitLog(log):
Simon Hausmann6ae8de82007-03-22 21:10:25 +0100567 values = {}
568 for line in log.split("\n"):
569 line = line.strip()
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -0300570 m = re.search (r"^ *\[git-p4: (.*)\]$", line)
571 if not m:
572 continue
Simon Hausmann6ae8de82007-03-22 21:10:25 +0100573
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -0300574 assignments = m.group(1).split (':')
575 for a in assignments:
576 vals = a.split ('=')
577 key = vals[0].strip()
578 val = ('='.join (vals[1:])).strip()
579 if val.endswith ('\"') and val.startswith('"'):
580 val = val[1:-1]
581
582 values[key] = val
583
Simon Hausmann845b42c2007-06-07 09:19:34 +0200584 paths = values.get("depot-paths")
585 if not paths:
586 paths = values.get("depot-path")
Simon Hausmanna3fdd572007-06-07 22:54:32 +0200587 if paths:
588 values['depot-paths'] = paths.split(',')
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -0300589 return values
Simon Hausmann6ae8de82007-03-22 21:10:25 +0100590
Simon Hausmann8136a632007-03-22 21:27:14 +0100591def gitBranchExists(branch):
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -0300592 proc = subprocess.Popen(["git", "rev-parse", branch],
593 stderr=subprocess.PIPE, stdout=subprocess.PIPE);
Simon Hausmanncaace112007-05-15 14:57:57 +0200594 return proc.wait() == 0;
Simon Hausmann8136a632007-03-22 21:27:14 +0100595
John Chapman36bd8442008-11-08 14:22:49 +1100596_gitConfig = {}
Pete Wyckoffb345d6c2013-01-26 22:11:23 -0500597
Pete Wyckoff0d609032013-01-26 22:11:24 -0500598def gitConfig(key):
John Chapman36bd8442008-11-08 14:22:49 +1100599 if not _gitConfig.has_key(key):
Pete Wyckoff0d609032013-01-26 22:11:24 -0500600 cmd = [ "git", "config", key ]
Pete Wyckoffb345d6c2013-01-26 22:11:23 -0500601 s = read_pipe(cmd, ignore_error=True)
602 _gitConfig[key] = s.strip()
John Chapman36bd8442008-11-08 14:22:49 +1100603 return _gitConfig[key]
Simon Hausmann01265102007-05-25 10:36:10 +0200604
Pete Wyckoff0d609032013-01-26 22:11:24 -0500605def gitConfigBool(key):
606 """Return a bool, using git config --bool. It is True only if the
607 variable is set to true, and False if set to false or not present
608 in the config."""
609
610 if not _gitConfig.has_key(key):
611 cmd = [ "git", "config", "--bool", key ]
612 s = read_pipe(cmd, ignore_error=True)
613 v = s.strip()
614 _gitConfig[key] = v == "true"
Simon Hausmann062410b2007-07-18 10:56:31 +0200615 return _gitConfig[key]
616
Vitor Antunes7199cf12011-08-19 00:44:05 +0100617def gitConfigList(key):
618 if not _gitConfig.has_key(key):
Pete Wyckoff2abba302013-01-26 22:11:22 -0500619 s = read_pipe(["git", "config", "--get-all", key], ignore_error=True)
620 _gitConfig[key] = s.strip().split(os.linesep)
Vitor Antunes7199cf12011-08-19 00:44:05 +0100621 return _gitConfig[key]
622
Pete Wyckoff2c8037e2013-01-14 19:46:57 -0500623def p4BranchesInGit(branchesAreInRemotes=True):
624 """Find all the branches whose names start with "p4/", looking
625 in remotes or heads as specified by the argument. Return
626 a dictionary of { branch: revision } for each one found.
627 The branch names are the short names, without any
628 "p4/" prefix."""
629
Simon Hausmann062410b2007-07-18 10:56:31 +0200630 branches = {}
631
632 cmdline = "git rev-parse --symbolic "
633 if branchesAreInRemotes:
Pete Wyckoff2c8037e2013-01-14 19:46:57 -0500634 cmdline += "--remotes"
Simon Hausmann062410b2007-07-18 10:56:31 +0200635 else:
Pete Wyckoff2c8037e2013-01-14 19:46:57 -0500636 cmdline += "--branches"
Simon Hausmann062410b2007-07-18 10:56:31 +0200637
638 for line in read_pipe_lines(cmdline):
639 line = line.strip()
640
Pete Wyckoff2c8037e2013-01-14 19:46:57 -0500641 # only import to p4/
642 if not line.startswith('p4/'):
Simon Hausmann062410b2007-07-18 10:56:31 +0200643 continue
Pete Wyckoff2c8037e2013-01-14 19:46:57 -0500644 # special symbolic ref to p4/master
645 if line == "p4/HEAD":
646 continue
Simon Hausmann062410b2007-07-18 10:56:31 +0200647
Pete Wyckoff2c8037e2013-01-14 19:46:57 -0500648 # strip off p4/ prefix
649 branch = line[len("p4/"):]
Simon Hausmann062410b2007-07-18 10:56:31 +0200650
651 branches[branch] = parseRevision(line)
Pete Wyckoff2c8037e2013-01-14 19:46:57 -0500652
Simon Hausmann062410b2007-07-18 10:56:31 +0200653 return branches
654
Pete Wyckoff5a8e84c2013-01-14 19:47:05 -0500655def branch_exists(branch):
656 """Make sure that the given ref name really exists."""
657
658 cmd = [ "git", "rev-parse", "--symbolic", "--verify", branch ]
659 p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
660 out, _ = p.communicate()
661 if p.returncode:
662 return False
663 # expect exactly one line of output: the branch name
664 return out.rstrip() == branch
665
Simon Hausmann9ceab362007-06-22 00:01:57 +0200666def findUpstreamBranchPoint(head = "HEAD"):
Simon Hausmann86506fe2007-07-18 12:40:12 +0200667 branches = p4BranchesInGit()
668 # map from depot-path to branch name
669 branchByDepotPath = {}
670 for branch in branches.keys():
671 tip = branches[branch]
672 log = extractLogMessageFromGitCommit(tip)
673 settings = extractSettingsGitLog(log)
674 if settings.has_key("depot-paths"):
675 paths = ",".join(settings["depot-paths"])
676 branchByDepotPath[paths] = "remotes/p4/" + branch
677
Simon Hausmann27d2d812007-06-12 14:31:59 +0200678 settings = None
Simon Hausmann27d2d812007-06-12 14:31:59 +0200679 parent = 0
680 while parent < 65535:
Simon Hausmann9ceab362007-06-22 00:01:57 +0200681 commit = head + "~%s" % parent
Simon Hausmann27d2d812007-06-12 14:31:59 +0200682 log = extractLogMessageFromGitCommit(commit)
683 settings = extractSettingsGitLog(log)
Simon Hausmann86506fe2007-07-18 12:40:12 +0200684 if settings.has_key("depot-paths"):
685 paths = ",".join(settings["depot-paths"])
686 if branchByDepotPath.has_key(paths):
687 return [branchByDepotPath[paths], settings]
Simon Hausmann27d2d812007-06-12 14:31:59 +0200688
Simon Hausmann86506fe2007-07-18 12:40:12 +0200689 parent = parent + 1
Simon Hausmann27d2d812007-06-12 14:31:59 +0200690
Simon Hausmann86506fe2007-07-18 12:40:12 +0200691 return ["", settings]
Simon Hausmann27d2d812007-06-12 14:31:59 +0200692
Simon Hausmann5ca44612007-08-24 17:44:16 +0200693def createOrUpdateBranchesFromOrigin(localRefPrefix = "refs/remotes/p4/", silent=True):
694 if not silent:
695 print ("Creating/updating branch(es) in %s based on origin branch(es)"
696 % localRefPrefix)
697
698 originPrefix = "origin/p4/"
699
700 for line in read_pipe_lines("git rev-parse --symbolic --remotes"):
701 line = line.strip()
702 if (not line.startswith(originPrefix)) or line.endswith("HEAD"):
703 continue
704
705 headName = line[len(originPrefix):]
706 remoteHead = localRefPrefix + headName
707 originHead = line
708
709 original = extractSettingsGitLog(extractLogMessageFromGitCommit(originHead))
710 if (not original.has_key('depot-paths')
711 or not original.has_key('change')):
712 continue
713
714 update = False
715 if not gitBranchExists(remoteHead):
716 if verbose:
717 print "creating %s" % remoteHead
718 update = True
719 else:
720 settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead))
721 if settings.has_key('change') > 0:
722 if settings['depot-paths'] == original['depot-paths']:
723 originP4Change = int(original['change'])
724 p4Change = int(settings['change'])
725 if originP4Change > p4Change:
726 print ("%s (%s) is newer than %s (%s). "
727 "Updating p4 branch from origin."
728 % (originHead, originP4Change,
729 remoteHead, p4Change))
730 update = True
731 else:
732 print ("Ignoring: %s was imported from %s while "
733 "%s was imported from %s"
734 % (originHead, ','.join(original['depot-paths']),
735 remoteHead, ','.join(settings['depot-paths'])))
736
737 if update:
738 system("git update-ref %s %s" % (remoteHead, originHead))
739
740def originP4BranchesExist():
741 return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
742
Simon Hausmann4f6432d2007-08-26 15:56:36 +0200743def p4ChangesForPaths(depotPaths, changeRange):
744 assert depotPaths
Luke Diamand6de040d2011-10-16 10:47:52 -0400745 cmd = ['changes']
746 for p in depotPaths:
747 cmd += ["%s...%s" % (p, changeRange)]
748 output = p4_read_pipe_lines(cmd)
Simon Hausmann4f6432d2007-08-26 15:56:36 +0200749
Pete Wyckoffb4b0ba02009-02-18 13:12:14 -0500750 changes = {}
Simon Hausmann4f6432d2007-08-26 15:56:36 +0200751 for line in output:
Andrew Garberc3f61632011-04-07 02:01:21 -0400752 changeNum = int(line.split(" ")[1])
753 changes[changeNum] = True
Simon Hausmann4f6432d2007-08-26 15:56:36 +0200754
Pete Wyckoffb4b0ba02009-02-18 13:12:14 -0500755 changelist = changes.keys()
756 changelist.sort()
757 return changelist
Simon Hausmann4f6432d2007-08-26 15:56:36 +0200758
Tor Arvid Lundd53de8b2011-03-15 13:08:02 +0100759def p4PathStartsWith(path, prefix):
760 # This method tries to remedy a potential mixed-case issue:
761 #
762 # If UserA adds //depot/DirA/file1
763 # and UserB adds //depot/dira/file2
764 #
765 # we may or may not have a problem. If you have core.ignorecase=true,
766 # we treat DirA and dira as the same directory
Pete Wyckoff0d609032013-01-26 22:11:24 -0500767 if gitConfigBool("core.ignorecase"):
Tor Arvid Lundd53de8b2011-03-15 13:08:02 +0100768 return path.lower().startswith(prefix.lower())
769 return path.startswith(prefix)
770
Pete Wyckoff543987b2012-02-25 20:06:25 -0500771def getClientSpec():
772 """Look at the p4 client spec, create a View() object that contains
773 all the mappings, and return it."""
774
775 specList = p4CmdList("client -o")
776 if len(specList) != 1:
777 die('Output from "client -o" is %d lines, expecting 1' %
778 len(specList))
779
780 # dictionary of all client parameters
781 entry = specList[0]
782
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +0900783 # the //client/ name
784 client_name = entry["Client"]
785
Pete Wyckoff543987b2012-02-25 20:06:25 -0500786 # just the keys that start with "View"
787 view_keys = [ k for k in entry.keys() if k.startswith("View") ]
788
789 # hold this new View
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +0900790 view = View(client_name)
Pete Wyckoff543987b2012-02-25 20:06:25 -0500791
792 # append the lines, in order, to the view
793 for view_num in range(len(view_keys)):
794 k = "View%d" % view_num
795 if k not in view_keys:
796 die("Expected view key %s missing" % k)
797 view.append(entry[k])
798
799 return view
800
801def getClientRoot():
802 """Grab the client directory."""
803
804 output = p4CmdList("client -o")
805 if len(output) != 1:
806 die('Output from "client -o" is %d lines, expecting 1' % len(output))
807
808 entry = output[0]
809 if "Root" not in entry:
810 die('Client has no "Root"')
811
812 return entry["Root"]
813
Pete Wyckoff9d7d4462012-04-29 20:57:17 -0400814#
815# P4 wildcards are not allowed in filenames. P4 complains
816# if you simply add them, but you can force it with "-f", in
817# which case it translates them into %xx encoding internally.
818#
819def wildcard_decode(path):
820 # Search for and fix just these four characters. Do % last so
821 # that fixing it does not inadvertently create new %-escapes.
822 # Cannot have * in a filename in windows; untested as to
823 # what p4 would do in such a case.
824 if not platform.system() == "Windows":
825 path = path.replace("%2A", "*")
826 path = path.replace("%23", "#") \
827 .replace("%40", "@") \
828 .replace("%25", "%")
829 return path
830
831def wildcard_encode(path):
832 # do % first to avoid double-encoding the %s introduced here
833 path = path.replace("%", "%25") \
834 .replace("*", "%2A") \
835 .replace("#", "%23") \
836 .replace("@", "%40")
837 return path
838
839def wildcard_present(path):
Brandon Casey598354c2013-01-26 11:14:32 -0800840 m = re.search("[*#@%]", path)
841 return m is not None
Pete Wyckoff9d7d4462012-04-29 20:57:17 -0400842
Simon Hausmannb9847332007-03-20 20:54:23 +0100843class Command:
844 def __init__(self):
845 self.usage = "usage: %prog [options]"
Simon Hausmann8910ac02007-03-26 08:18:55 +0200846 self.needsGit = True
Luke Diamand6a10b6a2012-04-24 09:33:23 +0100847 self.verbose = False
Simon Hausmannb9847332007-03-20 20:54:23 +0100848
Luke Diamand3ea2cfd2011-04-21 20:50:23 +0100849class P4UserMap:
850 def __init__(self):
851 self.userMapFromPerforceServer = False
Luke Diamandaffb4742012-01-19 09:52:27 +0000852 self.myP4UserId = None
853
854 def p4UserId(self):
855 if self.myP4UserId:
856 return self.myP4UserId
857
858 results = p4CmdList("user -o")
859 for r in results:
860 if r.has_key('User'):
861 self.myP4UserId = r['User']
862 return r['User']
863 die("Could not find your p4 user id")
864
865 def p4UserIsMe(self, p4User):
866 # return True if the given p4 user is actually me
867 me = self.p4UserId()
868 if not p4User or p4User != me:
869 return False
870 else:
871 return True
Luke Diamand3ea2cfd2011-04-21 20:50:23 +0100872
873 def getUserCacheFilename(self):
874 home = os.environ.get("HOME", os.environ.get("USERPROFILE"))
875 return home + "/.gitp4-usercache.txt"
876
877 def getUserMapFromPerforceServer(self):
878 if self.userMapFromPerforceServer:
879 return
880 self.users = {}
881 self.emails = {}
882
883 for output in p4CmdList("users"):
884 if not output.has_key("User"):
885 continue
886 self.users[output["User"]] = output["FullName"] + " <" + output["Email"] + ">"
887 self.emails[output["Email"]] = output["User"]
888
889
890 s = ''
891 for (key, val) in self.users.items():
892 s += "%s\t%s\n" % (key.expandtabs(1), val.expandtabs(1))
893
894 open(self.getUserCacheFilename(), "wb").write(s)
895 self.userMapFromPerforceServer = True
896
897 def loadUserMapFromCache(self):
898 self.users = {}
899 self.userMapFromPerforceServer = False
900 try:
901 cache = open(self.getUserCacheFilename(), "rb")
902 lines = cache.readlines()
903 cache.close()
904 for line in lines:
905 entry = line.strip().split("\t")
906 self.users[entry[0]] = entry[1]
907 except IOError:
908 self.getUserMapFromPerforceServer()
909
Simon Hausmannb9847332007-03-20 20:54:23 +0100910class P4Debug(Command):
Simon Hausmann86949ee2007-03-19 20:59:12 +0100911 def __init__(self):
Simon Hausmann6ae8de82007-03-22 21:10:25 +0100912 Command.__init__(self)
Luke Diamand6a10b6a2012-04-24 09:33:23 +0100913 self.options = []
Simon Hausmannc8c39112007-03-19 21:02:30 +0100914 self.description = "A tool to debug the output of p4 -G."
Simon Hausmann8910ac02007-03-26 08:18:55 +0200915 self.needsGit = False
Simon Hausmann86949ee2007-03-19 20:59:12 +0100916
917 def run(self, args):
Han-Wen Nienhuysb1ce9442007-05-23 18:49:35 -0300918 j = 0
Luke Diamand6de040d2011-10-16 10:47:52 -0400919 for output in p4CmdList(args):
Han-Wen Nienhuysb1ce9442007-05-23 18:49:35 -0300920 print 'Element: %d' % j
921 j += 1
Simon Hausmann86949ee2007-03-19 20:59:12 +0100922 print output
Simon Hausmannb9847332007-03-20 20:54:23 +0100923 return True
Simon Hausmann86949ee2007-03-19 20:59:12 +0100924
Simon Hausmann58346842007-05-21 22:57:06 +0200925class P4RollBack(Command):
926 def __init__(self):
927 Command.__init__(self)
928 self.options = [
Simon Hausmann0c66a782007-05-23 20:07:57 +0200929 optparse.make_option("--local", dest="rollbackLocalBranches", action="store_true")
Simon Hausmann58346842007-05-21 22:57:06 +0200930 ]
931 self.description = "A tool to debug the multi-branch import. Don't use :)"
Simon Hausmann0c66a782007-05-23 20:07:57 +0200932 self.rollbackLocalBranches = False
Simon Hausmann58346842007-05-21 22:57:06 +0200933
934 def run(self, args):
935 if len(args) != 1:
936 return False
937 maxChange = int(args[0])
Simon Hausmann0c66a782007-05-23 20:07:57 +0200938
Simon Hausmannad192f22007-05-23 23:44:19 +0200939 if "p4ExitCode" in p4Cmd("changes -m 1"):
Simon Hausmann66a2f522007-05-23 23:40:48 +0200940 die("Problems executing p4");
941
Simon Hausmann0c66a782007-05-23 20:07:57 +0200942 if self.rollbackLocalBranches:
943 refPrefix = "refs/heads/"
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300944 lines = read_pipe_lines("git rev-parse --symbolic --branches")
Simon Hausmann0c66a782007-05-23 20:07:57 +0200945 else:
946 refPrefix = "refs/remotes/"
Han-Wen Nienhuysb016d392007-05-23 17:10:46 -0300947 lines = read_pipe_lines("git rev-parse --symbolic --remotes")
Simon Hausmann0c66a782007-05-23 20:07:57 +0200948
949 for line in lines:
950 if self.rollbackLocalBranches or (line.startswith("p4/") and line != "p4/HEAD\n"):
Han-Wen Nienhuysb25b2062007-05-23 18:49:35 -0300951 line = line.strip()
952 ref = refPrefix + line
Simon Hausmann58346842007-05-21 22:57:06 +0200953 log = extractLogMessageFromGitCommit(ref)
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -0300954 settings = extractSettingsGitLog(log)
955
956 depotPaths = settings['depot-paths']
957 change = settings['change']
958
Simon Hausmann58346842007-05-21 22:57:06 +0200959 changed = False
Simon Hausmann52102d42007-05-21 23:44:24 +0200960
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -0300961 if len(p4Cmd("changes -m 1 " + ' '.join (['%s...@%s' % (p, maxChange)
962 for p in depotPaths]))) == 0:
Simon Hausmann52102d42007-05-21 23:44:24 +0200963 print "Branch %s did not exist at change %s, deleting." % (ref, maxChange)
964 system("git update-ref -d %s `git rev-parse %s`" % (ref, ref))
965 continue
966
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -0300967 while change and int(change) > maxChange:
Simon Hausmann58346842007-05-21 22:57:06 +0200968 changed = True
Simon Hausmann52102d42007-05-21 23:44:24 +0200969 if self.verbose:
970 print "%s is at %s ; rewinding towards %s" % (ref, change, maxChange)
Simon Hausmann58346842007-05-21 22:57:06 +0200971 system("git update-ref %s \"%s^\"" % (ref, ref))
972 log = extractLogMessageFromGitCommit(ref)
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -0300973 settings = extractSettingsGitLog(log)
974
975
976 depotPaths = settings['depot-paths']
977 change = settings['change']
Simon Hausmann58346842007-05-21 22:57:06 +0200978
979 if changed:
Simon Hausmann52102d42007-05-21 23:44:24 +0200980 print "%s rewound to %s" % (ref, change)
Simon Hausmann58346842007-05-21 22:57:06 +0200981
982 return True
983
Luke Diamand3ea2cfd2011-04-21 20:50:23 +0100984class P4Submit(Command, P4UserMap):
Pete Wyckoff6bbfd132012-09-09 16:16:13 -0400985
986 conflict_behavior_choices = ("ask", "skip", "quit")
987
Simon Hausmann4f5cf762007-03-19 22:25:17 +0100988 def __init__(self):
Simon Hausmannb9847332007-03-20 20:54:23 +0100989 Command.__init__(self)
Luke Diamand3ea2cfd2011-04-21 20:50:23 +0100990 P4UserMap.__init__(self)
Simon Hausmann4f5cf762007-03-19 22:25:17 +0100991 self.options = [
Simon Hausmann4f5cf762007-03-19 22:25:17 +0100992 optparse.make_option("--origin", dest="origin"),
Vitor Antunesae901092011-02-20 01:18:24 +0000993 optparse.make_option("-M", dest="detectRenames", action="store_true"),
Luke Diamand3ea2cfd2011-04-21 20:50:23 +0100994 # preserve the user, requires relevant p4 permissions
995 optparse.make_option("--preserve-user", dest="preserveUser", action="store_true"),
Luke Diamand06804c72012-04-11 17:21:24 +0200996 optparse.make_option("--export-labels", dest="exportLabels", action="store_true"),
Pete Wyckoffef739f02012-09-09 16:16:11 -0400997 optparse.make_option("--dry-run", "-n", dest="dry_run", action="store_true"),
Pete Wyckoff728b7ad2012-09-09 16:16:12 -0400998 optparse.make_option("--prepare-p4-only", dest="prepare_p4_only", action="store_true"),
Pete Wyckoff6bbfd132012-09-09 16:16:13 -0400999 optparse.make_option("--conflict", dest="conflict_behavior",
Pete Wyckoff44e8d262013-01-14 19:47:08 -05001000 choices=self.conflict_behavior_choices),
1001 optparse.make_option("--branch", dest="branch"),
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001002 ]
1003 self.description = "Submit changes from git to the perforce depot."
Simon Hausmannc9b50e62007-03-29 19:15:24 +02001004 self.usage += " [name of git branch to submit into perforce depot]"
Simon Hausmann95124972007-03-23 09:16:07 +01001005 self.origin = ""
Vitor Antunesae901092011-02-20 01:18:24 +00001006 self.detectRenames = False
Pete Wyckoff0d609032013-01-26 22:11:24 -05001007 self.preserveUser = gitConfigBool("git-p4.preserveUser")
Pete Wyckoffef739f02012-09-09 16:16:11 -04001008 self.dry_run = False
Pete Wyckoff728b7ad2012-09-09 16:16:12 -04001009 self.prepare_p4_only = False
Pete Wyckoff6bbfd132012-09-09 16:16:13 -04001010 self.conflict_behavior = None
Marius Storm-Olsenf7baba82007-06-07 14:07:01 +02001011 self.isWindows = (platform.system() == "Windows")
Luke Diamand06804c72012-04-11 17:21:24 +02001012 self.exportLabels = False
Pete Wyckoff249da4c2012-11-23 17:35:35 -05001013 self.p4HasMoveCommand = p4_has_move_command()
Pete Wyckoff44e8d262013-01-14 19:47:08 -05001014 self.branch = None
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001015
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001016 def check(self):
1017 if len(p4CmdList("opened ...")) > 0:
1018 die("You have files opened with perforce! Close them before starting the sync.")
1019
Pete Wyckofff19cb0a2012-07-04 09:34:20 -04001020 def separate_jobs_from_description(self, message):
1021 """Extract and return a possible Jobs field in the commit
1022 message. It goes into a separate section in the p4 change
1023 specification.
1024
1025 A jobs line starts with "Jobs:" and looks like a new field
1026 in a form. Values are white-space separated on the same
1027 line or on following lines that start with a tab.
1028
1029 This does not parse and extract the full git commit message
1030 like a p4 form. It just sees the Jobs: line as a marker
1031 to pass everything from then on directly into the p4 form,
1032 but outside the description section.
1033
1034 Return a tuple (stripped log message, jobs string)."""
1035
1036 m = re.search(r'^Jobs:', message, re.MULTILINE)
1037 if m is None:
1038 return (message, None)
1039
1040 jobtext = message[m.start():]
1041 stripped_message = message[:m.start()].rstrip()
1042 return (stripped_message, jobtext)
1043
1044 def prepareLogMessage(self, template, message, jobs):
1045 """Edits the template returned from "p4 change -o" to insert
1046 the message in the Description field, and the jobs text in
1047 the Jobs field."""
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001048 result = ""
1049
Simon Hausmannedae1e22008-02-19 09:29:06 +01001050 inDescriptionSection = False
1051
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001052 for line in template.split("\n"):
1053 if line.startswith("#"):
1054 result += line + "\n"
1055 continue
1056
Simon Hausmannedae1e22008-02-19 09:29:06 +01001057 if inDescriptionSection:
Michael Horowitzc9dbab02011-02-25 21:31:13 -05001058 if line.startswith("Files:") or line.startswith("Jobs:"):
Simon Hausmannedae1e22008-02-19 09:29:06 +01001059 inDescriptionSection = False
Pete Wyckofff19cb0a2012-07-04 09:34:20 -04001060 # insert Jobs section
1061 if jobs:
1062 result += jobs + "\n"
Simon Hausmannedae1e22008-02-19 09:29:06 +01001063 else:
1064 continue
1065 else:
1066 if line.startswith("Description:"):
1067 inDescriptionSection = True
1068 line += "\n"
1069 for messageLine in message.split("\n"):
1070 line += "\t" + messageLine + "\n"
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001071
Simon Hausmannedae1e22008-02-19 09:29:06 +01001072 result += line + "\n"
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001073
1074 return result
1075
Luke Diamand60df0712012-02-23 07:51:30 +00001076 def patchRCSKeywords(self, file, pattern):
1077 # Attempt to zap the RCS keywords in a p4 controlled file matching the given pattern
1078 (handle, outFileName) = tempfile.mkstemp(dir='.')
1079 try:
1080 outFile = os.fdopen(handle, "w+")
1081 inFile = open(file, "r")
1082 regexp = re.compile(pattern, re.VERBOSE)
1083 for line in inFile.readlines():
1084 line = regexp.sub(r'$\1$', line)
1085 outFile.write(line)
1086 inFile.close()
1087 outFile.close()
1088 # Forcibly overwrite the original file
1089 os.unlink(file)
1090 shutil.move(outFileName, file)
1091 except:
1092 # cleanup our temporary file
1093 os.unlink(outFileName)
1094 print "Failed to strip RCS keywords in %s" % file
1095 raise
1096
1097 print "Patched up RCS keywords in %s" % file
1098
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001099 def p4UserForCommit(self,id):
1100 # Return the tuple (perforce user,git email) for a given git commit id
1101 self.getUserMapFromPerforceServer()
Pete Wyckoff9bf28852013-01-26 22:11:20 -05001102 gitEmail = read_pipe(["git", "log", "--max-count=1",
1103 "--format=%ae", id])
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001104 gitEmail = gitEmail.strip()
1105 if not self.emails.has_key(gitEmail):
1106 return (None,gitEmail)
1107 else:
1108 return (self.emails[gitEmail],gitEmail)
1109
1110 def checkValidP4Users(self,commits):
1111 # check if any git authors cannot be mapped to p4 users
1112 for id in commits:
1113 (user,email) = self.p4UserForCommit(id)
1114 if not user:
1115 msg = "Cannot find p4 user for email %s in commit %s." % (email, id)
Pete Wyckoff0d609032013-01-26 22:11:24 -05001116 if gitConfigBool("git-p4.allowMissingP4Users"):
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001117 print "%s" % msg
1118 else:
1119 die("Error: %s\nSet git-p4.allowMissingP4Users to true to allow this." % msg)
1120
1121 def lastP4Changelist(self):
1122 # Get back the last changelist number submitted in this client spec. This
1123 # then gets used to patch up the username in the change. If the same
1124 # client spec is being used by multiple processes then this might go
1125 # wrong.
1126 results = p4CmdList("client -o") # find the current client
1127 client = None
1128 for r in results:
1129 if r.has_key('Client'):
1130 client = r['Client']
1131 break
1132 if not client:
1133 die("could not get client spec")
Luke Diamand6de040d2011-10-16 10:47:52 -04001134 results = p4CmdList(["changes", "-c", client, "-m", "1"])
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001135 for r in results:
1136 if r.has_key('change'):
1137 return r['change']
1138 die("Could not get changelist number for last submit - cannot patch up user details")
1139
1140 def modifyChangelistUser(self, changelist, newUser):
1141 # fixup the user field of a changelist after it has been submitted.
1142 changes = p4CmdList("change -o %s" % changelist)
Luke Diamandecdba362011-05-07 11:19:43 +01001143 if len(changes) != 1:
1144 die("Bad output from p4 change modifying %s to user %s" %
1145 (changelist, newUser))
1146
1147 c = changes[0]
1148 if c['User'] == newUser: return # nothing to do
1149 c['User'] = newUser
1150 input = marshal.dumps(c)
1151
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001152 result = p4CmdList("change -f -i", stdin=input)
1153 for r in result:
1154 if r.has_key('code'):
1155 if r['code'] == 'error':
1156 die("Could not modify user field of changelist %s to %s:%s" % (changelist, newUser, r['data']))
1157 if r.has_key('data'):
1158 print("Updated user field for changelist %s to %s" % (changelist, newUser))
1159 return
1160 die("Could not modify user field of changelist %s to %s" % (changelist, newUser))
1161
1162 def canChangeChangelists(self):
1163 # check to see if we have p4 admin or super-user permissions, either of
1164 # which are required to modify changelists.
Luke Diamand52a48802012-01-19 09:52:25 +00001165 results = p4CmdList(["protects", self.depotPath])
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001166 for r in results:
1167 if r.has_key('perm'):
1168 if r['perm'] == 'admin':
1169 return 1
1170 if r['perm'] == 'super':
1171 return 1
1172 return 0
1173
Simon Hausmannea99c3a2007-08-08 17:06:55 +02001174 def prepareSubmitTemplate(self):
Pete Wyckofff19cb0a2012-07-04 09:34:20 -04001175 """Run "p4 change -o" to grab a change specification template.
1176 This does not use "p4 -G", as it is nice to keep the submission
1177 template in original order, since a human might edit it.
1178
1179 Remove lines in the Files section that show changes to files
1180 outside the depot path we're committing into."""
1181
Simon Hausmannea99c3a2007-08-08 17:06:55 +02001182 template = ""
1183 inFilesSection = False
Luke Diamand6de040d2011-10-16 10:47:52 -04001184 for line in p4_read_pipe_lines(['change', '-o']):
Marius Storm-Olsenf3e5ae42008-03-28 15:40:40 +01001185 if line.endswith("\r\n"):
1186 line = line[:-2] + "\n"
Simon Hausmannea99c3a2007-08-08 17:06:55 +02001187 if inFilesSection:
1188 if line.startswith("\t"):
1189 # path starts and ends with a tab
1190 path = line[1:]
1191 lastTab = path.rfind("\t")
1192 if lastTab != -1:
1193 path = path[:lastTab]
Tor Arvid Lundd53de8b2011-03-15 13:08:02 +01001194 if not p4PathStartsWith(path, self.depotPath):
Simon Hausmannea99c3a2007-08-08 17:06:55 +02001195 continue
1196 else:
1197 inFilesSection = False
1198 else:
1199 if line.startswith("Files:"):
1200 inFilesSection = True
1201
1202 template += line
1203
1204 return template
1205
Pete Wyckoff7c766e52011-12-04 19:22:45 -05001206 def edit_template(self, template_file):
1207 """Invoke the editor to let the user change the submission
1208 message. Return true if okay to continue with the submit."""
1209
1210 # if configured to skip the editing part, just submit
Pete Wyckoff0d609032013-01-26 22:11:24 -05001211 if gitConfigBool("git-p4.skipSubmitEdit"):
Pete Wyckoff7c766e52011-12-04 19:22:45 -05001212 return True
1213
1214 # look at the modification time, to check later if the user saved
1215 # the file
1216 mtime = os.stat(template_file).st_mtime
1217
1218 # invoke the editor
Luke Diamandf95ceaf2012-04-24 09:33:21 +01001219 if os.environ.has_key("P4EDITOR") and (os.environ.get("P4EDITOR") != ""):
Pete Wyckoff7c766e52011-12-04 19:22:45 -05001220 editor = os.environ.get("P4EDITOR")
1221 else:
1222 editor = read_pipe("git var GIT_EDITOR").strip()
Pete Wyckoff0cf1b722014-01-21 18:16:44 -05001223 system([editor, template_file])
Pete Wyckoff7c766e52011-12-04 19:22:45 -05001224
1225 # If the file was not saved, prompt to see if this patch should
1226 # be skipped. But skip this verification step if configured so.
Pete Wyckoff0d609032013-01-26 22:11:24 -05001227 if gitConfigBool("git-p4.skipSubmitEditCheck"):
Pete Wyckoff7c766e52011-12-04 19:22:45 -05001228 return True
1229
Pete Wyckoffd1652042011-12-17 12:39:03 -05001230 # modification time updated means user saved the file
1231 if os.stat(template_file).st_mtime > mtime:
1232 return True
1233
1234 while True:
1235 response = raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")
1236 if response == 'y':
1237 return True
1238 if response == 'n':
1239 return False
Pete Wyckoff7c766e52011-12-04 19:22:45 -05001240
Maxime Costee2a892e2014-06-11 14:09:59 +01001241 def get_diff_description(self, editedFiles, filesToAdd):
Maxime Costeb4073bb2014-05-24 18:40:35 +01001242 # diff
1243 if os.environ.has_key("P4DIFF"):
1244 del(os.environ["P4DIFF"])
1245 diff = ""
1246 for editedFile in editedFiles:
1247 diff += p4_read_pipe(['diff', '-du',
1248 wildcard_encode(editedFile)])
1249
1250 # new file diff
1251 newdiff = ""
1252 for newFile in filesToAdd:
1253 newdiff += "==== new file ====\n"
1254 newdiff += "--- /dev/null\n"
1255 newdiff += "+++ %s\n" % newFile
1256 f = open(newFile, "r")
1257 for line in f.readlines():
1258 newdiff += "+" + line
1259 f.close()
1260
Maxime Costee2a892e2014-06-11 14:09:59 +01001261 return (diff + newdiff).replace('\r\n', '\n')
Maxime Costeb4073bb2014-05-24 18:40:35 +01001262
Han-Wen Nienhuys7cb5cbe2007-05-23 16:55:48 -03001263 def applyCommit(self, id):
Pete Wyckoff67b0fe22012-09-09 16:16:03 -04001264 """Apply one commit, return True if it succeeded."""
1265
1266 print "Applying", read_pipe(["git", "show", "-s",
1267 "--format=format:%h %s", id])
Vitor Antunesae901092011-02-20 01:18:24 +00001268
Luke Diamand848de9c2011-05-13 20:46:00 +01001269 (p4User, gitEmail) = self.p4UserForCommit(id)
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001270
Gary Gibbons84cb0002012-07-04 09:40:19 -04001271 diff = read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (self.diffOpts, id, id))
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001272 filesToAdd = set()
1273 filesToDelete = set()
Simon Hausmannd336c152007-05-16 09:41:26 +02001274 editedFiles = set()
Pete Wyckoffb6ad6dc2012-04-29 20:57:16 -04001275 pureRenameCopy = set()
Chris Pettittc65b6702007-11-01 20:43:14 -07001276 filesToChangeExecBit = {}
Luke Diamand60df0712012-02-23 07:51:30 +00001277
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001278 for line in diff:
Chris Pettittb43b0a32007-11-01 20:43:13 -07001279 diff = parseDiffTreeEntry(line)
1280 modifier = diff['status']
1281 path = diff['src']
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001282 if modifier == "M":
Luke Diamand6de040d2011-10-16 10:47:52 -04001283 p4_edit(path)
Chris Pettittc65b6702007-11-01 20:43:14 -07001284 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
1285 filesToChangeExecBit[path] = diff['dst_mode']
Simon Hausmannd336c152007-05-16 09:41:26 +02001286 editedFiles.add(path)
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001287 elif modifier == "A":
1288 filesToAdd.add(path)
Chris Pettittc65b6702007-11-01 20:43:14 -07001289 filesToChangeExecBit[path] = diff['dst_mode']
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001290 if path in filesToDelete:
1291 filesToDelete.remove(path)
1292 elif modifier == "D":
1293 filesToDelete.add(path)
1294 if path in filesToAdd:
1295 filesToAdd.remove(path)
Vitor Antunes4fddb412011-02-20 01:18:25 +00001296 elif modifier == "C":
1297 src, dest = diff['src'], diff['dst']
Luke Diamand6de040d2011-10-16 10:47:52 -04001298 p4_integrate(src, dest)
Pete Wyckoffb6ad6dc2012-04-29 20:57:16 -04001299 pureRenameCopy.add(dest)
Vitor Antunes4fddb412011-02-20 01:18:25 +00001300 if diff['src_sha1'] != diff['dst_sha1']:
Luke Diamand6de040d2011-10-16 10:47:52 -04001301 p4_edit(dest)
Pete Wyckoffb6ad6dc2012-04-29 20:57:16 -04001302 pureRenameCopy.discard(dest)
Vitor Antunes4fddb412011-02-20 01:18:25 +00001303 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
Luke Diamand6de040d2011-10-16 10:47:52 -04001304 p4_edit(dest)
Pete Wyckoffb6ad6dc2012-04-29 20:57:16 -04001305 pureRenameCopy.discard(dest)
Vitor Antunes4fddb412011-02-20 01:18:25 +00001306 filesToChangeExecBit[dest] = diff['dst_mode']
Pete Wyckoffd20f0f82013-01-26 22:11:19 -05001307 if self.isWindows:
1308 # turn off read-only attribute
1309 os.chmod(dest, stat.S_IWRITE)
Vitor Antunes4fddb412011-02-20 01:18:25 +00001310 os.unlink(dest)
1311 editedFiles.add(dest)
Chris Pettittd9a5f252007-10-15 22:15:06 -07001312 elif modifier == "R":
Chris Pettittb43b0a32007-11-01 20:43:13 -07001313 src, dest = diff['src'], diff['dst']
Gary Gibbons8e9497c2012-07-12 19:29:00 -04001314 if self.p4HasMoveCommand:
1315 p4_edit(src) # src must be open before move
1316 p4_move(src, dest) # opens for (move/delete, move/add)
Pete Wyckoffb6ad6dc2012-04-29 20:57:16 -04001317 else:
Gary Gibbons8e9497c2012-07-12 19:29:00 -04001318 p4_integrate(src, dest)
1319 if diff['src_sha1'] != diff['dst_sha1']:
1320 p4_edit(dest)
1321 else:
1322 pureRenameCopy.add(dest)
Chris Pettittc65b6702007-11-01 20:43:14 -07001323 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
Gary Gibbons8e9497c2012-07-12 19:29:00 -04001324 if not self.p4HasMoveCommand:
1325 p4_edit(dest) # with move: already open, writable
Chris Pettittc65b6702007-11-01 20:43:14 -07001326 filesToChangeExecBit[dest] = diff['dst_mode']
Gary Gibbons8e9497c2012-07-12 19:29:00 -04001327 if not self.p4HasMoveCommand:
Pete Wyckoffd20f0f82013-01-26 22:11:19 -05001328 if self.isWindows:
1329 os.chmod(dest, stat.S_IWRITE)
Gary Gibbons8e9497c2012-07-12 19:29:00 -04001330 os.unlink(dest)
1331 filesToDelete.add(src)
Chris Pettittd9a5f252007-10-15 22:15:06 -07001332 editedFiles.add(dest)
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001333 else:
1334 die("unknown modifier %s for %s" % (modifier, path))
1335
Tolga Ceylan749b6682014-05-06 22:48:54 -07001336 diffcmd = "git diff-tree --full-index -p \"%s\"" % (id)
Simon Hausmann47a130b2007-05-20 16:33:21 +02001337 patchcmd = diffcmd + " | git apply "
Simon Hausmannc1b296b2007-05-20 16:55:05 +02001338 tryPatchCmd = patchcmd + "--check -"
1339 applyPatchCmd = patchcmd + "--check --apply -"
Luke Diamand60df0712012-02-23 07:51:30 +00001340 patch_succeeded = True
Simon Hausmann51a26402007-04-15 09:59:56 +02001341
Simon Hausmann47a130b2007-05-20 16:33:21 +02001342 if os.system(tryPatchCmd) != 0:
Luke Diamand60df0712012-02-23 07:51:30 +00001343 fixed_rcs_keywords = False
1344 patch_succeeded = False
Simon Hausmann51a26402007-04-15 09:59:56 +02001345 print "Unfortunately applying the change failed!"
Luke Diamand60df0712012-02-23 07:51:30 +00001346
1347 # Patch failed, maybe it's just RCS keyword woes. Look through
1348 # the patch to see if that's possible.
Pete Wyckoff0d609032013-01-26 22:11:24 -05001349 if gitConfigBool("git-p4.attemptRCSCleanup"):
Luke Diamand60df0712012-02-23 07:51:30 +00001350 file = None
1351 pattern = None
1352 kwfiles = {}
1353 for file in editedFiles | filesToDelete:
1354 # did this file's delta contain RCS keywords?
1355 pattern = p4_keywords_regexp_for_file(file)
1356
1357 if pattern:
1358 # this file is a possibility...look for RCS keywords.
1359 regexp = re.compile(pattern, re.VERBOSE)
1360 for line in read_pipe_lines(["git", "diff", "%s^..%s" % (id, id), file]):
1361 if regexp.search(line):
1362 if verbose:
1363 print "got keyword match on %s in %s in %s" % (pattern, line, file)
1364 kwfiles[file] = pattern
1365 break
1366
1367 for file in kwfiles:
1368 if verbose:
1369 print "zapping %s with %s" % (line,pattern)
Pete Wyckoffd20f0f82013-01-26 22:11:19 -05001370 # File is being deleted, so not open in p4. Must
1371 # disable the read-only bit on windows.
1372 if self.isWindows and file not in editedFiles:
1373 os.chmod(file, stat.S_IWRITE)
Luke Diamand60df0712012-02-23 07:51:30 +00001374 self.patchRCSKeywords(file, kwfiles[file])
1375 fixed_rcs_keywords = True
1376
1377 if fixed_rcs_keywords:
1378 print "Retrying the patch with RCS keywords cleaned up"
1379 if os.system(tryPatchCmd) == 0:
1380 patch_succeeded = True
1381
1382 if not patch_succeeded:
Pete Wyckoff7e5dd9f2012-09-09 16:16:05 -04001383 for f in editedFiles:
1384 p4_revert(f)
Pete Wyckoff7e5dd9f2012-09-09 16:16:05 -04001385 return False
Simon Hausmann51a26402007-04-15 09:59:56 +02001386
Pete Wyckoff55ac2ed2012-09-09 16:16:08 -04001387 #
1388 # Apply the patch for real, and do add/delete/+x handling.
1389 #
Simon Hausmann47a130b2007-05-20 16:33:21 +02001390 system(applyPatchCmd)
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001391
1392 for f in filesToAdd:
Luke Diamand6de040d2011-10-16 10:47:52 -04001393 p4_add(f)
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001394 for f in filesToDelete:
Luke Diamand6de040d2011-10-16 10:47:52 -04001395 p4_revert(f)
1396 p4_delete(f)
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001397
Chris Pettittc65b6702007-11-01 20:43:14 -07001398 # Set/clear executable bits
1399 for f in filesToChangeExecBit.keys():
1400 mode = filesToChangeExecBit[f]
1401 setP4ExecBit(f, mode)
1402
Pete Wyckoff55ac2ed2012-09-09 16:16:08 -04001403 #
1404 # Build p4 change description, starting with the contents
1405 # of the git commit message.
1406 #
Simon Hausmann0e36f2d2008-02-19 09:33:08 +01001407 logMessage = extractLogMessageFromGitCommit(id)
Simon Hausmann0e36f2d2008-02-19 09:33:08 +01001408 logMessage = logMessage.strip()
Pete Wyckofff19cb0a2012-07-04 09:34:20 -04001409 (logMessage, jobs) = self.separate_jobs_from_description(logMessage)
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001410
Simon Hausmannea99c3a2007-08-08 17:06:55 +02001411 template = self.prepareSubmitTemplate()
Pete Wyckofff19cb0a2012-07-04 09:34:20 -04001412 submitTemplate = self.prepareLogMessage(template, logMessage, jobs)
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001413
1414 if self.preserveUser:
Pete Wyckoff55ac2ed2012-09-09 16:16:08 -04001415 submitTemplate += "\n######## Actual user %s, modified after commit\n" % p4User
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001416
Pete Wyckoff55ac2ed2012-09-09 16:16:08 -04001417 if self.checkAuthorship and not self.p4UserIsMe(p4User):
1418 submitTemplate += "######## git author %s does not match your p4 account.\n" % gitEmail
1419 submitTemplate += "######## Use option --preserve-user to modify authorship.\n"
1420 submitTemplate += "######## Variable git-p4.skipUserNameCheck hides this message.\n"
1421
1422 separatorLine = "######## everything below this line is just the diff #######\n"
Maxime Costeb4073bb2014-05-24 18:40:35 +01001423 if not self.prepare_p4_only:
1424 submitTemplate += separatorLine
Maxime Costee2a892e2014-06-11 14:09:59 +01001425 submitTemplate += self.get_diff_description(editedFiles, filesToAdd)
Pete Wyckoff55ac2ed2012-09-09 16:16:08 -04001426
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001427 (handle, fileName) = tempfile.mkstemp()
Maxime Costee2a892e2014-06-11 14:09:59 +01001428 tmpFile = os.fdopen(handle, "w+b")
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001429 if self.isWindows:
1430 submitTemplate = submitTemplate.replace("\n", "\r\n")
Maxime Costeb4073bb2014-05-24 18:40:35 +01001431 tmpFile.write(submitTemplate)
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001432 tmpFile.close()
1433
Pete Wyckoff728b7ad2012-09-09 16:16:12 -04001434 if self.prepare_p4_only:
1435 #
1436 # Leave the p4 tree prepared, and the submit template around
1437 # and let the user decide what to do next
1438 #
1439 print
1440 print "P4 workspace prepared for submission."
1441 print "To submit or revert, go to client workspace"
1442 print " " + self.clientPath
1443 print
1444 print "To submit, use \"p4 submit\" to write a new description,"
1445 print "or \"p4 submit -i %s\" to use the one prepared by" \
1446 " \"git p4\"." % fileName
1447 print "You can delete the file \"%s\" when finished." % fileName
1448
1449 if self.preserveUser and p4User and not self.p4UserIsMe(p4User):
1450 print "To preserve change ownership by user %s, you must\n" \
1451 "do \"p4 change -f <change>\" after submitting and\n" \
1452 "edit the User field."
1453 if pureRenameCopy:
1454 print "After submitting, renamed files must be re-synced."
1455 print "Invoke \"p4 sync -f\" on each of these files:"
1456 for f in pureRenameCopy:
1457 print " " + f
1458
1459 print
1460 print "To revert the changes, use \"p4 revert ...\", and delete"
1461 print "the submit template file \"%s\"" % fileName
1462 if filesToAdd:
1463 print "Since the commit adds new files, they must be deleted:"
1464 for f in filesToAdd:
1465 print " " + f
1466 print
1467 return True
1468
Pete Wyckoff55ac2ed2012-09-09 16:16:08 -04001469 #
1470 # Let the user edit the change description, then submit it.
1471 #
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001472 if self.edit_template(fileName):
1473 # read the edited message and submit
Pete Wyckoff5a41c162012-09-09 16:16:06 -04001474 ret = True
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001475 tmpFile = open(fileName, "rb")
1476 message = tmpFile.read()
1477 tmpFile.close()
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001478 if self.isWindows:
Maxime Costee2a892e2014-06-11 14:09:59 +01001479 message = message.replace("\r\n", "\n")
1480 submitTemplate = message[:message.index(separatorLine)]
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001481 p4_write_pipe(['submit', '-i'], submitTemplate)
Luke Diamandecdba362011-05-07 11:19:43 +01001482
1483 if self.preserveUser:
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001484 if p4User:
1485 # Get last changelist number. Cannot easily get it from
1486 # the submit command output as the output is
1487 # unmarshalled.
1488 changelist = self.lastP4Changelist()
1489 self.modifyChangelistUser(changelist, p4User)
Luke Diamandecdba362011-05-07 11:19:43 +01001490
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001491 # The rename/copy happened by applying a patch that created a
1492 # new file. This leaves it writable, which confuses p4.
1493 for f in pureRenameCopy:
1494 p4_sync(f, "-f")
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001495
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001496 else:
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001497 # skip this patch
Pete Wyckoff5a41c162012-09-09 16:16:06 -04001498 ret = False
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001499 print "Submission cancelled, undoing p4 changes."
1500 for f in editedFiles:
1501 p4_revert(f)
1502 for f in filesToAdd:
1503 p4_revert(f)
1504 os.remove(f)
Pete Wyckoffdf9c5452012-09-09 16:16:09 -04001505 for f in filesToDelete:
1506 p4_revert(f)
Pete Wyckoffc47178d2012-07-04 09:34:18 -04001507
1508 os.remove(fileName)
Pete Wyckoff5a41c162012-09-09 16:16:06 -04001509 return ret
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001510
Luke Diamand06804c72012-04-11 17:21:24 +02001511 # Export git tags as p4 labels. Create a p4 label and then tag
1512 # with that.
1513 def exportGitTags(self, gitTags):
Luke Diamandc8942a22012-04-11 17:21:24 +02001514 validLabelRegexp = gitConfig("git-p4.labelExportRegexp")
1515 if len(validLabelRegexp) == 0:
1516 validLabelRegexp = defaultLabelRegexp
1517 m = re.compile(validLabelRegexp)
Luke Diamand06804c72012-04-11 17:21:24 +02001518
1519 for name in gitTags:
1520
1521 if not m.match(name):
1522 if verbose:
Luke Diamand05a3cec2012-05-11 07:25:17 +01001523 print "tag %s does not match regexp %s" % (name, validLabelRegexp)
Luke Diamand06804c72012-04-11 17:21:24 +02001524 continue
1525
1526 # Get the p4 commit this corresponds to
Luke Diamandc8942a22012-04-11 17:21:24 +02001527 logMessage = extractLogMessageFromGitCommit(name)
1528 values = extractSettingsGitLog(logMessage)
Luke Diamand06804c72012-04-11 17:21:24 +02001529
Luke Diamandc8942a22012-04-11 17:21:24 +02001530 if not values.has_key('change'):
Luke Diamand06804c72012-04-11 17:21:24 +02001531 # a tag pointing to something not sent to p4; ignore
1532 if verbose:
1533 print "git tag %s does not give a p4 commit" % name
1534 continue
Luke Diamandc8942a22012-04-11 17:21:24 +02001535 else:
1536 changelist = values['change']
Luke Diamand06804c72012-04-11 17:21:24 +02001537
1538 # Get the tag details.
1539 inHeader = True
1540 isAnnotated = False
1541 body = []
1542 for l in read_pipe_lines(["git", "cat-file", "-p", name]):
1543 l = l.strip()
1544 if inHeader:
1545 if re.match(r'tag\s+', l):
1546 isAnnotated = True
1547 elif re.match(r'\s*$', l):
1548 inHeader = False
1549 continue
1550 else:
1551 body.append(l)
1552
1553 if not isAnnotated:
1554 body = ["lightweight tag imported by git p4\n"]
1555
1556 # Create the label - use the same view as the client spec we are using
1557 clientSpec = getClientSpec()
1558
1559 labelTemplate = "Label: %s\n" % name
1560 labelTemplate += "Description:\n"
1561 for b in body:
1562 labelTemplate += "\t" + b + "\n"
1563 labelTemplate += "View:\n"
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09001564 for depot_side in clientSpec.mappings:
1565 labelTemplate += "\t%s\n" % depot_side
Luke Diamand06804c72012-04-11 17:21:24 +02001566
Pete Wyckoffef739f02012-09-09 16:16:11 -04001567 if self.dry_run:
1568 print "Would create p4 label %s for tag" % name
Pete Wyckoff728b7ad2012-09-09 16:16:12 -04001569 elif self.prepare_p4_only:
1570 print "Not creating p4 label %s for tag due to option" \
1571 " --prepare-p4-only" % name
Pete Wyckoffef739f02012-09-09 16:16:11 -04001572 else:
1573 p4_write_pipe(["label", "-i"], labelTemplate)
Luke Diamand06804c72012-04-11 17:21:24 +02001574
Pete Wyckoffef739f02012-09-09 16:16:11 -04001575 # Use the label
1576 p4_system(["tag", "-l", name] +
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09001577 ["%s@%s" % (depot_side, changelist) for depot_side in clientSpec.mappings])
Luke Diamand06804c72012-04-11 17:21:24 +02001578
Pete Wyckoffef739f02012-09-09 16:16:11 -04001579 if verbose:
1580 print "created p4 label for tag %s" % name
Luke Diamand06804c72012-04-11 17:21:24 +02001581
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001582 def run(self, args):
Simon Hausmannc9b50e62007-03-29 19:15:24 +02001583 if len(args) == 0:
1584 self.master = currentGitBranch()
Simon Hausmann4280e532007-05-25 08:49:18 +02001585 if len(self.master) == 0 or not gitBranchExists("refs/heads/%s" % self.master):
Simon Hausmannc9b50e62007-03-29 19:15:24 +02001586 die("Detecting current git branch failed!")
1587 elif len(args) == 1:
1588 self.master = args[0]
Pete Wyckoff28755db2011-12-24 21:07:40 -05001589 if not branchExists(self.master):
1590 die("Branch %s does not exist" % self.master)
Simon Hausmannc9b50e62007-03-29 19:15:24 +02001591 else:
1592 return False
1593
Jing Xue4c2d5d72008-06-22 14:12:39 -04001594 allowSubmit = gitConfig("git-p4.allowSubmit")
1595 if len(allowSubmit) > 0 and not self.master in allowSubmit.split(","):
1596 die("%s is not in git-p4.allowSubmit" % self.master)
1597
Simon Hausmann27d2d812007-06-12 14:31:59 +02001598 [upstream, settings] = findUpstreamBranchPoint()
Simon Hausmannea99c3a2007-08-08 17:06:55 +02001599 self.depotPath = settings['depot-paths'][0]
Simon Hausmann27d2d812007-06-12 14:31:59 +02001600 if len(self.origin) == 0:
1601 self.origin = upstream
Simon Hausmanna3fdd572007-06-07 22:54:32 +02001602
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001603 if self.preserveUser:
1604 if not self.canChangeChangelists():
1605 die("Cannot preserve user names without p4 super-user or admin permissions")
1606
Pete Wyckoff6bbfd132012-09-09 16:16:13 -04001607 # if not set from the command line, try the config file
1608 if self.conflict_behavior is None:
1609 val = gitConfig("git-p4.conflict")
1610 if val:
1611 if val not in self.conflict_behavior_choices:
1612 die("Invalid value '%s' for config git-p4.conflict" % val)
1613 else:
1614 val = "ask"
1615 self.conflict_behavior = val
1616
Simon Hausmanna3fdd572007-06-07 22:54:32 +02001617 if self.verbose:
1618 print "Origin branch is " + self.origin
Simon Hausmann95124972007-03-23 09:16:07 +01001619
Simon Hausmannea99c3a2007-08-08 17:06:55 +02001620 if len(self.depotPath) == 0:
Simon Hausmann95124972007-03-23 09:16:07 +01001621 print "Internal error: cannot locate perforce depot path from existing branches"
1622 sys.exit(128)
1623
Pete Wyckoff543987b2012-02-25 20:06:25 -05001624 self.useClientSpec = False
Pete Wyckoff0d609032013-01-26 22:11:24 -05001625 if gitConfigBool("git-p4.useclientspec"):
Pete Wyckoff543987b2012-02-25 20:06:25 -05001626 self.useClientSpec = True
1627 if self.useClientSpec:
1628 self.clientSpecDirs = getClientSpec()
Simon Hausmann95124972007-03-23 09:16:07 +01001629
Pete Wyckoff543987b2012-02-25 20:06:25 -05001630 if self.useClientSpec:
1631 # all files are relative to the client spec
1632 self.clientPath = getClientRoot()
1633 else:
1634 self.clientPath = p4Where(self.depotPath)
1635
1636 if self.clientPath == "":
1637 die("Error: Cannot locate perforce checkout of %s in client view" % self.depotPath)
Simon Hausmann95124972007-03-23 09:16:07 +01001638
Simon Hausmannea99c3a2007-08-08 17:06:55 +02001639 print "Perforce checkout for depot path %s located at %s" % (self.depotPath, self.clientPath)
Simon Hausmann7944f142007-05-21 11:04:26 +02001640 self.oldWorkingDirectory = os.getcwd()
Simon Hausmannc1b296b2007-05-20 16:55:05 +02001641
Gary Gibbons0591cfa2011-12-09 18:48:14 -05001642 # ensure the clientPath exists
Pete Wyckoff8d7ec362012-04-29 20:57:14 -04001643 new_client_dir = False
Gary Gibbons0591cfa2011-12-09 18:48:14 -05001644 if not os.path.exists(self.clientPath):
Pete Wyckoff8d7ec362012-04-29 20:57:14 -04001645 new_client_dir = True
Gary Gibbons0591cfa2011-12-09 18:48:14 -05001646 os.makedirs(self.clientPath)
1647
Miklós Fazekasbbd84862013-03-11 17:45:29 -04001648 chdir(self.clientPath, is_client_path=True)
Pete Wyckoffef739f02012-09-09 16:16:11 -04001649 if self.dry_run:
1650 print "Would synchronize p4 checkout in %s" % self.clientPath
Pete Wyckoff8d7ec362012-04-29 20:57:14 -04001651 else:
Pete Wyckoffef739f02012-09-09 16:16:11 -04001652 print "Synchronizing p4 checkout..."
1653 if new_client_dir:
1654 # old one was destroyed, and maybe nobody told p4
1655 p4_sync("...", "-f")
1656 else:
1657 p4_sync("...")
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001658 self.check()
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001659
Simon Hausmann4c750c02008-02-19 09:37:16 +01001660 commits = []
Pete Wyckoffc7d34882013-01-26 22:11:21 -05001661 for line in read_pipe_lines(["git", "rev-list", "--no-merges", "%s..%s" % (self.origin, self.master)]):
Simon Hausmann4c750c02008-02-19 09:37:16 +01001662 commits.append(line.strip())
1663 commits.reverse()
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001664
Pete Wyckoff0d609032013-01-26 22:11:24 -05001665 if self.preserveUser or gitConfigBool("git-p4.skipUserNameCheck"):
Luke Diamand848de9c2011-05-13 20:46:00 +01001666 self.checkAuthorship = False
1667 else:
1668 self.checkAuthorship = True
1669
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001670 if self.preserveUser:
1671 self.checkValidP4Users(commits)
1672
Gary Gibbons84cb0002012-07-04 09:40:19 -04001673 #
1674 # Build up a set of options to be passed to diff when
1675 # submitting each commit to p4.
1676 #
1677 if self.detectRenames:
1678 # command-line -M arg
1679 self.diffOpts = "-M"
1680 else:
1681 # If not explicitly set check the config variable
1682 detectRenames = gitConfig("git-p4.detectRenames")
1683
1684 if detectRenames.lower() == "false" or detectRenames == "":
1685 self.diffOpts = ""
1686 elif detectRenames.lower() == "true":
1687 self.diffOpts = "-M"
1688 else:
1689 self.diffOpts = "-M%s" % detectRenames
1690
1691 # no command-line arg for -C or --find-copies-harder, just
1692 # config variables
1693 detectCopies = gitConfig("git-p4.detectCopies")
1694 if detectCopies.lower() == "false" or detectCopies == "":
1695 pass
1696 elif detectCopies.lower() == "true":
1697 self.diffOpts += " -C"
1698 else:
1699 self.diffOpts += " -C%s" % detectCopies
1700
Pete Wyckoff0d609032013-01-26 22:11:24 -05001701 if gitConfigBool("git-p4.detectCopiesHarder"):
Gary Gibbons84cb0002012-07-04 09:40:19 -04001702 self.diffOpts += " --find-copies-harder"
1703
Pete Wyckoff7e5dd9f2012-09-09 16:16:05 -04001704 #
1705 # Apply the commits, one at a time. On failure, ask if should
1706 # continue to try the rest of the patches, or quit.
1707 #
Pete Wyckoffef739f02012-09-09 16:16:11 -04001708 if self.dry_run:
1709 print "Would apply"
Pete Wyckoff67b0fe22012-09-09 16:16:03 -04001710 applied = []
Pete Wyckoff7e5dd9f2012-09-09 16:16:05 -04001711 last = len(commits) - 1
1712 for i, commit in enumerate(commits):
Pete Wyckoffef739f02012-09-09 16:16:11 -04001713 if self.dry_run:
1714 print " ", read_pipe(["git", "show", "-s",
1715 "--format=format:%h %s", commit])
1716 ok = True
1717 else:
1718 ok = self.applyCommit(commit)
Pete Wyckoff67b0fe22012-09-09 16:16:03 -04001719 if ok:
1720 applied.append(commit)
Pete Wyckoff7e5dd9f2012-09-09 16:16:05 -04001721 else:
Pete Wyckoff728b7ad2012-09-09 16:16:12 -04001722 if self.prepare_p4_only and i < last:
1723 print "Processing only the first commit due to option" \
1724 " --prepare-p4-only"
1725 break
Pete Wyckoff7e5dd9f2012-09-09 16:16:05 -04001726 if i < last:
1727 quit = False
1728 while True:
Pete Wyckoff6bbfd132012-09-09 16:16:13 -04001729 # prompt for what to do, or use the option/variable
1730 if self.conflict_behavior == "ask":
1731 print "What do you want to do?"
1732 response = raw_input("[s]kip this commit but apply"
1733 " the rest, or [q]uit? ")
1734 if not response:
1735 continue
1736 elif self.conflict_behavior == "skip":
1737 response = "s"
1738 elif self.conflict_behavior == "quit":
1739 response = "q"
1740 else:
1741 die("Unknown conflict_behavior '%s'" %
1742 self.conflict_behavior)
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001743
Pete Wyckoff7e5dd9f2012-09-09 16:16:05 -04001744 if response[0] == "s":
1745 print "Skipping this commit, but applying the rest"
1746 break
1747 if response[0] == "q":
1748 print "Quitting"
1749 quit = True
1750 break
1751 if quit:
1752 break
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001753
Pete Wyckoff67b0fe22012-09-09 16:16:03 -04001754 chdir(self.oldWorkingDirectory)
1755
Pete Wyckoffef739f02012-09-09 16:16:11 -04001756 if self.dry_run:
1757 pass
Pete Wyckoff728b7ad2012-09-09 16:16:12 -04001758 elif self.prepare_p4_only:
1759 pass
Pete Wyckoffef739f02012-09-09 16:16:11 -04001760 elif len(commits) == len(applied):
Pete Wyckoff67b0fe22012-09-09 16:16:03 -04001761 print "All commits applied!"
Simon Hausmann14594f42007-08-22 09:07:15 +02001762
Simon Hausmann4c750c02008-02-19 09:37:16 +01001763 sync = P4Sync()
Pete Wyckoff44e8d262013-01-14 19:47:08 -05001764 if self.branch:
1765 sync.branch = self.branch
Simon Hausmann4c750c02008-02-19 09:37:16 +01001766 sync.run([])
Simon Hausmann14594f42007-08-22 09:07:15 +02001767
Simon Hausmann4c750c02008-02-19 09:37:16 +01001768 rebase = P4Rebase()
1769 rebase.rebase()
Simon Hausmann4f5cf762007-03-19 22:25:17 +01001770
Pete Wyckoff67b0fe22012-09-09 16:16:03 -04001771 else:
1772 if len(applied) == 0:
1773 print "No commits applied."
1774 else:
1775 print "Applied only the commits marked with '*':"
1776 for c in commits:
1777 if c in applied:
1778 star = "*"
1779 else:
1780 star = " "
1781 print star, read_pipe(["git", "show", "-s",
1782 "--format=format:%h %s", c])
1783 print "You will have to do 'git p4 sync' and rebase."
1784
Pete Wyckoff0d609032013-01-26 22:11:24 -05001785 if gitConfigBool("git-p4.exportLabels"):
Luke Diamand06dcd152012-05-11 07:25:18 +01001786 self.exportLabels = True
Luke Diamand06804c72012-04-11 17:21:24 +02001787
1788 if self.exportLabels:
1789 p4Labels = getP4Labels(self.depotPath)
1790 gitTags = getGitTags()
1791
1792 missingGitTags = gitTags - p4Labels
1793 self.exportGitTags(missingGitTags)
1794
Ondřej Bílka98e023d2013-07-29 10:18:21 +02001795 # exit with error unless everything applied perfectly
Pete Wyckoff67b0fe22012-09-09 16:16:03 -04001796 if len(commits) != len(applied):
1797 sys.exit(1)
1798
Simon Hausmannb9847332007-03-20 20:54:23 +01001799 return True
1800
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001801class View(object):
1802 """Represent a p4 view ("p4 help views"), and map files in a
1803 repo according to the view."""
1804
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09001805 def __init__(self, client_name):
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001806 self.mappings = []
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09001807 self.client_prefix = "//%s/" % client_name
1808 # cache results of "p4 where" to lookup client file locations
1809 self.client_spec_path_cache = {}
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001810
1811 def append(self, view_line):
1812 """Parse a view line, splitting it into depot and client
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09001813 sides. Append to self.mappings, preserving order. This
1814 is only needed for tag creation."""
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001815
1816 # Split the view line into exactly two words. P4 enforces
1817 # structure on these lines that simplifies this quite a bit.
1818 #
1819 # Either or both words may be double-quoted.
1820 # Single quotes do not matter.
1821 # Double-quote marks cannot occur inside the words.
1822 # A + or - prefix is also inside the quotes.
1823 # There are no quotes unless they contain a space.
1824 # The line is already white-space stripped.
1825 # The two words are separated by a single space.
1826 #
1827 if view_line[0] == '"':
1828 # First word is double quoted. Find its end.
1829 close_quote_index = view_line.find('"', 1)
1830 if close_quote_index <= 0:
1831 die("No first-word closing quote found: %s" % view_line)
1832 depot_side = view_line[1:close_quote_index]
1833 # skip closing quote and space
1834 rhs_index = close_quote_index + 1 + 1
1835 else:
1836 space_index = view_line.find(" ")
1837 if space_index <= 0:
1838 die("No word-splitting space found: %s" % view_line)
1839 depot_side = view_line[0:space_index]
1840 rhs_index = space_index + 1
1841
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001842 # prefix + means overlay on previous mapping
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001843 if depot_side.startswith("+"):
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001844 depot_side = depot_side[1:]
1845
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09001846 # prefix - means exclude this path, leave out of mappings
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001847 exclude = False
1848 if depot_side.startswith("-"):
1849 exclude = True
1850 depot_side = depot_side[1:]
1851
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09001852 if not exclude:
1853 self.mappings.append(depot_side)
1854
1855 def convert_client_path(self, clientFile):
1856 # chop off //client/ part to make it relative
1857 if not clientFile.startswith(self.client_prefix):
1858 die("No prefix '%s' on clientFile '%s'" %
1859 (self.client_prefix, clientFile))
1860 return clientFile[len(self.client_prefix):]
1861
1862 def update_client_spec_path_cache(self, files):
1863 """ Caching file paths by "p4 where" batch query """
1864
1865 # List depot file paths exclude that already cached
1866 fileArgs = [f['path'] for f in files if f['path'] not in self.client_spec_path_cache]
1867
1868 if len(fileArgs) == 0:
1869 return # All files in cache
1870
1871 where_result = p4CmdList(["-x", "-", "where"], stdin=fileArgs)
1872 for res in where_result:
1873 if "code" in res and res["code"] == "error":
1874 # assume error is "... file(s) not in client view"
1875 continue
1876 if "clientFile" not in res:
Pete Wyckoff20005442014-01-21 18:16:46 -05001877 die("No clientFile in 'p4 where' output")
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09001878 if "unmap" in res:
1879 # it will list all of them, but only one not unmap-ped
1880 continue
1881 self.client_spec_path_cache[res['depotFile']] = self.convert_client_path(res["clientFile"])
1882
1883 # not found files or unmap files set to ""
1884 for depotFile in fileArgs:
1885 if depotFile not in self.client_spec_path_cache:
1886 self.client_spec_path_cache[depotFile] = ""
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001887
1888 def map_in_client(self, depot_path):
1889 """Return the relative location in the client where this
1890 depot file should live. Returns "" if the file should
1891 not be mapped in the client."""
1892
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09001893 if depot_path in self.client_spec_path_cache:
1894 return self.client_spec_path_cache[depot_path]
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001895
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09001896 die( "Error: %s is not found in client spec path" % depot_path )
1897 return ""
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001898
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001899class P4Sync(Command, P4UserMap):
Pete Wyckoff56c09342011-02-19 08:17:57 -05001900 delete_actions = ( "delete", "move/delete", "purge" )
1901
Simon Hausmannb9847332007-03-20 20:54:23 +01001902 def __init__(self):
1903 Command.__init__(self)
Luke Diamand3ea2cfd2011-04-21 20:50:23 +01001904 P4UserMap.__init__(self)
Simon Hausmannb9847332007-03-20 20:54:23 +01001905 self.options = [
1906 optparse.make_option("--branch", dest="branch"),
1907 optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"),
1908 optparse.make_option("--changesfile", dest="changesFile"),
1909 optparse.make_option("--silent", dest="silent", action="store_true"),
Simon Hausmannef48f902007-05-17 22:17:49 +02001910 optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),
Luke Diamand06804c72012-04-11 17:21:24 +02001911 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),
Han-Wen Nienhuysd2c6dd32007-05-23 18:49:35 -03001912 optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",
1913 help="Import into refs/heads/ , not refs/remotes"),
Han-Wen Nienhuys8b41a972007-05-23 18:20:53 -03001914 optparse.make_option("--max-changes", dest="maxChanges"),
Han-Wen Nienhuys86dff6b2007-05-23 18:49:35 -03001915 optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',
Tor Arvid Lund3a70cdf2008-02-18 15:22:08 +01001916 help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),
1917 optparse.make_option("--use-client-spec", dest="useClientSpec", action='store_true',
1918 help="Only sync files that are included in the Perforce Client Spec")
Simon Hausmannb9847332007-03-20 20:54:23 +01001919 ]
1920 self.description = """Imports from Perforce into a git repository.\n
1921 example:
1922 //depot/my/project/ -- to import the current head
1923 //depot/my/project/@all -- to import everything
1924 //depot/my/project/@1,6 -- to import only from revision 1 to 6
1925
1926 (a ... is not needed in the path p4 specification, it's added implicitly)"""
1927
1928 self.usage += " //depot/path[@revRange]"
Simon Hausmannb9847332007-03-20 20:54:23 +01001929 self.silent = False
Reilly Grant1d7367d2009-09-10 00:02:38 -07001930 self.createdBranches = set()
1931 self.committedChanges = set()
Simon Hausmann569d1bd2007-03-22 21:34:16 +01001932 self.branch = ""
Simon Hausmannb9847332007-03-20 20:54:23 +01001933 self.detectBranches = False
Simon Hausmanncb53e1f2007-04-08 00:12:02 +02001934 self.detectLabels = False
Luke Diamand06804c72012-04-11 17:21:24 +02001935 self.importLabels = False
Simon Hausmannb9847332007-03-20 20:54:23 +01001936 self.changesFile = ""
Simon Hausmann01265102007-05-25 10:36:10 +02001937 self.syncWithOrigin = True
Simon Hausmanna028a982007-05-23 00:03:08 +02001938 self.importIntoRemotes = True
Simon Hausmann01a9c9c2007-05-23 00:07:35 +02001939 self.maxChanges = ""
Han-Wen Nienhuys8b41a972007-05-23 18:20:53 -03001940 self.keepRepoPath = False
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03001941 self.depotPaths = None
Simon Hausmann3c699642007-06-16 13:09:21 +02001942 self.p4BranchesInGit = []
Tommy Thorn354081d2008-02-03 10:38:51 -08001943 self.cloneExclude = []
Tor Arvid Lund3a70cdf2008-02-18 15:22:08 +01001944 self.useClientSpec = False
Pete Wyckoffa93d33e2012-02-25 20:06:24 -05001945 self.useClientSpec_from_options = False
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05001946 self.clientSpecDirs = None
Vitor Antunesfed23692012-01-25 23:48:22 +00001947 self.tempBranches = []
1948 self.tempBranchLocation = "git-p4-tmp"
Simon Hausmannb9847332007-03-20 20:54:23 +01001949
Simon Hausmann01265102007-05-25 10:36:10 +02001950 if gitConfig("git-p4.syncFromOrigin") == "false":
1951 self.syncWithOrigin = False
1952
Vitor Antunesfed23692012-01-25 23:48:22 +00001953 # Force a checkpoint in fast-import and wait for it to finish
1954 def checkpoint(self):
1955 self.gitStream.write("checkpoint\n\n")
1956 self.gitStream.write("progress checkpoint\n\n")
1957 out = self.gitOutput.readline()
1958 if self.verbose:
1959 print "checkpoint finished: " + out
1960
Simon Hausmannb9847332007-03-20 20:54:23 +01001961 def extractFilesFromCommit(self, commit):
Tommy Thorn354081d2008-02-03 10:38:51 -08001962 self.cloneExclude = [re.sub(r"\.\.\.$", "", path)
1963 for path in self.cloneExclude]
Simon Hausmannb9847332007-03-20 20:54:23 +01001964 files = []
1965 fnum = 0
1966 while commit.has_key("depotFile%s" % fnum):
1967 path = commit["depotFile%s" % fnum]
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03001968
Tommy Thorn354081d2008-02-03 10:38:51 -08001969 if [p for p in self.cloneExclude
Tor Arvid Lundd53de8b2011-03-15 13:08:02 +01001970 if p4PathStartsWith(path, p)]:
Tommy Thorn354081d2008-02-03 10:38:51 -08001971 found = False
1972 else:
1973 found = [p for p in self.depotPaths
Tor Arvid Lundd53de8b2011-03-15 13:08:02 +01001974 if p4PathStartsWith(path, p)]
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03001975 if not found:
Simon Hausmannb9847332007-03-20 20:54:23 +01001976 fnum = fnum + 1
1977 continue
1978
1979 file = {}
1980 file["path"] = path
1981 file["rev"] = commit["rev%s" % fnum]
1982 file["action"] = commit["action%s" % fnum]
1983 file["type"] = commit["type%s" % fnum]
1984 files.append(file)
1985 fnum = fnum + 1
1986 return files
1987
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03001988 def stripRepoPath(self, path, prefixes):
Pete Wyckoff21ef5df2012-08-11 12:55:04 -04001989 """When streaming files, this is called to map a p4 depot path
1990 to where it should go in git. The prefixes are either
1991 self.depotPaths, or self.branchPrefixes in the case of
1992 branch detection."""
1993
Ian Wienand39527102011-02-11 16:33:48 -08001994 if self.useClientSpec:
Pete Wyckoff21ef5df2012-08-11 12:55:04 -04001995 # branch detection moves files up a level (the branch name)
1996 # from what client spec interpretation gives
Pete Wyckoff0d1696e2012-08-11 12:55:03 -04001997 path = self.clientSpecDirs.map_in_client(path)
Pete Wyckoff21ef5df2012-08-11 12:55:04 -04001998 if self.detectBranches:
1999 for b in self.knownBranches:
2000 if path.startswith(b + "/"):
2001 path = path[len(b)+1:]
2002
2003 elif self.keepRepoPath:
2004 # Preserve everything in relative path name except leading
2005 # //depot/; just look at first prefix as they all should
2006 # be in the same depot.
2007 depot = re.sub("^(//[^/]+/).*", r'\1', prefixes[0])
2008 if p4PathStartsWith(path, depot):
2009 path = path[len(depot):]
Ian Wienand39527102011-02-11 16:33:48 -08002010
Pete Wyckoff0d1696e2012-08-11 12:55:03 -04002011 else:
Pete Wyckoff0d1696e2012-08-11 12:55:03 -04002012 for p in prefixes:
2013 if p4PathStartsWith(path, p):
2014 path = path[len(p):]
Pete Wyckoff21ef5df2012-08-11 12:55:04 -04002015 break
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002016
Pete Wyckoff0d1696e2012-08-11 12:55:03 -04002017 path = wildcard_decode(path)
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002018 return path
Han-Wen Nienhuys6754a292007-05-23 17:41:50 -03002019
Simon Hausmann71b112d2007-05-19 11:54:11 +02002020 def splitFilesIntoBranches(self, commit):
Pete Wyckoff21ef5df2012-08-11 12:55:04 -04002021 """Look at each depotFile in the commit to figure out to what
2022 branch it belongs."""
2023
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09002024 if self.clientSpecDirs:
2025 files = self.extractFilesFromCommit(commit)
2026 self.clientSpecDirs.update_client_spec_path_cache(files)
2027
Simon Hausmannd5904672007-05-19 11:07:32 +02002028 branches = {}
Simon Hausmann71b112d2007-05-19 11:54:11 +02002029 fnum = 0
2030 while commit.has_key("depotFile%s" % fnum):
2031 path = commit["depotFile%s" % fnum]
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002032 found = [p for p in self.depotPaths
Tor Arvid Lundd53de8b2011-03-15 13:08:02 +01002033 if p4PathStartsWith(path, p)]
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002034 if not found:
Simon Hausmann71b112d2007-05-19 11:54:11 +02002035 fnum = fnum + 1
2036 continue
2037
2038 file = {}
2039 file["path"] = path
2040 file["rev"] = commit["rev%s" % fnum]
2041 file["action"] = commit["action%s" % fnum]
2042 file["type"] = commit["type%s" % fnum]
2043 fnum = fnum + 1
2044
Pete Wyckoff21ef5df2012-08-11 12:55:04 -04002045 # start with the full relative path where this file would
2046 # go in a p4 client
2047 if self.useClientSpec:
2048 relPath = self.clientSpecDirs.map_in_client(path)
2049 else:
2050 relPath = self.stripRepoPath(path, self.depotPaths)
Simon Hausmannb9847332007-03-20 20:54:23 +01002051
Simon Hausmann4b97ffb2007-05-18 21:45:23 +02002052 for branch in self.knownBranches.keys():
Pete Wyckoff21ef5df2012-08-11 12:55:04 -04002053 # add a trailing slash so that a commit into qt/4.2foo
2054 # doesn't end up in qt/4.2, e.g.
Han-Wen Nienhuys6754a292007-05-23 17:41:50 -03002055 if relPath.startswith(branch + "/"):
Simon Hausmannd5904672007-05-19 11:07:32 +02002056 if branch not in branches:
2057 branches[branch] = []
Simon Hausmann71b112d2007-05-19 11:54:11 +02002058 branches[branch].append(file)
Simon Hausmann6555b2c2007-06-17 11:25:34 +02002059 break
Simon Hausmannb9847332007-03-20 20:54:23 +01002060
2061 return branches
2062
Luke Diamandb9327052009-07-30 00:13:46 +01002063 # output one file from the P4 stream
2064 # - helper for streamP4Files
2065
2066 def streamOneP4File(self, file, contents):
Luke Diamandb9327052009-07-30 00:13:46 +01002067 relPath = self.stripRepoPath(file['depotFile'], self.branchPrefixes)
2068 if verbose:
2069 sys.stderr.write("%s\n" % relPath)
2070
Pete Wyckoff9cffb8c2011-10-16 10:45:01 -04002071 (type_base, type_mods) = split_p4_type(file["type"])
2072
2073 git_mode = "100644"
2074 if "x" in type_mods:
2075 git_mode = "100755"
2076 if type_base == "symlink":
2077 git_mode = "120000"
Alexandru Juncu1292df12013-08-08 16:17:38 +03002078 # p4 print on a symlink sometimes contains "target\n";
2079 # if it does, remove the newline
Evan Powersb39c3612010-02-16 00:44:08 -08002080 data = ''.join(contents)
Pete Wyckoff40f846c2014-01-21 18:16:40 -05002081 if not data:
2082 # Some version of p4 allowed creating a symlink that pointed
2083 # to nothing. This causes p4 errors when checking out such
2084 # a change, and errors here too. Work around it by ignoring
2085 # the bad symlink; hopefully a future change fixes it.
2086 print "\nIgnoring empty symlink in %s" % file['depotFile']
2087 return
2088 elif data[-1] == '\n':
Alexandru Juncu1292df12013-08-08 16:17:38 +03002089 contents = [data[:-1]]
2090 else:
2091 contents = [data]
Luke Diamandb9327052009-07-30 00:13:46 +01002092
Pete Wyckoff9cffb8c2011-10-16 10:45:01 -04002093 if type_base == "utf16":
Pete Wyckoff55aa5712011-09-17 19:16:14 -04002094 # p4 delivers different text in the python output to -G
2095 # than it does when using "print -o", or normal p4 client
2096 # operations. utf16 is converted to ascii or utf8, perhaps.
2097 # But ascii text saved as -t utf16 is completely mangled.
2098 # Invoke print -o to get the real contents.
Pete Wyckoff7f0e5962013-01-26 22:11:13 -05002099 #
2100 # On windows, the newlines will always be mangled by print, so put
2101 # them back too. This is not needed to the cygwin windows version,
2102 # just the native "NT" type.
2103 #
Luke Diamand6de040d2011-10-16 10:47:52 -04002104 text = p4_read_pipe(['print', '-q', '-o', '-', file['depotFile']])
Pete Wyckoff7f0e5962013-01-26 22:11:13 -05002105 if p4_version_string().find("/NT") >= 0:
2106 text = text.replace("\r\n", "\n")
Pete Wyckoff55aa5712011-09-17 19:16:14 -04002107 contents = [ text ]
2108
Pete Wyckoff9f7ef0e2011-11-05 13:36:07 -04002109 if type_base == "apple":
2110 # Apple filetype files will be streamed as a concatenation of
2111 # its appledouble header and the contents. This is useless
2112 # on both macs and non-macs. If using "print -q -o xx", it
2113 # will create "xx" with the data, and "%xx" with the header.
2114 # This is also not very useful.
2115 #
2116 # Ideally, someday, this script can learn how to generate
2117 # appledouble files directly and import those to git, but
2118 # non-mac machines can never find a use for apple filetype.
2119 print "\nIgnoring apple filetype file %s" % file['depotFile']
2120 return
2121
Pete Wyckoff55aa5712011-09-17 19:16:14 -04002122 # Note that we do not try to de-mangle keywords on utf16 files,
2123 # even though in theory somebody may want that.
Luke Diamand60df0712012-02-23 07:51:30 +00002124 pattern = p4_keywords_regexp_for_type(type_base, type_mods)
2125 if pattern:
2126 regexp = re.compile(pattern, re.VERBOSE)
2127 text = ''.join(contents)
2128 text = regexp.sub(r'$\1$', text)
2129 contents = [ text ]
Luke Diamandb9327052009-07-30 00:13:46 +01002130
Pete Wyckoff9cffb8c2011-10-16 10:45:01 -04002131 self.gitStream.write("M %s inline %s\n" % (git_mode, relPath))
Luke Diamandb9327052009-07-30 00:13:46 +01002132
2133 # total length...
2134 length = 0
2135 for d in contents:
2136 length = length + len(d)
2137
2138 self.gitStream.write("data %d\n" % length)
2139 for d in contents:
2140 self.gitStream.write(d)
2141 self.gitStream.write("\n")
2142
2143 def streamOneP4Deletion(self, file):
2144 relPath = self.stripRepoPath(file['path'], self.branchPrefixes)
2145 if verbose:
2146 sys.stderr.write("delete %s\n" % relPath)
2147 self.gitStream.write("D %s\n" % relPath)
2148
2149 # handle another chunk of streaming data
2150 def streamP4FilesCb(self, marshalled):
2151
Pete Wyckoff78189be2012-11-23 17:35:36 -05002152 # catch p4 errors and complain
2153 err = None
2154 if "code" in marshalled:
2155 if marshalled["code"] == "error":
2156 if "data" in marshalled:
2157 err = marshalled["data"].rstrip()
2158 if err:
2159 f = None
2160 if self.stream_have_file_info:
2161 if "depotFile" in self.stream_file:
2162 f = self.stream_file["depotFile"]
2163 # force a failure in fast-import, else an empty
2164 # commit will be made
2165 self.gitStream.write("\n")
2166 self.gitStream.write("die-now\n")
2167 self.gitStream.close()
2168 # ignore errors, but make sure it exits first
2169 self.importProcess.wait()
2170 if f:
2171 die("Error from p4 print for %s: %s" % (f, err))
2172 else:
2173 die("Error from p4 print: %s" % err)
2174
Andrew Garberc3f61632011-04-07 02:01:21 -04002175 if marshalled.has_key('depotFile') and self.stream_have_file_info:
2176 # start of a new file - output the old one first
2177 self.streamOneP4File(self.stream_file, self.stream_contents)
2178 self.stream_file = {}
2179 self.stream_contents = []
2180 self.stream_have_file_info = False
Luke Diamandb9327052009-07-30 00:13:46 +01002181
Andrew Garberc3f61632011-04-07 02:01:21 -04002182 # pick up the new file information... for the
2183 # 'data' field we need to append to our array
2184 for k in marshalled.keys():
2185 if k == 'data':
2186 self.stream_contents.append(marshalled['data'])
2187 else:
2188 self.stream_file[k] = marshalled[k]
Luke Diamandb9327052009-07-30 00:13:46 +01002189
Andrew Garberc3f61632011-04-07 02:01:21 -04002190 self.stream_have_file_info = True
Luke Diamandb9327052009-07-30 00:13:46 +01002191
2192 # Stream directly from "p4 files" into "git fast-import"
2193 def streamP4Files(self, files):
Simon Hausmann30b59402008-03-03 11:55:48 +01002194 filesForCommit = []
2195 filesToRead = []
Luke Diamandb9327052009-07-30 00:13:46 +01002196 filesToDelete = []
Simon Hausmann30b59402008-03-03 11:55:48 +01002197
Tor Arvid Lund3a70cdf2008-02-18 15:22:08 +01002198 for f in files:
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05002199 # if using a client spec, only add the files that have
2200 # a path in the client
2201 if self.clientSpecDirs:
2202 if self.clientSpecDirs.map_in_client(f['path']) == "":
2203 continue
Tor Arvid Lund3a70cdf2008-02-18 15:22:08 +01002204
Pete Wyckoffecb7cf92012-01-02 18:05:53 -05002205 filesForCommit.append(f)
2206 if f['action'] in self.delete_actions:
2207 filesToDelete.append(f)
2208 else:
2209 filesToRead.append(f)
Han-Wen Nienhuys6a49f8e2007-05-23 18:49:35 -03002210
Luke Diamandb9327052009-07-30 00:13:46 +01002211 # deleted files...
2212 for f in filesToDelete:
2213 self.streamOneP4Deletion(f)
2214
Simon Hausmann30b59402008-03-03 11:55:48 +01002215 if len(filesToRead) > 0:
Luke Diamandb9327052009-07-30 00:13:46 +01002216 self.stream_file = {}
2217 self.stream_contents = []
2218 self.stream_have_file_info = False
2219
Andrew Garberc3f61632011-04-07 02:01:21 -04002220 # curry self argument
2221 def streamP4FilesCbSelf(entry):
2222 self.streamP4FilesCb(entry)
Luke Diamandb9327052009-07-30 00:13:46 +01002223
Luke Diamand6de040d2011-10-16 10:47:52 -04002224 fileArgs = ['%s#%s' % (f['path'], f['rev']) for f in filesToRead]
2225
2226 p4CmdList(["-x", "-", "print"],
2227 stdin=fileArgs,
2228 cb=streamP4FilesCbSelf)
Han-Wen Nienhuysf2eda792007-05-23 18:49:35 -03002229
Luke Diamandb9327052009-07-30 00:13:46 +01002230 # do the last chunk
2231 if self.stream_file.has_key('depotFile'):
2232 self.streamOneP4File(self.stream_file, self.stream_contents)
Han-Wen Nienhuys6a49f8e2007-05-23 18:49:35 -03002233
Luke Diamandaffb4742012-01-19 09:52:27 +00002234 def make_email(self, userid):
2235 if userid in self.users:
2236 return self.users[userid]
2237 else:
2238 return "%s <a@b>" % userid
2239
Luke Diamand06804c72012-04-11 17:21:24 +02002240 # Stream a p4 tag
2241 def streamTag(self, gitStream, labelName, labelDetails, commit, epoch):
2242 if verbose:
2243 print "writing tag %s for commit %s" % (labelName, commit)
2244 gitStream.write("tag %s\n" % labelName)
2245 gitStream.write("from %s\n" % commit)
2246
2247 if labelDetails.has_key('Owner'):
2248 owner = labelDetails["Owner"]
2249 else:
2250 owner = None
2251
2252 # Try to use the owner of the p4 label, or failing that,
2253 # the current p4 user id.
2254 if owner:
2255 email = self.make_email(owner)
2256 else:
2257 email = self.make_email(self.p4UserId())
2258 tagger = "%s %s %s" % (email, epoch, self.tz)
2259
2260 gitStream.write("tagger %s\n" % tagger)
2261
2262 print "labelDetails=",labelDetails
2263 if labelDetails.has_key('Description'):
2264 description = labelDetails['Description']
2265 else:
2266 description = 'Label from git p4'
2267
2268 gitStream.write("data %d\n" % len(description))
2269 gitStream.write(description)
2270 gitStream.write("\n")
2271
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002272 def commit(self, details, files, branch, parent = ""):
Simon Hausmannb9847332007-03-20 20:54:23 +01002273 epoch = details["time"]
2274 author = details["user"]
2275
Simon Hausmann4b97ffb2007-05-18 21:45:23 +02002276 if self.verbose:
2277 print "commit into %s" % branch
2278
Han-Wen Nienhuys96e07dd2007-05-23 18:49:35 -03002279 # start with reading files; if that fails, we should not
2280 # create a commit.
2281 new_files = []
2282 for f in files:
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002283 if [p for p in self.branchPrefixes if p4PathStartsWith(f['path'], p)]:
Han-Wen Nienhuys96e07dd2007-05-23 18:49:35 -03002284 new_files.append (f)
2285 else:
Tor Arvid Lundafa1dd92011-03-15 13:08:03 +01002286 sys.stderr.write("Ignoring file outside of prefix: %s\n" % f['path'])
Han-Wen Nienhuys96e07dd2007-05-23 18:49:35 -03002287
Kazuki Saitoh9d57c4a2013-08-30 19:02:06 +09002288 if self.clientSpecDirs:
2289 self.clientSpecDirs.update_client_spec_path_cache(files)
2290
Simon Hausmannb9847332007-03-20 20:54:23 +01002291 self.gitStream.write("commit %s\n" % branch)
Han-Wen Nienhuys6a49f8e2007-05-23 18:49:35 -03002292# gitStream.write("mark :%s\n" % details["change"])
Simon Hausmannb9847332007-03-20 20:54:23 +01002293 self.committedChanges.add(int(details["change"]))
2294 committer = ""
Simon Hausmannb607e712007-05-20 10:55:54 +02002295 if author not in self.users:
2296 self.getUserMapFromPerforceServer()
Luke Diamandaffb4742012-01-19 09:52:27 +00002297 committer = "%s %s %s" % (self.make_email(author), epoch, self.tz)
Simon Hausmannb9847332007-03-20 20:54:23 +01002298
2299 self.gitStream.write("committer %s\n" % committer)
2300
2301 self.gitStream.write("data <<EOT\n")
2302 self.gitStream.write(details["desc"])
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002303 self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s" %
2304 (','.join(self.branchPrefixes), details["change"]))
Simon Hausmann6581de02007-06-11 10:01:58 +02002305 if len(details['options']) > 0:
2306 self.gitStream.write(": options = %s" % details['options'])
2307 self.gitStream.write("]\nEOT\n\n")
Simon Hausmannb9847332007-03-20 20:54:23 +01002308
2309 if len(parent) > 0:
Simon Hausmann4b97ffb2007-05-18 21:45:23 +02002310 if self.verbose:
2311 print "parent %s" % parent
Simon Hausmannb9847332007-03-20 20:54:23 +01002312 self.gitStream.write("from %s\n" % parent)
2313
Luke Diamandb9327052009-07-30 00:13:46 +01002314 self.streamP4Files(new_files)
Simon Hausmannb9847332007-03-20 20:54:23 +01002315 self.gitStream.write("\n")
2316
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002317 change = int(details["change"])
2318
Simon Hausmann9bda3a82007-05-19 12:05:40 +02002319 if self.labels.has_key(change):
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002320 label = self.labels[change]
2321 labelDetails = label[0]
2322 labelRevisions = label[1]
Simon Hausmann71b112d2007-05-19 11:54:11 +02002323 if self.verbose:
2324 print "Change %s is labelled %s" % (change, labelDetails)
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002325
Luke Diamand6de040d2011-10-16 10:47:52 -04002326 files = p4CmdList(["files"] + ["%s...@%s" % (p, change)
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002327 for p in self.branchPrefixes])
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002328
2329 if len(files) == len(labelRevisions):
2330
2331 cleanedFiles = {}
2332 for info in files:
Pete Wyckoff56c09342011-02-19 08:17:57 -05002333 if info["action"] in self.delete_actions:
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002334 continue
2335 cleanedFiles[info["depotFile"]] = info["rev"]
2336
2337 if cleanedFiles == labelRevisions:
Luke Diamand06804c72012-04-11 17:21:24 +02002338 self.streamTag(self.gitStream, 'tag_%s' % labelDetails['label'], labelDetails, branch, epoch)
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002339
2340 else:
Simon Hausmanna46668f2007-03-28 17:05:38 +02002341 if not self.silent:
Han-Wen Nienhuyscebdf5a2007-05-23 16:53:11 -03002342 print ("Tag %s does not match with change %s: files do not match."
2343 % (labelDetails["label"], change))
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002344
2345 else:
Simon Hausmanna46668f2007-03-28 17:05:38 +02002346 if not self.silent:
Han-Wen Nienhuyscebdf5a2007-05-23 16:53:11 -03002347 print ("Tag %s does not match with change %s: file count is different."
2348 % (labelDetails["label"], change))
Simon Hausmannb9847332007-03-20 20:54:23 +01002349
Luke Diamand06804c72012-04-11 17:21:24 +02002350 # Build a dictionary of changelists and labels, for "detect-labels" option.
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002351 def getLabels(self):
2352 self.labels = {}
2353
Luke Diamand52a48802012-01-19 09:52:25 +00002354 l = p4CmdList(["labels"] + ["%s..." % p for p in self.depotPaths])
Simon Hausmann10c32112007-04-08 10:15:47 +02002355 if len(l) > 0 and not self.silent:
Shun Kei Leung183f8432007-11-21 11:01:19 +08002356 print "Finding files belonging to labels in %s" % `self.depotPaths`
Simon Hausmann01ce1fe2007-04-07 23:46:50 +02002357
2358 for output in l:
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002359 label = output["label"]
2360 revisions = {}
2361 newestChange = 0
Simon Hausmann71b112d2007-05-19 11:54:11 +02002362 if self.verbose:
2363 print "Querying files for label %s" % label
Luke Diamand6de040d2011-10-16 10:47:52 -04002364 for file in p4CmdList(["files"] +
2365 ["%s...@%s" % (p, label)
2366 for p in self.depotPaths]):
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002367 revisions[file["depotFile"]] = file["rev"]
2368 change = int(file["change"])
2369 if change > newestChange:
2370 newestChange = change
2371
Simon Hausmann9bda3a82007-05-19 12:05:40 +02002372 self.labels[newestChange] = [output, revisions]
2373
2374 if self.verbose:
2375 print "Label changes: %s" % self.labels.keys()
Simon Hausmann1f4ba1c2007-03-26 22:34:34 +02002376
Luke Diamand06804c72012-04-11 17:21:24 +02002377 # Import p4 labels as git tags. A direct mapping does not
2378 # exist, so assume that if all the files are at the same revision
2379 # then we can use that, or it's something more complicated we should
2380 # just ignore.
2381 def importP4Labels(self, stream, p4Labels):
2382 if verbose:
2383 print "import p4 labels: " + ' '.join(p4Labels)
2384
2385 ignoredP4Labels = gitConfigList("git-p4.ignoredP4Labels")
Luke Diamandc8942a22012-04-11 17:21:24 +02002386 validLabelRegexp = gitConfig("git-p4.labelImportRegexp")
Luke Diamand06804c72012-04-11 17:21:24 +02002387 if len(validLabelRegexp) == 0:
2388 validLabelRegexp = defaultLabelRegexp
2389 m = re.compile(validLabelRegexp)
2390
2391 for name in p4Labels:
2392 commitFound = False
2393
2394 if not m.match(name):
2395 if verbose:
2396 print "label %s does not match regexp %s" % (name,validLabelRegexp)
2397 continue
2398
2399 if name in ignoredP4Labels:
2400 continue
2401
2402 labelDetails = p4CmdList(['label', "-o", name])[0]
2403
2404 # get the most recent changelist for each file in this label
2405 change = p4Cmd(["changes", "-m", "1"] + ["%s...@%s" % (p, name)
2406 for p in self.depotPaths])
2407
2408 if change.has_key('change'):
2409 # find the corresponding git commit; take the oldest commit
2410 changelist = int(change['change'])
2411 gitCommit = read_pipe(["git", "rev-list", "--max-count=1",
2412 "--reverse", ":/\[git-p4:.*change = %d\]" % changelist])
2413 if len(gitCommit) == 0:
2414 print "could not find git commit for changelist %d" % changelist
2415 else:
2416 gitCommit = gitCommit.strip()
2417 commitFound = True
2418 # Convert from p4 time format
2419 try:
2420 tmwhen = time.strptime(labelDetails['Update'], "%Y/%m/%d %H:%M:%S")
2421 except ValueError:
Pete Wyckoffa4e90542012-11-23 17:35:38 -05002422 print "Could not convert label time %s" % labelDetails['Update']
Luke Diamand06804c72012-04-11 17:21:24 +02002423 tmwhen = 1
2424
2425 when = int(time.mktime(tmwhen))
2426 self.streamTag(stream, name, labelDetails, gitCommit, when)
2427 if verbose:
2428 print "p4 label %s mapped to git commit %s" % (name, gitCommit)
2429 else:
2430 if verbose:
2431 print "Label %s has no changelists - possibly deleted?" % name
2432
2433 if not commitFound:
2434 # We can't import this label; don't try again as it will get very
2435 # expensive repeatedly fetching all the files for labels that will
2436 # never be imported. If the label is moved in the future, the
2437 # ignore will need to be removed manually.
2438 system(["git", "config", "--add", "git-p4.ignoredP4Labels", name])
2439
Han-Wen Nienhuys86dff6b2007-05-23 18:49:35 -03002440 def guessProjectName(self):
2441 for p in self.depotPaths:
Simon Hausmann6e5295c2007-06-11 08:50:57 +02002442 if p.endswith("/"):
2443 p = p[:-1]
2444 p = p[p.strip().rfind("/") + 1:]
2445 if not p.endswith("/"):
2446 p += "/"
2447 return p
Han-Wen Nienhuys86dff6b2007-05-23 18:49:35 -03002448
Simon Hausmann4b97ffb2007-05-18 21:45:23 +02002449 def getBranchMapping(self):
Simon Hausmann6555b2c2007-06-17 11:25:34 +02002450 lostAndFoundBranches = set()
2451
Vitor Antunes8ace74c2011-08-19 00:44:04 +01002452 user = gitConfig("git-p4.branchUser")
2453 if len(user) > 0:
2454 command = "branches -u %s" % user
2455 else:
2456 command = "branches"
2457
2458 for info in p4CmdList(command):
Luke Diamand52a48802012-01-19 09:52:25 +00002459 details = p4Cmd(["branch", "-o", info["branch"]])
Simon Hausmann4b97ffb2007-05-18 21:45:23 +02002460 viewIdx = 0
2461 while details.has_key("View%s" % viewIdx):
2462 paths = details["View%s" % viewIdx].split(" ")
2463 viewIdx = viewIdx + 1
2464 # require standard //depot/foo/... //depot/bar/... mapping
2465 if len(paths) != 2 or not paths[0].endswith("/...") or not paths[1].endswith("/..."):
2466 continue
2467 source = paths[0]
2468 destination = paths[1]
Simon Hausmann6509e192007-06-07 09:41:53 +02002469 ## HACK
Tor Arvid Lundd53de8b2011-03-15 13:08:02 +01002470 if p4PathStartsWith(source, self.depotPaths[0]) and p4PathStartsWith(destination, self.depotPaths[0]):
Simon Hausmann6509e192007-06-07 09:41:53 +02002471 source = source[len(self.depotPaths[0]):-4]
2472 destination = destination[len(self.depotPaths[0]):-4]
Simon Hausmann6555b2c2007-06-17 11:25:34 +02002473
Simon Hausmann1a2edf42007-06-17 15:10:24 +02002474 if destination in self.knownBranches:
2475 if not self.silent:
2476 print "p4 branch %s defines a mapping from %s to %s" % (info["branch"], source, destination)
2477 print "but there exists another mapping from %s to %s already!" % (self.knownBranches[destination], destination)
2478 continue
2479
Simon Hausmann6555b2c2007-06-17 11:25:34 +02002480 self.knownBranches[destination] = source
2481
2482 lostAndFoundBranches.discard(destination)
2483
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002484 if source not in self.knownBranches:
Simon Hausmann6555b2c2007-06-17 11:25:34 +02002485 lostAndFoundBranches.add(source)
2486
Vitor Antunes7199cf12011-08-19 00:44:05 +01002487 # Perforce does not strictly require branches to be defined, so we also
2488 # check git config for a branch list.
2489 #
2490 # Example of branch definition in git config file:
2491 # [git-p4]
2492 # branchList=main:branchA
2493 # branchList=main:branchB
2494 # branchList=branchA:branchC
2495 configBranches = gitConfigList("git-p4.branchList")
2496 for branch in configBranches:
2497 if branch:
2498 (source, destination) = branch.split(":")
2499 self.knownBranches[destination] = source
2500
2501 lostAndFoundBranches.discard(destination)
2502
2503 if source not in self.knownBranches:
2504 lostAndFoundBranches.add(source)
2505
Simon Hausmann6555b2c2007-06-17 11:25:34 +02002506
2507 for branch in lostAndFoundBranches:
2508 self.knownBranches[branch] = branch
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002509
Simon Hausmann38f9f5e2007-11-15 10:38:45 +01002510 def getBranchMappingFromGitBranches(self):
2511 branches = p4BranchesInGit(self.importIntoRemotes)
2512 for branch in branches.keys():
2513 if branch == "master":
2514 branch = "main"
2515 else:
2516 branch = branch[len(self.projectName):]
2517 self.knownBranches[branch] = branch
2518
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03002519 def updateOptionDict(self, d):
2520 option_keys = {}
2521 if self.keepRepoPath:
2522 option_keys['keepRepoPath'] = 1
2523
2524 d["options"] = ' '.join(sorted(option_keys.keys()))
2525
2526 def readOptions(self, d):
2527 self.keepRepoPath = (d.has_key('options')
2528 and ('keepRepoPath' in d['options']))
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002529
Simon Hausmann8134f692007-08-26 16:44:55 +02002530 def gitRefForBranch(self, branch):
2531 if branch == "main":
2532 return self.refPrefix + "master"
2533
2534 if len(branch) <= 0:
2535 return branch
2536
2537 return self.refPrefix + self.projectName + branch
2538
Simon Hausmann1ca3d712007-08-26 17:36:55 +02002539 def gitCommitByP4Change(self, ref, change):
2540 if self.verbose:
2541 print "looking in ref " + ref + " for change %s using bisect..." % change
2542
2543 earliestCommit = ""
2544 latestCommit = parseRevision(ref)
2545
2546 while True:
2547 if self.verbose:
2548 print "trying: earliest %s latest %s" % (earliestCommit, latestCommit)
2549 next = read_pipe("git rev-list --bisect %s %s" % (latestCommit, earliestCommit)).strip()
2550 if len(next) == 0:
2551 if self.verbose:
2552 print "argh"
2553 return ""
2554 log = extractLogMessageFromGitCommit(next)
2555 settings = extractSettingsGitLog(log)
2556 currentChange = int(settings['change'])
2557 if self.verbose:
2558 print "current change %s" % currentChange
2559
2560 if currentChange == change:
2561 if self.verbose:
2562 print "found %s" % next
2563 return next
2564
2565 if currentChange < change:
2566 earliestCommit = "^%s" % next
2567 else:
2568 latestCommit = "%s" % next
2569
2570 return ""
2571
2572 def importNewBranch(self, branch, maxChange):
2573 # make fast-import flush all changes to disk and update the refs using the checkpoint
2574 # command so that we can try to find the branch parent in the git history
2575 self.gitStream.write("checkpoint\n\n");
2576 self.gitStream.flush();
2577 branchPrefix = self.depotPaths[0] + branch + "/"
2578 range = "@1,%s" % maxChange
2579 #print "prefix" + branchPrefix
2580 changes = p4ChangesForPaths([branchPrefix], range)
2581 if len(changes) <= 0:
2582 return False
2583 firstChange = changes[0]
2584 #print "first change in branch: %s" % firstChange
2585 sourceBranch = self.knownBranches[branch]
2586 sourceDepotPath = self.depotPaths[0] + sourceBranch
2587 sourceRef = self.gitRefForBranch(sourceBranch)
2588 #print "source " + sourceBranch
2589
Luke Diamand52a48802012-01-19 09:52:25 +00002590 branchParentChange = int(p4Cmd(["changes", "-m", "1", "%s...@1,%s" % (sourceDepotPath, firstChange)])["change"])
Simon Hausmann1ca3d712007-08-26 17:36:55 +02002591 #print "branch parent: %s" % branchParentChange
2592 gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)
2593 if len(gitParent) > 0:
2594 self.initialParents[self.gitRefForBranch(branch)] = gitParent
2595 #print "parent git commit: %s" % gitParent
2596
2597 self.importChanges(changes)
2598 return True
2599
Vitor Antunesfed23692012-01-25 23:48:22 +00002600 def searchParent(self, parent, branch, target):
2601 parentFound = False
Pete Wyckoffc7d34882013-01-26 22:11:21 -05002602 for blob in read_pipe_lines(["git", "rev-list", "--reverse",
2603 "--no-merges", parent]):
Vitor Antunesfed23692012-01-25 23:48:22 +00002604 blob = blob.strip()
2605 if len(read_pipe(["git", "diff-tree", blob, target])) == 0:
2606 parentFound = True
2607 if self.verbose:
2608 print "Found parent of %s in commit %s" % (branch, blob)
2609 break
2610 if parentFound:
2611 return blob
2612 else:
2613 return None
2614
Simon Hausmanne87f37a2007-08-26 16:00:52 +02002615 def importChanges(self, changes):
2616 cnt = 1
2617 for change in changes:
Pete Wyckoff18fa13d2012-11-23 17:35:34 -05002618 description = p4_describe(change)
Simon Hausmanne87f37a2007-08-26 16:00:52 +02002619 self.updateOptionDict(description)
2620
2621 if not self.silent:
2622 sys.stdout.write("\rImporting revision %s (%s%%)" % (change, cnt * 100 / len(changes)))
2623 sys.stdout.flush()
2624 cnt = cnt + 1
2625
2626 try:
2627 if self.detectBranches:
2628 branches = self.splitFilesIntoBranches(description)
2629 for branch in branches.keys():
2630 ## HACK --hwn
2631 branchPrefix = self.depotPaths[0] + branch + "/"
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002632 self.branchPrefixes = [ branchPrefix ]
Simon Hausmanne87f37a2007-08-26 16:00:52 +02002633
2634 parent = ""
2635
2636 filesForCommit = branches[branch]
2637
2638 if self.verbose:
2639 print "branch is %s" % branch
2640
2641 self.updatedBranches.add(branch)
2642
2643 if branch not in self.createdBranches:
2644 self.createdBranches.add(branch)
2645 parent = self.knownBranches[branch]
2646 if parent == branch:
2647 parent = ""
Simon Hausmann1ca3d712007-08-26 17:36:55 +02002648 else:
2649 fullBranch = self.projectName + branch
2650 if fullBranch not in self.p4BranchesInGit:
2651 if not self.silent:
2652 print("\n Importing new branch %s" % fullBranch);
2653 if self.importNewBranch(branch, change - 1):
2654 parent = ""
2655 self.p4BranchesInGit.append(fullBranch)
2656 if not self.silent:
2657 print("\n Resuming with change %s" % change);
2658
2659 if self.verbose:
2660 print "parent determined through known branches: %s" % parent
Simon Hausmanne87f37a2007-08-26 16:00:52 +02002661
Simon Hausmann8134f692007-08-26 16:44:55 +02002662 branch = self.gitRefForBranch(branch)
2663 parent = self.gitRefForBranch(parent)
Simon Hausmanne87f37a2007-08-26 16:00:52 +02002664
2665 if self.verbose:
2666 print "looking for initial parent for %s; current parent is %s" % (branch, parent)
2667
2668 if len(parent) == 0 and branch in self.initialParents:
2669 parent = self.initialParents[branch]
2670 del self.initialParents[branch]
2671
Vitor Antunesfed23692012-01-25 23:48:22 +00002672 blob = None
2673 if len(parent) > 0:
Pete Wyckoff4f9273d2013-01-26 22:11:04 -05002674 tempBranch = "%s/%d" % (self.tempBranchLocation, change)
Vitor Antunesfed23692012-01-25 23:48:22 +00002675 if self.verbose:
2676 print "Creating temporary branch: " + tempBranch
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002677 self.commit(description, filesForCommit, tempBranch)
Vitor Antunesfed23692012-01-25 23:48:22 +00002678 self.tempBranches.append(tempBranch)
2679 self.checkpoint()
2680 blob = self.searchParent(parent, branch, tempBranch)
2681 if blob:
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002682 self.commit(description, filesForCommit, branch, blob)
Vitor Antunesfed23692012-01-25 23:48:22 +00002683 else:
2684 if self.verbose:
2685 print "Parent of %s not found. Committing into head of %s" % (branch, parent)
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002686 self.commit(description, filesForCommit, branch, parent)
Simon Hausmanne87f37a2007-08-26 16:00:52 +02002687 else:
2688 files = self.extractFilesFromCommit(description)
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002689 self.commit(description, files, self.branch,
Simon Hausmanne87f37a2007-08-26 16:00:52 +02002690 self.initialParent)
Pete Wyckoff47497842013-01-14 19:47:04 -05002691 # only needed once, to connect to the previous commit
Simon Hausmanne87f37a2007-08-26 16:00:52 +02002692 self.initialParent = ""
2693 except IOError:
2694 print self.gitError.read()
2695 sys.exit(1)
2696
Simon Hausmannc208a242007-08-26 16:07:18 +02002697 def importHeadRevision(self, revision):
2698 print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), revision, self.branch)
2699
Pete Wyckoff4e2e6ce2011-07-31 09:45:55 -04002700 details = {}
2701 details["user"] = "git perforce import user"
Pete Wyckoff1494fcb2011-02-19 08:17:56 -05002702 details["desc"] = ("Initial import of %s from the state at revision %s\n"
Simon Hausmannc208a242007-08-26 16:07:18 +02002703 % (' '.join(self.depotPaths), revision))
2704 details["change"] = revision
2705 newestRevision = 0
2706
2707 fileCnt = 0
Luke Diamand6de040d2011-10-16 10:47:52 -04002708 fileArgs = ["%s...%s" % (p,revision) for p in self.depotPaths]
2709
2710 for info in p4CmdList(["files"] + fileArgs):
Simon Hausmannc208a242007-08-26 16:07:18 +02002711
Pete Wyckoff68b28592011-02-19 08:17:55 -05002712 if 'code' in info and info['code'] == 'error':
Simon Hausmannc208a242007-08-26 16:07:18 +02002713 sys.stderr.write("p4 returned an error: %s\n"
2714 % info['data'])
Pete Wyckoffd88e7072011-02-19 08:17:58 -05002715 if info['data'].find("must refer to client") >= 0:
2716 sys.stderr.write("This particular p4 error is misleading.\n")
2717 sys.stderr.write("Perhaps the depot path was misspelled.\n");
2718 sys.stderr.write("Depot path: %s\n" % " ".join(self.depotPaths))
Simon Hausmannc208a242007-08-26 16:07:18 +02002719 sys.exit(1)
Pete Wyckoff68b28592011-02-19 08:17:55 -05002720 if 'p4ExitCode' in info:
2721 sys.stderr.write("p4 exitcode: %s\n" % info['p4ExitCode'])
Simon Hausmannc208a242007-08-26 16:07:18 +02002722 sys.exit(1)
2723
2724
2725 change = int(info["change"])
2726 if change > newestRevision:
2727 newestRevision = change
2728
Pete Wyckoff56c09342011-02-19 08:17:57 -05002729 if info["action"] in self.delete_actions:
Simon Hausmannc208a242007-08-26 16:07:18 +02002730 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
2731 #fileCnt = fileCnt + 1
2732 continue
2733
2734 for prop in ["depotFile", "rev", "action", "type" ]:
2735 details["%s%s" % (prop, fileCnt)] = info[prop]
2736
2737 fileCnt = fileCnt + 1
2738
2739 details["change"] = newestRevision
Pete Wyckoff4e2e6ce2011-07-31 09:45:55 -04002740
Pete Wyckoff9dcb9f22012-04-08 20:18:01 -04002741 # Use time from top-most change so that all git p4 clones of
Pete Wyckoff4e2e6ce2011-07-31 09:45:55 -04002742 # the same p4 repo have the same commit SHA1s.
Pete Wyckoff18fa13d2012-11-23 17:35:34 -05002743 res = p4_describe(newestRevision)
2744 details["time"] = res["time"]
Pete Wyckoff4e2e6ce2011-07-31 09:45:55 -04002745
Simon Hausmannc208a242007-08-26 16:07:18 +02002746 self.updateOptionDict(details)
2747 try:
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002748 self.commit(details, self.extractFilesFromCommit(details), self.branch)
Simon Hausmannc208a242007-08-26 16:07:18 +02002749 except IOError:
2750 print "IO error with git fast-import. Is your git version recent enough?"
2751 print self.gitError.read()
2752
2753
Simon Hausmannb9847332007-03-20 20:54:23 +01002754 def run(self, args):
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002755 self.depotPaths = []
Simon Hausmann179caeb2007-03-22 22:17:42 +01002756 self.changeRange = ""
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002757 self.previousDepotPaths = []
Pete Wyckoff991a2de2013-01-14 19:46:56 -05002758 self.hasOrigin = False
Han-Wen Nienhuysce6f33c2007-05-23 16:46:29 -03002759
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002760 # map from branch depot path to parent branch
2761 self.knownBranches = {}
2762 self.initialParents = {}
Simon Hausmann179caeb2007-03-22 22:17:42 +01002763
Simon Hausmanna028a982007-05-23 00:03:08 +02002764 if self.importIntoRemotes:
2765 self.refPrefix = "refs/remotes/p4/"
2766 else:
Marius Storm-Olsendb775552007-06-07 15:13:59 +02002767 self.refPrefix = "refs/heads/p4/"
Simon Hausmanna028a982007-05-23 00:03:08 +02002768
Pete Wyckoff991a2de2013-01-14 19:46:56 -05002769 if self.syncWithOrigin:
2770 self.hasOrigin = originP4BranchesExist()
2771 if self.hasOrigin:
2772 if not self.silent:
2773 print 'Syncing with origin first, using "git fetch origin"'
2774 system("git fetch origin")
Simon Hausmann10f880f2007-05-24 22:28:28 +02002775
Pete Wyckoff5a8e84c2013-01-14 19:47:05 -05002776 branch_arg_given = bool(self.branch)
Simon Hausmann569d1bd2007-03-22 21:34:16 +01002777 if len(self.branch) == 0:
Marius Storm-Olsendb775552007-06-07 15:13:59 +02002778 self.branch = self.refPrefix + "master"
Simon Hausmanna028a982007-05-23 00:03:08 +02002779 if gitBranchExists("refs/heads/p4") and self.importIntoRemotes:
Simon Hausmann48df6fd2007-05-17 21:18:53 +02002780 system("git update-ref %s refs/heads/p4" % self.branch)
Pete Wyckoff55d12432013-01-14 19:46:59 -05002781 system("git branch -D p4")
Simon Hausmann179caeb2007-03-22 22:17:42 +01002782
Pete Wyckoffa93d33e2012-02-25 20:06:24 -05002783 # accept either the command-line option, or the configuration variable
2784 if self.useClientSpec:
2785 # will use this after clone to set the variable
2786 self.useClientSpec_from_options = True
2787 else:
Pete Wyckoff0d609032013-01-26 22:11:24 -05002788 if gitConfigBool("git-p4.useclientspec"):
Pete Wyckoff09fca772011-12-24 21:07:39 -05002789 self.useClientSpec = True
2790 if self.useClientSpec:
Pete Wyckoff543987b2012-02-25 20:06:25 -05002791 self.clientSpecDirs = getClientSpec()
Tor Arvid Lund3a70cdf2008-02-18 15:22:08 +01002792
Han-Wen Nienhuys6a49f8e2007-05-23 18:49:35 -03002793 # TODO: should always look at previous commits,
2794 # merge with previous imports, if possible.
2795 if args == []:
Simon Hausmannd414c742007-05-25 11:36:42 +02002796 if self.hasOrigin:
Simon Hausmann5ca44612007-08-24 17:44:16 +02002797 createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)
Pete Wyckoff3b650fc2013-01-14 19:46:58 -05002798
2799 # branches holds mapping from branch name to sha1
2800 branches = p4BranchesInGit(self.importIntoRemotes)
Pete Wyckoff8c9e8b62013-01-14 19:47:06 -05002801
2802 # restrict to just this one, disabling detect-branches
2803 if branch_arg_given:
2804 short = self.branch.split("/")[-1]
2805 if short in branches:
2806 self.p4BranchesInGit = [ short ]
2807 else:
2808 self.p4BranchesInGit = branches.keys()
Simon Hausmannabcd7902007-05-24 22:25:36 +02002809
2810 if len(self.p4BranchesInGit) > 1:
2811 if not self.silent:
2812 print "Importing from/into multiple branches"
2813 self.detectBranches = True
Pete Wyckoff8c9e8b62013-01-14 19:47:06 -05002814 for branch in branches.keys():
2815 self.initialParents[self.refPrefix + branch] = \
2816 branches[branch]
Simon Hausmann967f72e2007-03-23 09:30:41 +01002817
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002818 if self.verbose:
2819 print "branches: %s" % self.p4BranchesInGit
2820
2821 p4Change = 0
2822 for branch in self.p4BranchesInGit:
Han-Wen Nienhuyscebdf5a2007-05-23 16:53:11 -03002823 logMsg = extractLogMessageFromGitCommit(self.refPrefix + branch)
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03002824
2825 settings = extractSettingsGitLog(logMsg)
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002826
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03002827 self.readOptions(settings)
2828 if (settings.has_key('depot-paths')
2829 and settings.has_key ('change')):
2830 change = int(settings['change']) + 1
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002831 p4Change = max(p4Change, change)
2832
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03002833 depotPaths = sorted(settings['depot-paths'])
2834 if self.previousDepotPaths == []:
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002835 self.previousDepotPaths = depotPaths
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002836 else:
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002837 paths = []
2838 for (prev, cur) in zip(self.previousDepotPaths, depotPaths):
Vitor Antunes04d277b2011-08-19 00:44:03 +01002839 prev_list = prev.split("/")
2840 cur_list = cur.split("/")
2841 for i in range(0, min(len(cur_list), len(prev_list))):
2842 if cur_list[i] <> prev_list[i]:
Simon Hausmann583e1702007-06-07 09:37:13 +02002843 i = i - 1
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002844 break
2845
Vitor Antunes04d277b2011-08-19 00:44:03 +01002846 paths.append ("/".join(cur_list[:i + 1]))
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002847
2848 self.previousDepotPaths = paths
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002849
2850 if p4Change > 0:
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03002851 self.depotPaths = sorted(self.previousDepotPaths)
Simon Hausmannd5904672007-05-19 11:07:32 +02002852 self.changeRange = "@%s,#head" % p4Change
Simon Hausmann341dc1c2007-05-21 00:39:16 +02002853 if not self.silent and not self.detectBranches:
Simon Hausmann967f72e2007-03-23 09:30:41 +01002854 print "Performing incremental import into %s git branch" % self.branch
Simon Hausmann569d1bd2007-03-22 21:34:16 +01002855
Pete Wyckoff40d69ac2013-01-14 19:47:03 -05002856 # accept multiple ref name abbreviations:
2857 # refs/foo/bar/branch -> use it exactly
2858 # p4/branch -> prepend refs/remotes/ or refs/heads/
2859 # branch -> prepend refs/remotes/p4/ or refs/heads/p4/
Simon Hausmannf9162f62007-05-17 09:02:45 +02002860 if not self.branch.startswith("refs/"):
Pete Wyckoff40d69ac2013-01-14 19:47:03 -05002861 if self.importIntoRemotes:
2862 prepend = "refs/remotes/"
2863 else:
2864 prepend = "refs/heads/"
2865 if not self.branch.startswith("p4/"):
2866 prepend += "p4/"
2867 self.branch = prepend + self.branch
Simon Hausmann179caeb2007-03-22 22:17:42 +01002868
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002869 if len(args) == 0 and self.depotPaths:
Simon Hausmannb9847332007-03-20 20:54:23 +01002870 if not self.silent:
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002871 print "Depot paths: %s" % ' '.join(self.depotPaths)
Simon Hausmannb9847332007-03-20 20:54:23 +01002872 else:
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002873 if self.depotPaths and self.depotPaths != args:
Han-Wen Nienhuyscebdf5a2007-05-23 16:53:11 -03002874 print ("previous import used depot path %s and now %s was specified. "
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002875 "This doesn't work!" % (' '.join (self.depotPaths),
2876 ' '.join (args)))
Simon Hausmannb9847332007-03-20 20:54:23 +01002877 sys.exit(1)
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002878
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03002879 self.depotPaths = sorted(args)
Simon Hausmannb9847332007-03-20 20:54:23 +01002880
Simon Hausmann1c49fc12007-08-26 16:04:34 +02002881 revision = ""
Simon Hausmannb9847332007-03-20 20:54:23 +01002882 self.users = {}
Simon Hausmannb9847332007-03-20 20:54:23 +01002883
Pete Wyckoff58c8bc72011-12-24 21:07:35 -05002884 # Make sure no revision specifiers are used when --changesfile
2885 # is specified.
2886 bad_changesfile = False
2887 if len(self.changesFile) > 0:
2888 for p in self.depotPaths:
2889 if p.find("@") >= 0 or p.find("#") >= 0:
2890 bad_changesfile = True
2891 break
2892 if bad_changesfile:
2893 die("Option --changesfile is incompatible with revision specifiers")
2894
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002895 newPaths = []
2896 for p in self.depotPaths:
2897 if p.find("@") != -1:
2898 atIdx = p.index("@")
2899 self.changeRange = p[atIdx:]
2900 if self.changeRange == "@all":
2901 self.changeRange = ""
Han-Wen Nienhuys6a49f8e2007-05-23 18:49:35 -03002902 elif ',' not in self.changeRange:
Simon Hausmann1c49fc12007-08-26 16:04:34 +02002903 revision = self.changeRange
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002904 self.changeRange = ""
Han-Wen Nienhuys7fcff9d2007-07-23 15:56:37 -07002905 p = p[:atIdx]
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002906 elif p.find("#") != -1:
2907 hashIdx = p.index("#")
Simon Hausmann1c49fc12007-08-26 16:04:34 +02002908 revision = p[hashIdx:]
Han-Wen Nienhuys7fcff9d2007-07-23 15:56:37 -07002909 p = p[:hashIdx]
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002910 elif self.previousDepotPaths == []:
Pete Wyckoff58c8bc72011-12-24 21:07:35 -05002911 # pay attention to changesfile, if given, else import
2912 # the entire p4 tree at the head revision
2913 if len(self.changesFile) == 0:
2914 revision = "#head"
Simon Hausmannb9847332007-03-20 20:54:23 +01002915
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002916 p = re.sub ("\.\.\.$", "", p)
2917 if not p.endswith("/"):
2918 p += "/"
2919
2920 newPaths.append(p)
2921
2922 self.depotPaths = newPaths
2923
Pete Wyckoffe63231e2012-08-11 12:55:02 -04002924 # --detect-branches may change this for each branch
2925 self.branchPrefixes = self.depotPaths
2926
Simon Hausmannb607e712007-05-20 10:55:54 +02002927 self.loadUserMapFromCache()
Simon Hausmanncb53e1f2007-04-08 00:12:02 +02002928 self.labels = {}
2929 if self.detectLabels:
2930 self.getLabels();
Simon Hausmannb9847332007-03-20 20:54:23 +01002931
Simon Hausmann4b97ffb2007-05-18 21:45:23 +02002932 if self.detectBranches:
Simon Hausmanndf450922007-06-08 08:49:22 +02002933 ## FIXME - what's a P4 projectName ?
2934 self.projectName = self.guessProjectName()
2935
Simon Hausmann38f9f5e2007-11-15 10:38:45 +01002936 if self.hasOrigin:
2937 self.getBranchMappingFromGitBranches()
2938 else:
2939 self.getBranchMapping()
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002940 if self.verbose:
2941 print "p4-git branches: %s" % self.p4BranchesInGit
2942 print "initial parents: %s" % self.initialParents
2943 for b in self.p4BranchesInGit:
2944 if b != "master":
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002945
2946 ## FIXME
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002947 b = b[len(self.projectName):]
2948 self.createdBranches.add(b)
Simon Hausmann4b97ffb2007-05-18 21:45:23 +02002949
Simon Hausmannf291b4e2007-04-14 11:21:50 +02002950 self.tz = "%+03d%02d" % (- time.timezone / 3600, ((- time.timezone % 3600) / 60))
Simon Hausmannb9847332007-03-20 20:54:23 +01002951
Pete Wyckoff78189be2012-11-23 17:35:36 -05002952 self.importProcess = subprocess.Popen(["git", "fast-import"],
2953 stdin=subprocess.PIPE,
2954 stdout=subprocess.PIPE,
2955 stderr=subprocess.PIPE);
2956 self.gitOutput = self.importProcess.stdout
2957 self.gitStream = self.importProcess.stdin
2958 self.gitError = self.importProcess.stderr
Simon Hausmannb9847332007-03-20 20:54:23 +01002959
Simon Hausmann1c49fc12007-08-26 16:04:34 +02002960 if revision:
Simon Hausmannc208a242007-08-26 16:07:18 +02002961 self.importHeadRevision(revision)
Simon Hausmannb9847332007-03-20 20:54:23 +01002962 else:
2963 changes = []
2964
Simon Hausmann0828ab12007-03-20 20:59:30 +01002965 if len(self.changesFile) > 0:
Simon Hausmannb9847332007-03-20 20:54:23 +01002966 output = open(self.changesFile).readlines()
Reilly Grant1d7367d2009-09-10 00:02:38 -07002967 changeSet = set()
Simon Hausmannb9847332007-03-20 20:54:23 +01002968 for line in output:
2969 changeSet.add(int(line))
2970
2971 for change in changeSet:
2972 changes.append(change)
2973
2974 changes.sort()
2975 else:
Pete Wyckoff9dcb9f22012-04-08 20:18:01 -04002976 # catch "git p4 sync" with no new branches, in a repo that
2977 # does not have any existing p4 branches
Pete Wyckoff5a8e84c2013-01-14 19:47:05 -05002978 if len(args) == 0:
2979 if not self.p4BranchesInGit:
2980 die("No remote p4 branches. Perhaps you never did \"git p4 clone\" in here.")
2981
2982 # The default branch is master, unless --branch is used to
2983 # specify something else. Make sure it exists, or complain
2984 # nicely about how to use --branch.
2985 if not self.detectBranches:
2986 if not branch_exists(self.branch):
2987 if branch_arg_given:
2988 die("Error: branch %s does not exist." % self.branch)
2989 else:
2990 die("Error: no branch %s; perhaps specify one with --branch." %
2991 self.branch)
2992
Simon Hausmann29bdbac2007-05-19 10:23:12 +02002993 if self.verbose:
Han-Wen Nienhuys86dff6b2007-05-23 18:49:35 -03002994 print "Getting p4 changes for %s...%s" % (', '.join(self.depotPaths),
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03002995 self.changeRange)
Simon Hausmann4f6432d2007-08-26 15:56:36 +02002996 changes = p4ChangesForPaths(self.depotPaths, self.changeRange)
Simon Hausmannb9847332007-03-20 20:54:23 +01002997
Simon Hausmann01a9c9c2007-05-23 00:07:35 +02002998 if len(self.maxChanges) > 0:
Han-Wen Nienhuys7fcff9d2007-07-23 15:56:37 -07002999 changes = changes[:min(int(self.maxChanges), len(changes))]
Simon Hausmann01a9c9c2007-05-23 00:07:35 +02003000
Simon Hausmannb9847332007-03-20 20:54:23 +01003001 if len(changes) == 0:
Simon Hausmann0828ab12007-03-20 20:59:30 +01003002 if not self.silent:
Simon Hausmann341dc1c2007-05-21 00:39:16 +02003003 print "No changes to import!"
Luke Diamand06804c72012-04-11 17:21:24 +02003004 else:
3005 if not self.silent and not self.detectBranches:
3006 print "Import destination: %s" % self.branch
Simon Hausmannb9847332007-03-20 20:54:23 +01003007
Luke Diamand06804c72012-04-11 17:21:24 +02003008 self.updatedBranches = set()
Simon Hausmanna9d1a272007-06-11 23:28:03 +02003009
Pete Wyckoff47497842013-01-14 19:47:04 -05003010 if not self.detectBranches:
3011 if args:
3012 # start a new branch
3013 self.initialParent = ""
3014 else:
3015 # build on a previous revision
3016 self.initialParent = parseRevision(self.branch)
3017
Luke Diamand06804c72012-04-11 17:21:24 +02003018 self.importChanges(changes)
Simon Hausmann341dc1c2007-05-21 00:39:16 +02003019
Luke Diamand06804c72012-04-11 17:21:24 +02003020 if not self.silent:
3021 print ""
3022 if len(self.updatedBranches) > 0:
3023 sys.stdout.write("Updated branches: ")
3024 for b in self.updatedBranches:
3025 sys.stdout.write("%s " % b)
3026 sys.stdout.write("\n")
Simon Hausmannb9847332007-03-20 20:54:23 +01003027
Pete Wyckoff0d609032013-01-26 22:11:24 -05003028 if gitConfigBool("git-p4.importLabels"):
Luke Diamand06dcd152012-05-11 07:25:18 +01003029 self.importLabels = True
Luke Diamand06804c72012-04-11 17:21:24 +02003030
3031 if self.importLabels:
3032 p4Labels = getP4Labels(self.depotPaths)
3033 gitTags = getGitTags()
3034
3035 missingP4Labels = p4Labels - gitTags
3036 self.importP4Labels(self.gitStream, missingP4Labels)
Simon Hausmannb9847332007-03-20 20:54:23 +01003037
Simon Hausmannb9847332007-03-20 20:54:23 +01003038 self.gitStream.close()
Pete Wyckoff78189be2012-11-23 17:35:36 -05003039 if self.importProcess.wait() != 0:
Simon Hausmann29bdbac2007-05-19 10:23:12 +02003040 die("fast-import failed: %s" % self.gitError.read())
Simon Hausmannb9847332007-03-20 20:54:23 +01003041 self.gitOutput.close()
3042 self.gitError.close()
3043
Vitor Antunesfed23692012-01-25 23:48:22 +00003044 # Cleanup temporary branches created during import
3045 if self.tempBranches != []:
3046 for branch in self.tempBranches:
3047 read_pipe("git update-ref -d %s" % branch)
3048 os.rmdir(os.path.join(os.environ.get("GIT_DIR", ".git"), self.tempBranchLocation))
3049
Pete Wyckoff55d12432013-01-14 19:46:59 -05003050 # Create a symbolic ref p4/HEAD pointing to p4/<branch> to allow
3051 # a convenient shortcut refname "p4".
3052 if self.importIntoRemotes:
3053 head_ref = self.refPrefix + "HEAD"
3054 if not gitBranchExists(head_ref) and gitBranchExists(self.branch):
3055 system(["git", "symbolic-ref", head_ref, self.branch])
3056
Simon Hausmannb9847332007-03-20 20:54:23 +01003057 return True
3058
Simon Hausmann01ce1fe2007-04-07 23:46:50 +02003059class P4Rebase(Command):
3060 def __init__(self):
3061 Command.__init__(self)
Luke Diamand06804c72012-04-11 17:21:24 +02003062 self.options = [
3063 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),
Luke Diamand06804c72012-04-11 17:21:24 +02003064 ]
Luke Diamand06804c72012-04-11 17:21:24 +02003065 self.importLabels = False
Han-Wen Nienhuyscebdf5a2007-05-23 16:53:11 -03003066 self.description = ("Fetches the latest revision from perforce and "
3067 + "rebases the current work (branch) against it")
Simon Hausmann01ce1fe2007-04-07 23:46:50 +02003068
3069 def run(self, args):
3070 sync = P4Sync()
Luke Diamand06804c72012-04-11 17:21:24 +02003071 sync.importLabels = self.importLabels
Simon Hausmann01ce1fe2007-04-07 23:46:50 +02003072 sync.run([])
Simon Hausmannd7e38682007-06-12 14:34:46 +02003073
Simon Hausmann14594f42007-08-22 09:07:15 +02003074 return self.rebase()
3075
3076 def rebase(self):
Simon Hausmann36ee4ee2008-01-07 14:21:45 +01003077 if os.system("git update-index --refresh") != 0:
3078 die("Some files in your working directory are modified and different than what is in your index. You can use git update-index <filename> to bring the index up-to-date or stash away all your changes with git stash.");
3079 if len(read_pipe("git diff-index HEAD --")) > 0:
Veres Lajosf7e604e2013-06-19 07:37:24 +02003080 die("You have uncommitted changes. Please commit them before rebasing or stash them away with git stash.");
Simon Hausmann36ee4ee2008-01-07 14:21:45 +01003081
Simon Hausmannd7e38682007-06-12 14:34:46 +02003082 [upstream, settings] = findUpstreamBranchPoint()
3083 if len(upstream) == 0:
3084 die("Cannot find upstream branchpoint for rebase")
3085
3086 # the branchpoint may be p4/foo~3, so strip off the parent
3087 upstream = re.sub("~[0-9]+$", "", upstream)
3088
3089 print "Rebasing the current branch onto %s" % upstream
Han-Wen Nienhuysb25b2062007-05-23 18:49:35 -03003090 oldHead = read_pipe("git rev-parse HEAD").strip()
Simon Hausmannd7e38682007-06-12 14:34:46 +02003091 system("git rebase %s" % upstream)
Vlad Dogaru4e49d952014-04-07 16:19:11 +03003092 system("git diff-tree --stat --summary -M %s HEAD --" % oldHead)
Simon Hausmann01ce1fe2007-04-07 23:46:50 +02003093 return True
3094
Simon Hausmannf9a3a4f2007-04-08 10:08:26 +02003095class P4Clone(P4Sync):
3096 def __init__(self):
3097 P4Sync.__init__(self)
3098 self.description = "Creates a new git repository and imports from Perforce into it"
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003099 self.usage = "usage: %prog [options] //depot/path[@revRange]"
Tommy Thorn354081d2008-02-03 10:38:51 -08003100 self.options += [
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003101 optparse.make_option("--destination", dest="cloneDestination",
3102 action='store', default=None,
Tommy Thorn354081d2008-02-03 10:38:51 -08003103 help="where to leave result of the clone"),
3104 optparse.make_option("-/", dest="cloneExclude",
3105 action="append", type="string",
Pete Wyckoff38200072011-02-19 08:18:01 -05003106 help="exclude depot path"),
3107 optparse.make_option("--bare", dest="cloneBare",
3108 action="store_true", default=False),
Tommy Thorn354081d2008-02-03 10:38:51 -08003109 ]
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003110 self.cloneDestination = None
Simon Hausmannf9a3a4f2007-04-08 10:08:26 +02003111 self.needsGit = False
Pete Wyckoff38200072011-02-19 08:18:01 -05003112 self.cloneBare = False
Simon Hausmannf9a3a4f2007-04-08 10:08:26 +02003113
Tommy Thorn354081d2008-02-03 10:38:51 -08003114 # This is required for the "append" cloneExclude action
3115 def ensure_value(self, attr, value):
3116 if not hasattr(self, attr) or getattr(self, attr) is None:
3117 setattr(self, attr, value)
3118 return getattr(self, attr)
3119
Han-Wen Nienhuys6a49f8e2007-05-23 18:49:35 -03003120 def defaultDestination(self, args):
3121 ## TODO: use common prefix of args?
3122 depotPath = args[0]
3123 depotDir = re.sub("(@[^@]*)$", "", depotPath)
3124 depotDir = re.sub("(#[^#]*)$", "", depotDir)
Toby Allsopp053d9e42008-02-05 09:41:43 +13003125 depotDir = re.sub(r"\.\.\.$", "", depotDir)
Han-Wen Nienhuys6a49f8e2007-05-23 18:49:35 -03003126 depotDir = re.sub(r"/$", "", depotDir)
3127 return os.path.split(depotDir)[1]
3128
Simon Hausmannf9a3a4f2007-04-08 10:08:26 +02003129 def run(self, args):
3130 if len(args) < 1:
3131 return False
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003132
3133 if self.keepRepoPath and not self.cloneDestination:
3134 sys.stderr.write("Must specify destination for --keep-path\n")
3135 sys.exit(1)
Simon Hausmannf9a3a4f2007-04-08 10:08:26 +02003136
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03003137 depotPaths = args
Simon Hausmann5e100b52007-06-07 21:12:25 +02003138
3139 if not self.cloneDestination and len(depotPaths) > 1:
3140 self.cloneDestination = depotPaths[-1]
3141 depotPaths = depotPaths[:-1]
3142
Tommy Thorn354081d2008-02-03 10:38:51 -08003143 self.cloneExclude = ["/"+p for p in self.cloneExclude]
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03003144 for p in depotPaths:
3145 if not p.startswith("//"):
Pete Wyckoff0f487d32013-01-26 22:11:06 -05003146 sys.stderr.write('Depot paths must start with "//": %s\n' % p)
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03003147 return False
Simon Hausmannf9a3a4f2007-04-08 10:08:26 +02003148
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003149 if not self.cloneDestination:
Marius Storm-Olsen98ad4fa2007-06-07 15:08:33 +02003150 self.cloneDestination = self.defaultDestination(args)
Simon Hausmannf9a3a4f2007-04-08 10:08:26 +02003151
Han-Wen Nienhuys86dff6b2007-05-23 18:49:35 -03003152 print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
Pete Wyckoff38200072011-02-19 08:18:01 -05003153
Kevin Greenc3bf3f12007-06-11 16:48:07 -04003154 if not os.path.exists(self.cloneDestination):
3155 os.makedirs(self.cloneDestination)
Robert Blum053fd0c2008-08-01 12:50:03 -07003156 chdir(self.cloneDestination)
Pete Wyckoff38200072011-02-19 08:18:01 -05003157
3158 init_cmd = [ "git", "init" ]
3159 if self.cloneBare:
3160 init_cmd.append("--bare")
Brandon Caseya235e852013-01-26 11:14:33 -08003161 retcode = subprocess.call(init_cmd)
3162 if retcode:
3163 raise CalledProcessError(retcode, init_cmd)
Pete Wyckoff38200072011-02-19 08:18:01 -05003164
Han-Wen Nienhuys6326aa52007-05-23 18:49:35 -03003165 if not P4Sync.run(self, depotPaths):
Simon Hausmannf9a3a4f2007-04-08 10:08:26 +02003166 return False
Pete Wyckoffc5959562013-01-14 19:47:01 -05003167
3168 # create a master branch and check out a work tree
3169 if gitBranchExists(self.branch):
3170 system([ "git", "branch", "master", self.branch ])
3171 if not self.cloneBare:
3172 system([ "git", "checkout", "-f" ])
3173 else:
3174 print 'Not checking out any branch, use ' \
3175 '"git checkout -q -b master <branch>"'
Han-Wen Nienhuys86dff6b2007-05-23 18:49:35 -03003176
Pete Wyckoffa93d33e2012-02-25 20:06:24 -05003177 # auto-set this variable if invoked with --use-client-spec
3178 if self.useClientSpec_from_options:
3179 system("git config --bool git-p4.useclientspec true")
3180
Simon Hausmannf9a3a4f2007-04-08 10:08:26 +02003181 return True
3182
Simon Hausmann09d89de2007-06-20 23:10:28 +02003183class P4Branches(Command):
3184 def __init__(self):
3185 Command.__init__(self)
3186 self.options = [ ]
3187 self.description = ("Shows the git branches that hold imports and their "
3188 + "corresponding perforce depot paths")
3189 self.verbose = False
3190
3191 def run(self, args):
Simon Hausmann5ca44612007-08-24 17:44:16 +02003192 if originP4BranchesExist():
3193 createOrUpdateBranchesFromOrigin()
3194
Simon Hausmann09d89de2007-06-20 23:10:28 +02003195 cmdline = "git rev-parse --symbolic "
3196 cmdline += " --remotes"
3197
3198 for line in read_pipe_lines(cmdline):
3199 line = line.strip()
3200
3201 if not line.startswith('p4/') or line == "p4/HEAD":
3202 continue
3203 branch = line
3204
3205 log = extractLogMessageFromGitCommit("refs/remotes/%s" % branch)
3206 settings = extractSettingsGitLog(log)
3207
3208 print "%s <= %s (%s)" % (branch, ",".join(settings["depot-paths"]), settings["change"])
3209 return True
3210
Simon Hausmannb9847332007-03-20 20:54:23 +01003211class HelpFormatter(optparse.IndentedHelpFormatter):
3212 def __init__(self):
3213 optparse.IndentedHelpFormatter.__init__(self)
3214
3215 def format_description(self, description):
3216 if description:
3217 return description + "\n"
3218 else:
3219 return ""
Simon Hausmann4f5cf762007-03-19 22:25:17 +01003220
Simon Hausmann86949ee2007-03-19 20:59:12 +01003221def printUsage(commands):
3222 print "usage: %s <command> [options]" % sys.argv[0]
3223 print ""
3224 print "valid commands: %s" % ", ".join(commands)
3225 print ""
3226 print "Try %s <command> --help for command specific help." % sys.argv[0]
3227 print ""
3228
3229commands = {
Han-Wen Nienhuysb86f7372007-05-23 18:49:35 -03003230 "debug" : P4Debug,
3231 "submit" : P4Submit,
Marius Storm-Olsena9834f52007-10-09 16:16:09 +02003232 "commit" : P4Submit,
Han-Wen Nienhuysb86f7372007-05-23 18:49:35 -03003233 "sync" : P4Sync,
3234 "rebase" : P4Rebase,
3235 "clone" : P4Clone,
Simon Hausmann09d89de2007-06-20 23:10:28 +02003236 "rollback" : P4RollBack,
3237 "branches" : P4Branches
Simon Hausmann86949ee2007-03-19 20:59:12 +01003238}
3239
Simon Hausmann86949ee2007-03-19 20:59:12 +01003240
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003241def main():
3242 if len(sys.argv[1:]) == 0:
3243 printUsage(commands.keys())
3244 sys.exit(2)
Simon Hausmann86949ee2007-03-19 20:59:12 +01003245
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003246 cmdName = sys.argv[1]
3247 try:
Han-Wen Nienhuysb86f7372007-05-23 18:49:35 -03003248 klass = commands[cmdName]
3249 cmd = klass()
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003250 except KeyError:
3251 print "unknown command %s" % cmdName
3252 print ""
3253 printUsage(commands.keys())
3254 sys.exit(2)
Simon Hausmann4f5cf762007-03-19 22:25:17 +01003255
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003256 options = cmd.options
Han-Wen Nienhuysb86f7372007-05-23 18:49:35 -03003257 cmd.gitdir = os.environ.get("GIT_DIR", None)
Simon Hausmann86949ee2007-03-19 20:59:12 +01003258
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003259 args = sys.argv[2:]
Simon Hausmanne20a9e52007-03-26 00:13:51 +02003260
Pete Wyckoffb0ccc802012-09-09 16:16:10 -04003261 options.append(optparse.make_option("--verbose", "-v", dest="verbose", action="store_true"))
Luke Diamand6a10b6a2012-04-24 09:33:23 +01003262 if cmd.needsGit:
3263 options.append(optparse.make_option("--git-dir", dest="gitdir"))
Simon Hausmanne20a9e52007-03-26 00:13:51 +02003264
Luke Diamand6a10b6a2012-04-24 09:33:23 +01003265 parser = optparse.OptionParser(cmd.usage.replace("%prog", "%prog " + cmdName),
3266 options,
3267 description = cmd.description,
3268 formatter = HelpFormatter())
Simon Hausmann86949ee2007-03-19 20:59:12 +01003269
Luke Diamand6a10b6a2012-04-24 09:33:23 +01003270 (cmd, args) = parser.parse_args(sys.argv[2:], cmd);
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003271 global verbose
3272 verbose = cmd.verbose
3273 if cmd.needsGit:
Han-Wen Nienhuysb86f7372007-05-23 18:49:35 -03003274 if cmd.gitdir == None:
3275 cmd.gitdir = os.path.abspath(".git")
3276 if not isValidGitDir(cmd.gitdir):
3277 cmd.gitdir = read_pipe("git rev-parse --git-dir").strip()
3278 if os.path.exists(cmd.gitdir):
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003279 cdup = read_pipe("git rev-parse --show-cdup").strip()
3280 if len(cdup) > 0:
Robert Blum053fd0c2008-08-01 12:50:03 -07003281 chdir(cdup);
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003282
Han-Wen Nienhuysb86f7372007-05-23 18:49:35 -03003283 if not isValidGitDir(cmd.gitdir):
3284 if isValidGitDir(cmd.gitdir + "/.git"):
3285 cmd.gitdir += "/.git"
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003286 else:
Han-Wen Nienhuysb86f7372007-05-23 18:49:35 -03003287 die("fatal: cannot locate git repository at %s" % cmd.gitdir)
Simon Hausmann8910ac02007-03-26 08:18:55 +02003288
Han-Wen Nienhuysb86f7372007-05-23 18:49:35 -03003289 os.environ["GIT_DIR"] = cmd.gitdir
Simon Hausmann4f5cf762007-03-19 22:25:17 +01003290
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003291 if not cmd.run(args):
3292 parser.print_help()
Pete Wyckoff09fca772011-12-24 21:07:39 -05003293 sys.exit(2)
Simon Hausmann4f5cf762007-03-19 22:25:17 +01003294
Han-Wen Nienhuysbb6e09b2007-05-23 18:49:35 -03003295
3296if __name__ == '__main__':
3297 main()