git-p4: cope with labels with empty descriptions
[git/git.git] / contrib / fast-import / git-p4
CommitLineData
86949eef
SH
1#!/usr/bin/env python
2#
3# git-p4.py -- A tool for bidirectional operation between a Perforce depot and git.
4#
c8cbbee9
SH
5# Author: Simon Hausmann <simon@lst.de>
6# Copyright: 2007 Simon Hausmann <simon@lst.de>
83dce55a 7# 2007 Trolltech ASA
86949eef
SH
8# License: MIT <http://www.opensource.org/licenses/mit-license.php>
9#
10
1d7367dc
RG
11import optparse, sys, os, marshal, subprocess, shelve
12import tempfile, getopt, os.path, time, platform
ce6f33c8 13import re
8b41a97f 14
4addad22 15verbose = False
86949eef 16
21a50753
AK
17
18def p4_build_cmd(cmd):
19 """Build a suitable p4 command line.
20
21 This consolidates building and returning a p4 command line into one
22 location. It means that hooking into the environment, or other configuration
23 can be done more easily.
24 """
6de040df 25 real_cmd = ["p4"]
abcaf073
AK
26
27 user = gitConfig("git-p4.user")
28 if len(user) > 0:
6de040df 29 real_cmd += ["-u",user]
abcaf073
AK
30
31 password = gitConfig("git-p4.password")
32 if len(password) > 0:
6de040df 33 real_cmd += ["-P", password]
abcaf073
AK
34
35 port = gitConfig("git-p4.port")
36 if len(port) > 0:
6de040df 37 real_cmd += ["-p", port]
abcaf073
AK
38
39 host = gitConfig("git-p4.host")
40 if len(host) > 0:
6de040df 41 real_cmd += ["-h", host]
abcaf073
AK
42
43 client = gitConfig("git-p4.client")
44 if len(client) > 0:
6de040df 45 real_cmd += ["-c", client]
abcaf073 46
6de040df
LD
47
48 if isinstance(cmd,basestring):
49 real_cmd = ' '.join(real_cmd) + ' ' + cmd
50 else:
51 real_cmd += cmd
21a50753
AK
52 return real_cmd
53
053fd0c1 54def chdir(dir):
6de040df 55 # P4 uses the PWD environment variable rather than getcwd(). Since we're
bf1d68ff
GG
56 # not using the shell, we have to set it ourselves. This path could
57 # be relative, so go there first, then figure out where we ended up.
053fd0c1 58 os.chdir(dir)
bf1d68ff 59 os.environ['PWD'] = os.getcwd()
053fd0c1 60
86dff6b6
HWN
61def die(msg):
62 if verbose:
63 raise Exception(msg)
64 else:
65 sys.stderr.write(msg + "\n")
66 sys.exit(1)
67
6de040df 68def write_pipe(c, stdin):
4addad22 69 if verbose:
6de040df 70 sys.stderr.write('Writing pipe: %s\n' % str(c))
b016d397 71
6de040df
LD
72 expand = isinstance(c,basestring)
73 p = subprocess.Popen(c, stdin=subprocess.PIPE, shell=expand)
74 pipe = p.stdin
75 val = pipe.write(stdin)
76 pipe.close()
77 if p.wait():
78 die('Command failed: %s' % str(c))
b016d397
HWN
79
80 return val
81
6de040df 82def p4_write_pipe(c, stdin):
d9429194 83 real_cmd = p4_build_cmd(c)
6de040df 84 return write_pipe(real_cmd, stdin)
d9429194 85
4addad22
HWN
86def read_pipe(c, ignore_error=False):
87 if verbose:
6de040df 88 sys.stderr.write('Reading pipe: %s\n' % str(c))
8b41a97f 89
6de040df
LD
90 expand = isinstance(c,basestring)
91 p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand)
92 pipe = p.stdout
b016d397 93 val = pipe.read()
6de040df
LD
94 if p.wait() and not ignore_error:
95 die('Command failed: %s' % str(c))
b016d397
HWN
96
97 return val
98
d9429194
AK
99def p4_read_pipe(c, ignore_error=False):
100 real_cmd = p4_build_cmd(c)
101 return read_pipe(real_cmd, ignore_error)
b016d397 102
bce4c5fc 103def read_pipe_lines(c):
4addad22 104 if verbose:
6de040df
LD
105 sys.stderr.write('Reading pipe: %s\n' % str(c))
106
107 expand = isinstance(c, basestring)
108 p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand)
109 pipe = p.stdout
b016d397 110 val = pipe.readlines()
6de040df
LD
111 if pipe.close() or p.wait():
112 die('Command failed: %s' % str(c))
b016d397
HWN
113
114 return val
caace111 115
2318121b
AK
116def p4_read_pipe_lines(c):
117 """Specifically invoke p4 on the command supplied. """
155af834 118 real_cmd = p4_build_cmd(c)
2318121b
AK
119 return read_pipe_lines(real_cmd)
120
6754a299 121def system(cmd):
6de040df 122 expand = isinstance(cmd,basestring)
4addad22 123 if verbose:
6de040df
LD
124 sys.stderr.write("executing %s\n" % str(cmd))
125 subprocess.check_call(cmd, shell=expand)
6754a299 126
bf9320f1
AK
127def p4_system(cmd):
128 """Specifically invoke p4 as the system command. """
155af834 129 real_cmd = p4_build_cmd(cmd)
6de040df
LD
130 expand = isinstance(real_cmd, basestring)
131 subprocess.check_call(real_cmd, shell=expand)
132
133def p4_integrate(src, dest):
134 p4_system(["integrate", "-Dt", src, dest])
135
136def p4_sync(path):
137 p4_system(["sync", path])
138
139def p4_add(f):
140 p4_system(["add", f])
141
142def p4_delete(f):
143 p4_system(["delete", f])
144
145def p4_edit(f):
146 p4_system(["edit", f])
147
148def p4_revert(f):
149 p4_system(["revert", f])
150
151def p4_reopen(type, file):
152 p4_system(["reopen", "-t", type, file])
bf9320f1 153
9cffb8c8
PW
154#
155# Canonicalize the p4 type and return a tuple of the
156# base type, plus any modifiers. See "p4 help filetypes"
157# for a list and explanation.
158#
159def split_p4_type(p4type):
160
161 p4_filetypes_historical = {
162 "ctempobj": "binary+Sw",
163 "ctext": "text+C",
164 "cxtext": "text+Cx",
165 "ktext": "text+k",
166 "kxtext": "text+kx",
167 "ltext": "text+F",
168 "tempobj": "binary+FSw",
169 "ubinary": "binary+F",
170 "uresource": "resource+F",
171 "uxbinary": "binary+Fx",
172 "xbinary": "binary+x",
173 "xltext": "text+Fx",
174 "xtempobj": "binary+Swx",
175 "xtext": "text+x",
176 "xunicode": "unicode+x",
177 "xutf16": "utf16+x",
178 }
179 if p4type in p4_filetypes_historical:
180 p4type = p4_filetypes_historical[p4type]
181 mods = ""
182 s = p4type.split("+")
183 base = s[0]
184 mods = ""
185 if len(s) > 1:
186 mods = s[1]
187 return (base, mods)
b9fc6ea9 188
b9fc6ea9 189
c65b670e
CP
190def setP4ExecBit(file, mode):
191 # Reopens an already open file and changes the execute bit to match
192 # the execute bit setting in the passed in mode.
193
194 p4Type = "+x"
195
196 if not isModeExec(mode):
197 p4Type = getP4OpenedType(file)
198 p4Type = re.sub('^([cku]?)x(.*)', '\\1\\2', p4Type)
199 p4Type = re.sub('(.*?\+.*?)x(.*?)', '\\1\\2', p4Type)
200 if p4Type[-1] == "+":
201 p4Type = p4Type[0:-1]
202
6de040df 203 p4_reopen(p4Type, file)
c65b670e
CP
204
205def getP4OpenedType(file):
206 # Returns the perforce file type for the given file.
207
6de040df 208 result = p4_read_pipe(["opened", file])
f3e5ae4f 209 match = re.match(".*\((.+)\)\r?$", result)
c65b670e
CP
210 if match:
211 return match.group(1)
212 else:
f3e5ae4f 213 die("Could not determine file type for %s (result: '%s')" % (file, result))
c65b670e 214
b43b0a3c
CP
215def diffTreePattern():
216 # This is a simple generator for the diff tree regex pattern. This could be
217 # a class variable if this and parseDiffTreeEntry were a part of a class.
218 pattern = re.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)')
219 while True:
220 yield pattern
221
222def parseDiffTreeEntry(entry):
223 """Parses a single diff tree entry into its component elements.
224
225 See git-diff-tree(1) manpage for details about the format of the diff
226 output. This method returns a dictionary with the following elements:
227
228 src_mode - The mode of the source file
229 dst_mode - The mode of the destination file
230 src_sha1 - The sha1 for the source file
231 dst_sha1 - The sha1 fr the destination file
232 status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc)
233 status_score - The score for the status (applicable for 'C' and 'R'
234 statuses). This is None if there is no score.
235 src - The path for the source file.
236 dst - The path for the destination file. This is only present for
237 copy or renames. If it is not present, this is None.
238
239 If the pattern is not matched, None is returned."""
240
241 match = diffTreePattern().next().match(entry)
242 if match:
243 return {
244 'src_mode': match.group(1),
245 'dst_mode': match.group(2),
246 'src_sha1': match.group(3),
247 'dst_sha1': match.group(4),
248 'status': match.group(5),
249 'status_score': match.group(6),
250 'src': match.group(7),
251 'dst': match.group(10)
252 }
253 return None
254
c65b670e
CP
255def isModeExec(mode):
256 # Returns True if the given git mode represents an executable file,
257 # otherwise False.
258 return mode[-3:] == "755"
259
260def isModeExecChanged(src_mode, dst_mode):
261 return isModeExec(src_mode) != isModeExec(dst_mode)
262
b932705b 263def p4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None):
6de040df
LD
264
265 if isinstance(cmd,basestring):
266 cmd = "-G " + cmd
267 expand = True
268 else:
269 cmd = ["-G"] + cmd
270 expand = False
271
272 cmd = p4_build_cmd(cmd)
6a49f8e2 273 if verbose:
6de040df 274 sys.stderr.write("Opening pipe: %s\n" % str(cmd))
9f90c733
SL
275
276 # Use a temporary file to avoid deadlocks without
277 # subprocess.communicate(), which would put another copy
278 # of stdout into memory.
279 stdin_file = None
280 if stdin is not None:
281 stdin_file = tempfile.TemporaryFile(prefix='p4-stdin', mode=stdin_mode)
6de040df
LD
282 if isinstance(stdin,basestring):
283 stdin_file.write(stdin)
284 else:
285 for i in stdin:
286 stdin_file.write(i + '\n')
9f90c733
SL
287 stdin_file.flush()
288 stdin_file.seek(0)
289
6de040df
LD
290 p4 = subprocess.Popen(cmd,
291 shell=expand,
9f90c733
SL
292 stdin=stdin_file,
293 stdout=subprocess.PIPE)
86949eef
SH
294
295 result = []
296 try:
297 while True:
9f90c733 298 entry = marshal.load(p4.stdout)
c3f6163b
AG
299 if cb is not None:
300 cb(entry)
301 else:
302 result.append(entry)
86949eef
SH
303 except EOFError:
304 pass
9f90c733
SL
305 exitCode = p4.wait()
306 if exitCode != 0:
ac3e0d79
SH
307 entry = {}
308 entry["p4ExitCode"] = exitCode
309 result.append(entry)
86949eef
SH
310
311 return result
312
313def p4Cmd(cmd):
314 list = p4CmdList(cmd)
315 result = {}
316 for entry in list:
317 result.update(entry)
318 return result;
319
cb2c9db5
SH
320def p4Where(depotPath):
321 if not depotPath.endswith("/"):
322 depotPath += "/"
7f705dc3 323 depotPath = depotPath + "..."
6de040df 324 outputList = p4CmdList(["where", depotPath])
7f705dc3
TAL
325 output = None
326 for entry in outputList:
75bc9573
TAL
327 if "depotFile" in entry:
328 if entry["depotFile"] == depotPath:
329 output = entry
330 break
331 elif "data" in entry:
332 data = entry.get("data")
333 space = data.find(" ")
334 if data[:space] == depotPath:
335 output = entry
336 break
7f705dc3
TAL
337 if output == None:
338 return ""
dc524036
SH
339 if output["code"] == "error":
340 return ""
cb2c9db5
SH
341 clientPath = ""
342 if "path" in output:
343 clientPath = output.get("path")
344 elif "data" in output:
345 data = output.get("data")
346 lastSpace = data.rfind(" ")
347 clientPath = data[lastSpace + 1:]
348
349 if clientPath.endswith("..."):
350 clientPath = clientPath[:-3]
351 return clientPath
352
86949eef 353def currentGitBranch():
b25b2065 354 return read_pipe("git name-rev HEAD").split(" ")[1].strip()
86949eef 355
4f5cf76a 356def isValidGitDir(path):
bb6e09b2
HWN
357 if (os.path.exists(path + "/HEAD")
358 and os.path.exists(path + "/refs") and os.path.exists(path + "/objects")):
4f5cf76a
SH
359 return True;
360 return False
361
463e8af6 362def parseRevision(ref):
b25b2065 363 return read_pipe("git rev-parse %s" % ref).strip()
463e8af6 364
28755dba
PW
365def branchExists(ref):
366 rev = read_pipe(["git", "rev-parse", "-q", "--verify", ref],
367 ignore_error=True)
368 return len(rev) > 0
369
6ae8de88
SH
370def extractLogMessageFromGitCommit(commit):
371 logMessage = ""
b016d397
HWN
372
373 ## fixme: title is first line of commit, not 1st paragraph.
6ae8de88 374 foundTitle = False
b016d397 375 for log in read_pipe_lines("git cat-file commit %s" % commit):
6ae8de88
SH
376 if not foundTitle:
377 if len(log) == 1:
1c094184 378 foundTitle = True
6ae8de88
SH
379 continue
380
381 logMessage += log
382 return logMessage
383
bb6e09b2 384def extractSettingsGitLog(log):
6ae8de88
SH
385 values = {}
386 for line in log.split("\n"):
387 line = line.strip()
6326aa58
HWN
388 m = re.search (r"^ *\[git-p4: (.*)\]$", line)
389 if not m:
390 continue
391
392 assignments = m.group(1).split (':')
393 for a in assignments:
394 vals = a.split ('=')
395 key = vals[0].strip()
396 val = ('='.join (vals[1:])).strip()
397 if val.endswith ('\"') and val.startswith('"'):
398 val = val[1:-1]
399
400 values[key] = val
401
845b42cb
SH
402 paths = values.get("depot-paths")
403 if not paths:
404 paths = values.get("depot-path")
a3fdd579
SH
405 if paths:
406 values['depot-paths'] = paths.split(',')
bb6e09b2 407 return values
6ae8de88 408
8136a639 409def gitBranchExists(branch):
bb6e09b2
HWN
410 proc = subprocess.Popen(["git", "rev-parse", branch],
411 stderr=subprocess.PIPE, stdout=subprocess.PIPE);
caace111 412 return proc.wait() == 0;
8136a639 413
36bd8446 414_gitConfig = {}
99f790f2 415def gitConfig(key, args = None): # set args to "--bool", for instance
36bd8446 416 if not _gitConfig.has_key(key):
99f790f2
TAL
417 argsFilter = ""
418 if args != None:
419 argsFilter = "%s " % args
420 cmd = "git config %s%s" % (argsFilter, key)
421 _gitConfig[key] = read_pipe(cmd, ignore_error=True).strip()
36bd8446 422 return _gitConfig[key]
01265103 423
7199cf13
VA
424def gitConfigList(key):
425 if not _gitConfig.has_key(key):
426 _gitConfig[key] = read_pipe("git config --get-all %s" % key, ignore_error=True).strip().split(os.linesep)
427 return _gitConfig[key]
428
062410bb
SH
429def p4BranchesInGit(branchesAreInRemotes = True):
430 branches = {}
431
432 cmdline = "git rev-parse --symbolic "
433 if branchesAreInRemotes:
434 cmdline += " --remotes"
435 else:
436 cmdline += " --branches"
437
438 for line in read_pipe_lines(cmdline):
439 line = line.strip()
440
441 ## only import to p4/
442 if not line.startswith('p4/') or line == "p4/HEAD":
443 continue
444 branch = line
445
446 # strip off p4
447 branch = re.sub ("^p4/", "", line)
448
449 branches[branch] = parseRevision(line)
450 return branches
451
9ceab363 452def findUpstreamBranchPoint(head = "HEAD"):
86506fe5
SH
453 branches = p4BranchesInGit()
454 # map from depot-path to branch name
455 branchByDepotPath = {}
456 for branch in branches.keys():
457 tip = branches[branch]
458 log = extractLogMessageFromGitCommit(tip)
459 settings = extractSettingsGitLog(log)
460 if settings.has_key("depot-paths"):
461 paths = ",".join(settings["depot-paths"])
462 branchByDepotPath[paths] = "remotes/p4/" + branch
463
27d2d811 464 settings = None
27d2d811
SH
465 parent = 0
466 while parent < 65535:
9ceab363 467 commit = head + "~%s" % parent
27d2d811
SH
468 log = extractLogMessageFromGitCommit(commit)
469 settings = extractSettingsGitLog(log)
86506fe5
SH
470 if settings.has_key("depot-paths"):
471 paths = ",".join(settings["depot-paths"])
472 if branchByDepotPath.has_key(paths):
473 return [branchByDepotPath[paths], settings]
27d2d811 474
86506fe5 475 parent = parent + 1
27d2d811 476
86506fe5 477 return ["", settings]
27d2d811 478
5ca44617
SH
479def createOrUpdateBranchesFromOrigin(localRefPrefix = "refs/remotes/p4/", silent=True):
480 if not silent:
481 print ("Creating/updating branch(es) in %s based on origin branch(es)"
482 % localRefPrefix)
483
484 originPrefix = "origin/p4/"
485
486 for line in read_pipe_lines("git rev-parse --symbolic --remotes"):
487 line = line.strip()
488 if (not line.startswith(originPrefix)) or line.endswith("HEAD"):
489 continue
490
491 headName = line[len(originPrefix):]
492 remoteHead = localRefPrefix + headName
493 originHead = line
494
495 original = extractSettingsGitLog(extractLogMessageFromGitCommit(originHead))
496 if (not original.has_key('depot-paths')
497 or not original.has_key('change')):
498 continue
499
500 update = False
501 if not gitBranchExists(remoteHead):
502 if verbose:
503 print "creating %s" % remoteHead
504 update = True
505 else:
506 settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead))
507 if settings.has_key('change') > 0:
508 if settings['depot-paths'] == original['depot-paths']:
509 originP4Change = int(original['change'])
510 p4Change = int(settings['change'])
511 if originP4Change > p4Change:
512 print ("%s (%s) is newer than %s (%s). "
513 "Updating p4 branch from origin."
514 % (originHead, originP4Change,
515 remoteHead, p4Change))
516 update = True
517 else:
518 print ("Ignoring: %s was imported from %s while "
519 "%s was imported from %s"
520 % (originHead, ','.join(original['depot-paths']),
521 remoteHead, ','.join(settings['depot-paths'])))
522
523 if update:
524 system("git update-ref %s %s" % (remoteHead, originHead))
525
526def originP4BranchesExist():
527 return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
528
4f6432d8
SH
529def p4ChangesForPaths(depotPaths, changeRange):
530 assert depotPaths
6de040df
LD
531 cmd = ['changes']
532 for p in depotPaths:
533 cmd += ["%s...%s" % (p, changeRange)]
534 output = p4_read_pipe_lines(cmd)
4f6432d8 535
b4b0ba06 536 changes = {}
4f6432d8 537 for line in output:
c3f6163b
AG
538 changeNum = int(line.split(" ")[1])
539 changes[changeNum] = True
4f6432d8 540
b4b0ba06
PW
541 changelist = changes.keys()
542 changelist.sort()
543 return changelist
4f6432d8 544
d53de8b9
TAL
545def p4PathStartsWith(path, prefix):
546 # This method tries to remedy a potential mixed-case issue:
547 #
548 # If UserA adds //depot/DirA/file1
549 # and UserB adds //depot/dira/file2
550 #
551 # we may or may not have a problem. If you have core.ignorecase=true,
552 # we treat DirA and dira as the same directory
553 ignorecase = gitConfig("core.ignorecase", "--bool") == "true"
554 if ignorecase:
555 return path.lower().startswith(prefix.lower())
556 return path.startswith(prefix)
557
b984733c
SH
558class Command:
559 def __init__(self):
560 self.usage = "usage: %prog [options]"
8910ac0e 561 self.needsGit = True
b984733c 562
3ea2cfd4
LD
563class P4UserMap:
564 def __init__(self):
565 self.userMapFromPerforceServer = False
566
567 def getUserCacheFilename(self):
568 home = os.environ.get("HOME", os.environ.get("USERPROFILE"))
569 return home + "/.gitp4-usercache.txt"
570
571 def getUserMapFromPerforceServer(self):
572 if self.userMapFromPerforceServer:
573 return
574 self.users = {}
575 self.emails = {}
576
577 for output in p4CmdList("users"):
578 if not output.has_key("User"):
579 continue
580 self.users[output["User"]] = output["FullName"] + " <" + output["Email"] + ">"
581 self.emails[output["Email"]] = output["User"]
582
583
584 s = ''
585 for (key, val) in self.users.items():
586 s += "%s\t%s\n" % (key.expandtabs(1), val.expandtabs(1))
587
588 open(self.getUserCacheFilename(), "wb").write(s)
589 self.userMapFromPerforceServer = True
590
591 def loadUserMapFromCache(self):
592 self.users = {}
593 self.userMapFromPerforceServer = False
594 try:
595 cache = open(self.getUserCacheFilename(), "rb")
596 lines = cache.readlines()
597 cache.close()
598 for line in lines:
599 entry = line.strip().split("\t")
600 self.users[entry[0]] = entry[1]
601 except IOError:
602 self.getUserMapFromPerforceServer()
603
b984733c 604class P4Debug(Command):
86949eef 605 def __init__(self):
6ae8de88 606 Command.__init__(self)
86949eef 607 self.options = [
b1ce9447
HWN
608 optparse.make_option("--verbose", dest="verbose", action="store_true",
609 default=False),
4addad22 610 ]
c8c39116 611 self.description = "A tool to debug the output of p4 -G."
8910ac0e 612 self.needsGit = False
b1ce9447 613 self.verbose = False
86949eef
SH
614
615 def run(self, args):
b1ce9447 616 j = 0
6de040df 617 for output in p4CmdList(args):
b1ce9447
HWN
618 print 'Element: %d' % j
619 j += 1
86949eef 620 print output
b984733c 621 return True
86949eef 622
5834684d
SH
623class P4RollBack(Command):
624 def __init__(self):
625 Command.__init__(self)
626 self.options = [
0c66a783
SH
627 optparse.make_option("--verbose", dest="verbose", action="store_true"),
628 optparse.make_option("--local", dest="rollbackLocalBranches", action="store_true")
5834684d
SH
629 ]
630 self.description = "A tool to debug the multi-branch import. Don't use :)"
52102d47 631 self.verbose = False
0c66a783 632 self.rollbackLocalBranches = False
5834684d
SH
633
634 def run(self, args):
635 if len(args) != 1:
636 return False
637 maxChange = int(args[0])
0c66a783 638
ad192f28 639 if "p4ExitCode" in p4Cmd("changes -m 1"):
66a2f523
SH
640 die("Problems executing p4");
641
0c66a783
SH
642 if self.rollbackLocalBranches:
643 refPrefix = "refs/heads/"
b016d397 644 lines = read_pipe_lines("git rev-parse --symbolic --branches")
0c66a783
SH
645 else:
646 refPrefix = "refs/remotes/"
b016d397 647 lines = read_pipe_lines("git rev-parse --symbolic --remotes")
0c66a783
SH
648
649 for line in lines:
650 if self.rollbackLocalBranches or (line.startswith("p4/") and line != "p4/HEAD\n"):
b25b2065
HWN
651 line = line.strip()
652 ref = refPrefix + line
5834684d 653 log = extractLogMessageFromGitCommit(ref)
bb6e09b2
HWN
654 settings = extractSettingsGitLog(log)
655
656 depotPaths = settings['depot-paths']
657 change = settings['change']
658
5834684d 659 changed = False
52102d47 660
6326aa58
HWN
661 if len(p4Cmd("changes -m 1 " + ' '.join (['%s...@%s' % (p, maxChange)
662 for p in depotPaths]))) == 0:
52102d47
SH
663 print "Branch %s did not exist at change %s, deleting." % (ref, maxChange)
664 system("git update-ref -d %s `git rev-parse %s`" % (ref, ref))
665 continue
666
bb6e09b2 667 while change and int(change) > maxChange:
5834684d 668 changed = True
52102d47
SH
669 if self.verbose:
670 print "%s is at %s ; rewinding towards %s" % (ref, change, maxChange)
5834684d
SH
671 system("git update-ref %s \"%s^\"" % (ref, ref))
672 log = extractLogMessageFromGitCommit(ref)
bb6e09b2
HWN
673 settings = extractSettingsGitLog(log)
674
675
676 depotPaths = settings['depot-paths']
677 change = settings['change']
5834684d
SH
678
679 if changed:
52102d47 680 print "%s rewound to %s" % (ref, change)
5834684d
SH
681
682 return True
683
3ea2cfd4 684class P4Submit(Command, P4UserMap):
4f5cf76a 685 def __init__(self):
b984733c 686 Command.__init__(self)
3ea2cfd4 687 P4UserMap.__init__(self)
4f5cf76a 688 self.options = [
4addad22 689 optparse.make_option("--verbose", dest="verbose", action="store_true"),
4f5cf76a 690 optparse.make_option("--origin", dest="origin"),
ae901090 691 optparse.make_option("-M", dest="detectRenames", action="store_true"),
3ea2cfd4
LD
692 # preserve the user, requires relevant p4 permissions
693 optparse.make_option("--preserve-user", dest="preserveUser", action="store_true"),
4f5cf76a
SH
694 ]
695 self.description = "Submit changes from git to the perforce depot."
c9b50e63 696 self.usage += " [name of git branch to submit into perforce depot]"
4f5cf76a 697 self.interactive = True
9512497b 698 self.origin = ""
ae901090 699 self.detectRenames = False
b0d10df7 700 self.verbose = False
3ea2cfd4 701 self.preserveUser = gitConfig("git-p4.preserveUser").lower() == "true"
f7baba8b 702 self.isWindows = (platform.system() == "Windows")
848de9c3 703 self.myP4UserId = None
4f5cf76a 704
4f5cf76a
SH
705 def check(self):
706 if len(p4CmdList("opened ...")) > 0:
707 die("You have files opened with perforce! Close them before starting the sync.")
708
edae1e2f
SH
709 # replaces everything between 'Description:' and the next P4 submit template field with the
710 # commit message
4f5cf76a
SH
711 def prepareLogMessage(self, template, message):
712 result = ""
713
edae1e2f
SH
714 inDescriptionSection = False
715
4f5cf76a
SH
716 for line in template.split("\n"):
717 if line.startswith("#"):
718 result += line + "\n"
719 continue
720
edae1e2f 721 if inDescriptionSection:
c9dbab04 722 if line.startswith("Files:") or line.startswith("Jobs:"):
edae1e2f
SH
723 inDescriptionSection = False
724 else:
725 continue
726 else:
727 if line.startswith("Description:"):
728 inDescriptionSection = True
729 line += "\n"
730 for messageLine in message.split("\n"):
731 line += "\t" + messageLine + "\n"
732
733 result += line + "\n"
4f5cf76a
SH
734
735 return result
736
3ea2cfd4
LD
737 def p4UserForCommit(self,id):
738 # Return the tuple (perforce user,git email) for a given git commit id
739 self.getUserMapFromPerforceServer()
740 gitEmail = read_pipe("git log --max-count=1 --format='%%ae' %s" % id)
741 gitEmail = gitEmail.strip()
742 if not self.emails.has_key(gitEmail):
743 return (None,gitEmail)
744 else:
745 return (self.emails[gitEmail],gitEmail)
746
747 def checkValidP4Users(self,commits):
748 # check if any git authors cannot be mapped to p4 users
749 for id in commits:
750 (user,email) = self.p4UserForCommit(id)
751 if not user:
752 msg = "Cannot find p4 user for email %s in commit %s." % (email, id)
753 if gitConfig('git-p4.allowMissingP4Users').lower() == "true":
754 print "%s" % msg
755 else:
756 die("Error: %s\nSet git-p4.allowMissingP4Users to true to allow this." % msg)
757
758 def lastP4Changelist(self):
759 # Get back the last changelist number submitted in this client spec. This
760 # then gets used to patch up the username in the change. If the same
761 # client spec is being used by multiple processes then this might go
762 # wrong.
763 results = p4CmdList("client -o") # find the current client
764 client = None
765 for r in results:
766 if r.has_key('Client'):
767 client = r['Client']
768 break
769 if not client:
770 die("could not get client spec")
6de040df 771 results = p4CmdList(["changes", "-c", client, "-m", "1"])
3ea2cfd4
LD
772 for r in results:
773 if r.has_key('change'):
774 return r['change']
775 die("Could not get changelist number for last submit - cannot patch up user details")
776
777 def modifyChangelistUser(self, changelist, newUser):
778 # fixup the user field of a changelist after it has been submitted.
779 changes = p4CmdList("change -o %s" % changelist)
ecdba36d
LD
780 if len(changes) != 1:
781 die("Bad output from p4 change modifying %s to user %s" %
782 (changelist, newUser))
783
784 c = changes[0]
785 if c['User'] == newUser: return # nothing to do
786 c['User'] = newUser
787 input = marshal.dumps(c)
788
3ea2cfd4
LD
789 result = p4CmdList("change -f -i", stdin=input)
790 for r in result:
791 if r.has_key('code'):
792 if r['code'] == 'error':
793 die("Could not modify user field of changelist %s to %s:%s" % (changelist, newUser, r['data']))
794 if r.has_key('data'):
795 print("Updated user field for changelist %s to %s" % (changelist, newUser))
796 return
797 die("Could not modify user field of changelist %s to %s" % (changelist, newUser))
798
799 def canChangeChangelists(self):
800 # check to see if we have p4 admin or super-user permissions, either of
801 # which are required to modify changelists.
52a4880b 802 results = p4CmdList(["protects", self.depotPath])
3ea2cfd4
LD
803 for r in results:
804 if r.has_key('perm'):
805 if r['perm'] == 'admin':
806 return 1
807 if r['perm'] == 'super':
808 return 1
809 return 0
810
848de9c3
LD
811 def p4UserId(self):
812 if self.myP4UserId:
813 return self.myP4UserId
814
815 results = p4CmdList("user -o")
816 for r in results:
817 if r.has_key('User'):
818 self.myP4UserId = r['User']
819 return r['User']
820 die("Could not find your p4 user id")
821
822 def p4UserIsMe(self, p4User):
823 # return True if the given p4 user is actually me
824 me = self.p4UserId()
825 if not p4User or p4User != me:
826 return False
827 else:
828 return True
829
ea99c3ae
SH
830 def prepareSubmitTemplate(self):
831 # remove lines in the Files section that show changes to files outside the depot path we're committing into
832 template = ""
833 inFilesSection = False
6de040df 834 for line in p4_read_pipe_lines(['change', '-o']):
f3e5ae4f
MSO
835 if line.endswith("\r\n"):
836 line = line[:-2] + "\n"
ea99c3ae
SH
837 if inFilesSection:
838 if line.startswith("\t"):
839 # path starts and ends with a tab
840 path = line[1:]
841 lastTab = path.rfind("\t")
842 if lastTab != -1:
843 path = path[:lastTab]
d53de8b9 844 if not p4PathStartsWith(path, self.depotPath):
ea99c3ae
SH
845 continue
846 else:
847 inFilesSection = False
848 else:
849 if line.startswith("Files:"):
850 inFilesSection = True
851
852 template += line
853
854 return template
855
7c766e57
PW
856 def edit_template(self, template_file):
857 """Invoke the editor to let the user change the submission
858 message. Return true if okay to continue with the submit."""
859
860 # if configured to skip the editing part, just submit
861 if gitConfig("git-p4.skipSubmitEdit") == "true":
862 return True
863
864 # look at the modification time, to check later if the user saved
865 # the file
866 mtime = os.stat(template_file).st_mtime
867
868 # invoke the editor
869 if os.environ.has_key("P4EDITOR"):
870 editor = os.environ.get("P4EDITOR")
871 else:
872 editor = read_pipe("git var GIT_EDITOR").strip()
873 system(editor + " " + template_file)
874
875 # If the file was not saved, prompt to see if this patch should
876 # be skipped. But skip this verification step if configured so.
877 if gitConfig("git-p4.skipSubmitEditCheck") == "true":
878 return True
879
d1652049
PW
880 # modification time updated means user saved the file
881 if os.stat(template_file).st_mtime > mtime:
882 return True
883
884 while True:
885 response = raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")
886 if response == 'y':
887 return True
888 if response == 'n':
889 return False
7c766e57 890
7cb5cbef 891 def applyCommit(self, id):
0e36f2d7 892 print "Applying %s" % (read_pipe("git log --max-count=1 --pretty=oneline %s" % id))
ae901090 893
848de9c3 894 (p4User, gitEmail) = self.p4UserForCommit(id)
3ea2cfd4 895
ae901090
VA
896 if not self.detectRenames:
897 # If not explicitly set check the config variable
0a9feffc 898 self.detectRenames = gitConfig("git-p4.detectRenames")
ae901090 899
0a9feffc
VA
900 if self.detectRenames.lower() == "false" or self.detectRenames == "":
901 diffOpts = ""
902 elif self.detectRenames.lower() == "true":
ae901090
VA
903 diffOpts = "-M"
904 else:
0a9feffc 905 diffOpts = "-M%s" % self.detectRenames
ae901090 906
0a9feffc
VA
907 detectCopies = gitConfig("git-p4.detectCopies")
908 if detectCopies.lower() == "true":
4fddb41b 909 diffOpts += " -C"
0a9feffc
VA
910 elif detectCopies != "" and detectCopies.lower() != "false":
911 diffOpts += " -C%s" % detectCopies
4fddb41b 912
68cbcf1b 913 if gitConfig("git-p4.detectCopiesHarder", "--bool") == "true":
4fddb41b
VA
914 diffOpts += " --find-copies-harder"
915
0e36f2d7 916 diff = read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (diffOpts, id, id))
4f5cf76a
SH
917 filesToAdd = set()
918 filesToDelete = set()
d336c158 919 editedFiles = set()
c65b670e 920 filesToChangeExecBit = {}
4f5cf76a 921 for line in diff:
b43b0a3c
CP
922 diff = parseDiffTreeEntry(line)
923 modifier = diff['status']
924 path = diff['src']
4f5cf76a 925 if modifier == "M":
6de040df 926 p4_edit(path)
c65b670e
CP
927 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
928 filesToChangeExecBit[path] = diff['dst_mode']
d336c158 929 editedFiles.add(path)
4f5cf76a
SH
930 elif modifier == "A":
931 filesToAdd.add(path)
c65b670e 932 filesToChangeExecBit[path] = diff['dst_mode']
4f5cf76a
SH
933 if path in filesToDelete:
934 filesToDelete.remove(path)
935 elif modifier == "D":
936 filesToDelete.add(path)
937 if path in filesToAdd:
938 filesToAdd.remove(path)
4fddb41b
VA
939 elif modifier == "C":
940 src, dest = diff['src'], diff['dst']
6de040df 941 p4_integrate(src, dest)
4fddb41b 942 if diff['src_sha1'] != diff['dst_sha1']:
6de040df 943 p4_edit(dest)
4fddb41b 944 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
6de040df 945 p4_edit(dest)
4fddb41b
VA
946 filesToChangeExecBit[dest] = diff['dst_mode']
947 os.unlink(dest)
948 editedFiles.add(dest)
d9a5f25b 949 elif modifier == "R":
b43b0a3c 950 src, dest = diff['src'], diff['dst']
6de040df 951 p4_integrate(src, dest)
ae901090 952 if diff['src_sha1'] != diff['dst_sha1']:
6de040df 953 p4_edit(dest)
c65b670e 954 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
6de040df 955 p4_edit(dest)
c65b670e 956 filesToChangeExecBit[dest] = diff['dst_mode']
d9a5f25b
CP
957 os.unlink(dest)
958 editedFiles.add(dest)
959 filesToDelete.add(src)
4f5cf76a
SH
960 else:
961 die("unknown modifier %s for %s" % (modifier, path))
962
0e36f2d7 963 diffcmd = "git format-patch -k --stdout \"%s^\"..\"%s\"" % (id, id)
47a130b7 964 patchcmd = diffcmd + " | git apply "
c1b296b9
SH
965 tryPatchCmd = patchcmd + "--check -"
966 applyPatchCmd = patchcmd + "--check --apply -"
51a2640a 967
47a130b7 968 if os.system(tryPatchCmd) != 0:
51a2640a
SH
969 print "Unfortunately applying the change failed!"
970 print "What do you want to do?"
971 response = "x"
972 while response != "s" and response != "a" and response != "w":
cebdf5af
HWN
973 response = raw_input("[s]kip this patch / [a]pply the patch forcibly "
974 "and with .rej files / [w]rite the patch to a file (patch.txt) ")
51a2640a
SH
975 if response == "s":
976 print "Skipping! Good luck with the next patches..."
20947149 977 for f in editedFiles:
6de040df 978 p4_revert(f)
20947149 979 for f in filesToAdd:
6de040df 980 os.remove(f)
51a2640a
SH
981 return
982 elif response == "a":
47a130b7 983 os.system(applyPatchCmd)
51a2640a
SH
984 if len(filesToAdd) > 0:
985 print "You may also want to call p4 add on the following files:"
986 print " ".join(filesToAdd)
987 if len(filesToDelete):
988 print "The following files should be scheduled for deletion with p4 delete:"
989 print " ".join(filesToDelete)
cebdf5af
HWN
990 die("Please resolve and submit the conflict manually and "
991 + "continue afterwards with git-p4 submit --continue")
51a2640a
SH
992 elif response == "w":
993 system(diffcmd + " > patch.txt")
994 print "Patch saved to patch.txt in %s !" % self.clientPath
cebdf5af
HWN
995 die("Please resolve and submit the conflict manually and "
996 "continue afterwards with git-p4 submit --continue")
51a2640a 997
47a130b7 998 system(applyPatchCmd)
4f5cf76a
SH
999
1000 for f in filesToAdd:
6de040df 1001 p4_add(f)
4f5cf76a 1002 for f in filesToDelete:
6de040df
LD
1003 p4_revert(f)
1004 p4_delete(f)
4f5cf76a 1005
c65b670e
CP
1006 # Set/clear executable bits
1007 for f in filesToChangeExecBit.keys():
1008 mode = filesToChangeExecBit[f]
1009 setP4ExecBit(f, mode)
1010
0e36f2d7 1011 logMessage = extractLogMessageFromGitCommit(id)
0e36f2d7 1012 logMessage = logMessage.strip()
4f5cf76a 1013
ea99c3ae 1014 template = self.prepareSubmitTemplate()
4f5cf76a
SH
1015
1016 if self.interactive:
1017 submitTemplate = self.prepareLogMessage(template, logMessage)
ecdba36d
LD
1018
1019 if self.preserveUser:
1020 submitTemplate = submitTemplate + ("\n######## Actual user %s, modified after commit\n" % p4User)
1021
67abd417
SB
1022 if os.environ.has_key("P4DIFF"):
1023 del(os.environ["P4DIFF"])
8b130262
AW
1024 diff = ""
1025 for editedFile in editedFiles:
6de040df 1026 diff += p4_read_pipe(['diff', '-du', editedFile])
4f5cf76a 1027
f3e5ae4f 1028 newdiff = ""
4f5cf76a 1029 for newFile in filesToAdd:
f3e5ae4f
MSO
1030 newdiff += "==== new file ====\n"
1031 newdiff += "--- /dev/null\n"
1032 newdiff += "+++ %s\n" % newFile
4f5cf76a
SH
1033 f = open(newFile, "r")
1034 for line in f.readlines():
f3e5ae4f 1035 newdiff += "+" + line
4f5cf76a
SH
1036 f.close()
1037
848de9c3
LD
1038 if self.checkAuthorship and not self.p4UserIsMe(p4User):
1039 submitTemplate += "######## git author %s does not match your p4 account.\n" % gitEmail
1040 submitTemplate += "######## Use git-p4 option --preserve-user to modify authorship\n"
1041 submitTemplate += "######## Use git-p4 config git-p4.skipUserNameCheck hides this message.\n"
1042
f3e5ae4f 1043 separatorLine = "######## everything below this line is just the diff #######\n"
4f5cf76a 1044
7c766e57 1045 (handle, fileName) = tempfile.mkstemp()
e96e400f 1046 tmpFile = os.fdopen(handle, "w+")
f3e5ae4f
MSO
1047 if self.isWindows:
1048 submitTemplate = submitTemplate.replace("\n", "\r\n")
1049 separatorLine = separatorLine.replace("\n", "\r\n")
1050 newdiff = newdiff.replace("\n", "\r\n")
1051 tmpFile.write(submitTemplate + separatorLine + diff + newdiff)
e96e400f 1052 tmpFile.close()
e96e400f 1053
7c766e57
PW
1054 if self.edit_template(fileName):
1055 # read the edited message and submit
cdc7e388
SH
1056 tmpFile = open(fileName, "rb")
1057 message = tmpFile.read()
1058 tmpFile.close()
1059 submitTemplate = message[:message.index(separatorLine)]
1060 if self.isWindows:
1061 submitTemplate = submitTemplate.replace("\r\n", "\n")
6de040df 1062 p4_write_pipe(['submit', '-i'], submitTemplate)
3ea2cfd4
LD
1063
1064 if self.preserveUser:
1065 if p4User:
1066 # Get last changelist number. Cannot easily get it from
7c766e57
PW
1067 # the submit command output as the output is
1068 # unmarshalled.
3ea2cfd4
LD
1069 changelist = self.lastP4Changelist()
1070 self.modifyChangelistUser(changelist, p4User)
cdc7e388 1071 else:
7c766e57 1072 # skip this patch
d1652049 1073 print "Submission cancelled, undoing p4 changes."
cdc7e388 1074 for f in editedFiles:
6de040df 1075 p4_revert(f)
cdc7e388 1076 for f in filesToAdd:
6de040df
LD
1077 p4_revert(f)
1078 os.remove(f)
cdc7e388
SH
1079
1080 os.remove(fileName)
4f5cf76a
SH
1081 else:
1082 fileName = "submit.txt"
1083 file = open(fileName, "w+")
1084 file.write(self.prepareLogMessage(template, logMessage))
1085 file.close()
cebdf5af
HWN
1086 print ("Perforce submit template written as %s. "
1087 + "Please review/edit and then use p4 submit -i < %s to submit directly!"
1088 % (fileName, fileName))
4f5cf76a
SH
1089
1090 def run(self, args):
c9b50e63
SH
1091 if len(args) == 0:
1092 self.master = currentGitBranch()
4280e533 1093 if len(self.master) == 0 or not gitBranchExists("refs/heads/%s" % self.master):
c9b50e63
SH
1094 die("Detecting current git branch failed!")
1095 elif len(args) == 1:
1096 self.master = args[0]
28755dba
PW
1097 if not branchExists(self.master):
1098 die("Branch %s does not exist" % self.master)
c9b50e63
SH
1099 else:
1100 return False
1101
4c2d5d72
JX
1102 allowSubmit = gitConfig("git-p4.allowSubmit")
1103 if len(allowSubmit) > 0 and not self.master in allowSubmit.split(","):
1104 die("%s is not in git-p4.allowSubmit" % self.master)
1105
27d2d811 1106 [upstream, settings] = findUpstreamBranchPoint()
ea99c3ae 1107 self.depotPath = settings['depot-paths'][0]
27d2d811
SH
1108 if len(self.origin) == 0:
1109 self.origin = upstream
a3fdd579 1110
3ea2cfd4
LD
1111 if self.preserveUser:
1112 if not self.canChangeChangelists():
1113 die("Cannot preserve user names without p4 super-user or admin permissions")
1114
a3fdd579
SH
1115 if self.verbose:
1116 print "Origin branch is " + self.origin
9512497b 1117
ea99c3ae 1118 if len(self.depotPath) == 0:
9512497b
SH
1119 print "Internal error: cannot locate perforce depot path from existing branches"
1120 sys.exit(128)
1121
ea99c3ae 1122 self.clientPath = p4Where(self.depotPath)
9512497b 1123
51a2640a 1124 if len(self.clientPath) == 0:
ea99c3ae 1125 print "Error: Cannot locate perforce checkout of %s in client view" % self.depotPath
9512497b
SH
1126 sys.exit(128)
1127
ea99c3ae 1128 print "Perforce checkout for depot path %s located at %s" % (self.depotPath, self.clientPath)
7944f142 1129 self.oldWorkingDirectory = os.getcwd()
c1b296b9 1130
0591cfa8
GG
1131 # ensure the clientPath exists
1132 if not os.path.exists(self.clientPath):
1133 os.makedirs(self.clientPath)
1134
053fd0c1 1135 chdir(self.clientPath)
6a01298a 1136 print "Synchronizing p4 checkout..."
6de040df 1137 p4_sync("...")
4f5cf76a 1138 self.check()
4f5cf76a 1139
4c750c0d
SH
1140 commits = []
1141 for line in read_pipe_lines("git rev-list --no-merges %s..%s" % (self.origin, self.master)):
1142 commits.append(line.strip())
1143 commits.reverse()
4f5cf76a 1144
848de9c3
LD
1145 if self.preserveUser or (gitConfig("git-p4.skipUserNameCheck") == "true"):
1146 self.checkAuthorship = False
1147 else:
1148 self.checkAuthorship = True
1149
3ea2cfd4
LD
1150 if self.preserveUser:
1151 self.checkValidP4Users(commits)
1152
4f5cf76a 1153 while len(commits) > 0:
4f5cf76a
SH
1154 commit = commits[0]
1155 commits = commits[1:]
7cb5cbef 1156 self.applyCommit(commit)
4f5cf76a
SH
1157 if not self.interactive:
1158 break
1159
4f5cf76a 1160 if len(commits) == 0:
4c750c0d 1161 print "All changes applied!"
053fd0c1 1162 chdir(self.oldWorkingDirectory)
14594f4b 1163
4c750c0d
SH
1164 sync = P4Sync()
1165 sync.run([])
14594f4b 1166
4c750c0d
SH
1167 rebase = P4Rebase()
1168 rebase.rebase()
4f5cf76a 1169
b984733c
SH
1170 return True
1171
ecb7cf98
PW
1172class View(object):
1173 """Represent a p4 view ("p4 help views"), and map files in a
1174 repo according to the view."""
1175
1176 class Path(object):
1177 """A depot or client path, possibly containing wildcards.
1178 The only one supported is ... at the end, currently.
1179 Initialize with the full path, with //depot or //client."""
1180
1181 def __init__(self, path, is_depot):
1182 self.path = path
1183 self.is_depot = is_depot
1184 self.find_wildcards()
1185 # remember the prefix bit, useful for relative mappings
1186 m = re.match("(//[^/]+/)", self.path)
1187 if not m:
1188 die("Path %s does not start with //prefix/" % self.path)
1189 prefix = m.group(1)
1190 if not self.is_depot:
1191 # strip //client/ on client paths
1192 self.path = self.path[len(prefix):]
1193
1194 def find_wildcards(self):
1195 """Make sure wildcards are valid, and set up internal
1196 variables."""
1197
1198 self.ends_triple_dot = False
1199 # There are three wildcards allowed in p4 views
1200 # (see "p4 help views"). This code knows how to
1201 # handle "..." (only at the end), but cannot deal with
1202 # "%%n" or "*". Only check the depot_side, as p4 should
1203 # validate that the client_side matches too.
1204 if re.search(r'%%[1-9]', self.path):
1205 die("Can't handle %%n wildcards in view: %s" % self.path)
1206 if self.path.find("*") >= 0:
1207 die("Can't handle * wildcards in view: %s" % self.path)
1208 triple_dot_index = self.path.find("...")
1209 if triple_dot_index >= 0:
1210 if not self.path.endswith("..."):
1211 die("Can handle ... wildcard only at end of path: %s" %
1212 self.path)
1213 self.ends_triple_dot = True
1214
1215 def ensure_compatible(self, other_path):
1216 """Make sure the wildcards agree."""
1217 if self.ends_triple_dot != other_path.ends_triple_dot:
1218 die("Both paths must end with ... if either does;\n" +
1219 "paths: %s %s" % (self.path, other_path.path))
1220
1221 def match_wildcards(self, test_path):
1222 """See if this test_path matches us, and fill in the value
1223 of the wildcards if so. Returns a tuple of
1224 (True|False, wildcards[]). For now, only the ... at end
1225 is supported, so at most one wildcard."""
1226 if self.ends_triple_dot:
1227 dotless = self.path[:-3]
1228 if test_path.startswith(dotless):
1229 wildcard = test_path[len(dotless):]
1230 return (True, [ wildcard ])
1231 else:
1232 if test_path == self.path:
1233 return (True, [])
1234 return (False, [])
1235
1236 def match(self, test_path):
1237 """Just return if it matches; don't bother with the wildcards."""
1238 b, _ = self.match_wildcards(test_path)
1239 return b
1240
1241 def fill_in_wildcards(self, wildcards):
1242 """Return the relative path, with the wildcards filled in
1243 if there are any."""
1244 if self.ends_triple_dot:
1245 return self.path[:-3] + wildcards[0]
1246 else:
1247 return self.path
1248
1249 class Mapping(object):
1250 def __init__(self, depot_side, client_side, overlay, exclude):
1251 # depot_side is without the trailing /... if it had one
1252 self.depot_side = View.Path(depot_side, is_depot=True)
1253 self.client_side = View.Path(client_side, is_depot=False)
1254 self.overlay = overlay # started with "+"
1255 self.exclude = exclude # started with "-"
1256 assert not (self.overlay and self.exclude)
1257 self.depot_side.ensure_compatible(self.client_side)
1258
1259 def __str__(self):
1260 c = " "
1261 if self.overlay:
1262 c = "+"
1263 if self.exclude:
1264 c = "-"
1265 return "View.Mapping: %s%s -> %s" % \
1266 (c, self.depot_side, self.client_side)
1267
1268 def map_depot_to_client(self, depot_path):
1269 """Calculate the client path if using this mapping on the
1270 given depot path; does not consider the effect of other
1271 mappings in a view. Even excluded mappings are returned."""
1272 matches, wildcards = self.depot_side.match_wildcards(depot_path)
1273 if not matches:
1274 return ""
1275 client_path = self.client_side.fill_in_wildcards(wildcards)
1276 return client_path
1277
1278 #
1279 # View methods
1280 #
1281 def __init__(self):
1282 self.mappings = []
1283
1284 def append(self, view_line):
1285 """Parse a view line, splitting it into depot and client
1286 sides. Append to self.mappings, preserving order."""
1287
1288 # Split the view line into exactly two words. P4 enforces
1289 # structure on these lines that simplifies this quite a bit.
1290 #
1291 # Either or both words may be double-quoted.
1292 # Single quotes do not matter.
1293 # Double-quote marks cannot occur inside the words.
1294 # A + or - prefix is also inside the quotes.
1295 # There are no quotes unless they contain a space.
1296 # The line is already white-space stripped.
1297 # The two words are separated by a single space.
1298 #
1299 if view_line[0] == '"':
1300 # First word is double quoted. Find its end.
1301 close_quote_index = view_line.find('"', 1)
1302 if close_quote_index <= 0:
1303 die("No first-word closing quote found: %s" % view_line)
1304 depot_side = view_line[1:close_quote_index]
1305 # skip closing quote and space
1306 rhs_index = close_quote_index + 1 + 1
1307 else:
1308 space_index = view_line.find(" ")
1309 if space_index <= 0:
1310 die("No word-splitting space found: %s" % view_line)
1311 depot_side = view_line[0:space_index]
1312 rhs_index = space_index + 1
1313
1314 if view_line[rhs_index] == '"':
1315 # Second word is double quoted. Make sure there is a
1316 # double quote at the end too.
1317 if not view_line.endswith('"'):
1318 die("View line with rhs quote should end with one: %s" %
1319 view_line)
1320 # skip the quotes
1321 client_side = view_line[rhs_index+1:-1]
1322 else:
1323 client_side = view_line[rhs_index:]
1324
1325 # prefix + means overlay on previous mapping
1326 overlay = False
1327 if depot_side.startswith("+"):
1328 overlay = True
1329 depot_side = depot_side[1:]
1330
1331 # prefix - means exclude this path
1332 exclude = False
1333 if depot_side.startswith("-"):
1334 exclude = True
1335 depot_side = depot_side[1:]
1336
1337 m = View.Mapping(depot_side, client_side, overlay, exclude)
1338 self.mappings.append(m)
1339
1340 def map_in_client(self, depot_path):
1341 """Return the relative location in the client where this
1342 depot file should live. Returns "" if the file should
1343 not be mapped in the client."""
1344
1345 paths_filled = []
1346 client_path = ""
1347
1348 # look at later entries first
1349 for m in self.mappings[::-1]:
1350
1351 # see where will this path end up in the client
1352 p = m.map_depot_to_client(depot_path)
1353
1354 if p == "":
1355 # Depot path does not belong in client. Must remember
1356 # this, as previous items should not cause files to
1357 # exist in this path either. Remember that the list is
1358 # being walked from the end, which has higher precedence.
1359 # Overlap mappings do not exclude previous mappings.
1360 if not m.overlay:
1361 paths_filled.append(m.client_side)
1362
1363 else:
1364 # This mapping matched; no need to search any further.
1365 # But, the mapping could be rejected if the client path
1366 # has already been claimed by an earlier mapping.
1367 already_mapped_in_client = False
1368 for f in paths_filled:
1369 # this is View.Path.match
1370 if f.match(p):
1371 already_mapped_in_client = True
1372 break
1373 if not already_mapped_in_client:
1374 # Include this file, unless it is from a line that
1375 # explicitly said to exclude it.
1376 if not m.exclude:
1377 client_path = p
1378
1379 # a match, even if rejected, always stops the search
1380 break
1381
1382 return client_path
1383
3ea2cfd4 1384class P4Sync(Command, P4UserMap):
56c09345
PW
1385 delete_actions = ( "delete", "move/delete", "purge" )
1386
b984733c
SH
1387 def __init__(self):
1388 Command.__init__(self)
3ea2cfd4 1389 P4UserMap.__init__(self)
b984733c
SH
1390 self.options = [
1391 optparse.make_option("--branch", dest="branch"),
1392 optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"),
1393 optparse.make_option("--changesfile", dest="changesFile"),
1394 optparse.make_option("--silent", dest="silent", action="store_true"),
ef48f909 1395 optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),
a028a98e 1396 optparse.make_option("--verbose", dest="verbose", action="store_true"),
d2c6dd30
HWN
1397 optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",
1398 help="Import into refs/heads/ , not refs/remotes"),
8b41a97f 1399 optparse.make_option("--max-changes", dest="maxChanges"),
86dff6b6 1400 optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',
3a70cdfa
TAL
1401 help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),
1402 optparse.make_option("--use-client-spec", dest="useClientSpec", action='store_true',
1403 help="Only sync files that are included in the Perforce Client Spec")
b984733c
SH
1404 ]
1405 self.description = """Imports from Perforce into a git repository.\n
1406 example:
1407 //depot/my/project/ -- to import the current head
1408 //depot/my/project/@all -- to import everything
1409 //depot/my/project/@1,6 -- to import only from revision 1 to 6
1410
1411 (a ... is not needed in the path p4 specification, it's added implicitly)"""
1412
1413 self.usage += " //depot/path[@revRange]"
b984733c 1414 self.silent = False
1d7367dc
RG
1415 self.createdBranches = set()
1416 self.committedChanges = set()
569d1bd4 1417 self.branch = ""
b984733c 1418 self.detectBranches = False
cb53e1f8 1419 self.detectLabels = False
b984733c 1420 self.changesFile = ""
01265103 1421 self.syncWithOrigin = True
4b97ffb1 1422 self.verbose = False
a028a98e 1423 self.importIntoRemotes = True
01a9c9c5 1424 self.maxChanges = ""
c1f9197f 1425 self.isWindows = (platform.system() == "Windows")
8b41a97f 1426 self.keepRepoPath = False
6326aa58 1427 self.depotPaths = None
3c699645 1428 self.p4BranchesInGit = []
354081d5 1429 self.cloneExclude = []
3a70cdfa 1430 self.useClientSpec = False
ecb7cf98 1431 self.clientSpecDirs = None
b984733c 1432
01265103
SH
1433 if gitConfig("git-p4.syncFromOrigin") == "false":
1434 self.syncWithOrigin = False
1435
084f6306
PW
1436 #
1437 # P4 wildcards are not allowed in filenames. P4 complains
1438 # if you simply add them, but you can force it with "-f", in
1439 # which case it translates them into %xx encoding internally.
1440 # Search for and fix just these four characters. Do % last so
1441 # that fixing it does not inadvertently create new %-escapes.
1442 #
1443 def wildcard_decode(self, path):
1444 # Cannot have * in a filename in windows; untested as to
1445 # what p4 would do in such a case.
1446 if not self.isWindows:
1447 path = path.replace("%2A", "*")
1448 path = path.replace("%23", "#") \
1449 .replace("%40", "@") \
1450 .replace("%25", "%")
1451 return path
1452
b984733c 1453 def extractFilesFromCommit(self, commit):
354081d5
TT
1454 self.cloneExclude = [re.sub(r"\.\.\.$", "", path)
1455 for path in self.cloneExclude]
b984733c
SH
1456 files = []
1457 fnum = 0
1458 while commit.has_key("depotFile%s" % fnum):
1459 path = commit["depotFile%s" % fnum]
6326aa58 1460
354081d5 1461 if [p for p in self.cloneExclude
d53de8b9 1462 if p4PathStartsWith(path, p)]:
354081d5
TT
1463 found = False
1464 else:
1465 found = [p for p in self.depotPaths
d53de8b9 1466 if p4PathStartsWith(path, p)]
6326aa58 1467 if not found:
b984733c
SH
1468 fnum = fnum + 1
1469 continue
1470
1471 file = {}
1472 file["path"] = path
1473 file["rev"] = commit["rev%s" % fnum]
1474 file["action"] = commit["action%s" % fnum]
1475 file["type"] = commit["type%s" % fnum]
1476 files.append(file)
1477 fnum = fnum + 1
1478 return files
1479
6326aa58 1480 def stripRepoPath(self, path, prefixes):
3952710b 1481 if self.useClientSpec:
ecb7cf98 1482 return self.clientSpecDirs.map_in_client(path)
3952710b 1483
8b41a97f 1484 if self.keepRepoPath:
6326aa58
HWN
1485 prefixes = [re.sub("^(//[^/]+/).*", r'\1', prefixes[0])]
1486
1487 for p in prefixes:
d53de8b9 1488 if p4PathStartsWith(path, p):
6326aa58 1489 path = path[len(p):]
8b41a97f 1490
6326aa58 1491 return path
6754a299 1492
71b112d4 1493 def splitFilesIntoBranches(self, commit):
d5904674 1494 branches = {}
71b112d4
SH
1495 fnum = 0
1496 while commit.has_key("depotFile%s" % fnum):
1497 path = commit["depotFile%s" % fnum]
6326aa58 1498 found = [p for p in self.depotPaths
d53de8b9 1499 if p4PathStartsWith(path, p)]
6326aa58 1500 if not found:
71b112d4
SH
1501 fnum = fnum + 1
1502 continue
1503
1504 file = {}
1505 file["path"] = path
1506 file["rev"] = commit["rev%s" % fnum]
1507 file["action"] = commit["action%s" % fnum]
1508 file["type"] = commit["type%s" % fnum]
1509 fnum = fnum + 1
1510
6326aa58 1511 relPath = self.stripRepoPath(path, self.depotPaths)
b984733c 1512
4b97ffb1 1513 for branch in self.knownBranches.keys():
6754a299
HWN
1514
1515 # add a trailing slash so that a commit into qt/4.2foo doesn't end up in qt/4.2
1516 if relPath.startswith(branch + "/"):
d5904674
SH
1517 if branch not in branches:
1518 branches[branch] = []
71b112d4 1519 branches[branch].append(file)
6555b2cc 1520 break
b984733c
SH
1521
1522 return branches
1523
b932705b
LD
1524 # output one file from the P4 stream
1525 # - helper for streamP4Files
1526
1527 def streamOneP4File(self, file, contents):
b932705b 1528 relPath = self.stripRepoPath(file['depotFile'], self.branchPrefixes)
084f6306 1529 relPath = self.wildcard_decode(relPath)
b932705b
LD
1530 if verbose:
1531 sys.stderr.write("%s\n" % relPath)
1532
9cffb8c8
PW
1533 (type_base, type_mods) = split_p4_type(file["type"])
1534
1535 git_mode = "100644"
1536 if "x" in type_mods:
1537 git_mode = "100755"
1538 if type_base == "symlink":
1539 git_mode = "120000"
1540 # p4 print on a symlink contains "target\n"; remove the newline
b39c3612
EP
1541 data = ''.join(contents)
1542 contents = [data[:-1]]
b932705b 1543
9cffb8c8 1544 if type_base == "utf16":
55aa5714
PW
1545 # p4 delivers different text in the python output to -G
1546 # than it does when using "print -o", or normal p4 client
1547 # operations. utf16 is converted to ascii or utf8, perhaps.
1548 # But ascii text saved as -t utf16 is completely mangled.
1549 # Invoke print -o to get the real contents.
6de040df 1550 text = p4_read_pipe(['print', '-q', '-o', '-', file['depotFile']])
55aa5714
PW
1551 contents = [ text ]
1552
9f7ef0ea
PW
1553 if type_base == "apple":
1554 # Apple filetype files will be streamed as a concatenation of
1555 # its appledouble header and the contents. This is useless
1556 # on both macs and non-macs. If using "print -q -o xx", it
1557 # will create "xx" with the data, and "%xx" with the header.
1558 # This is also not very useful.
1559 #
1560 # Ideally, someday, this script can learn how to generate
1561 # appledouble files directly and import those to git, but
1562 # non-mac machines can never find a use for apple filetype.
1563 print "\nIgnoring apple filetype file %s" % file['depotFile']
1564 return
1565
9cffb8c8
PW
1566 # Perhaps windows wants unicode, utf16 newlines translated too;
1567 # but this is not doing it.
1568 if self.isWindows and type_base == "text":
b932705b
LD
1569 mangled = []
1570 for data in contents:
1571 data = data.replace("\r\n", "\n")
1572 mangled.append(data)
1573 contents = mangled
1574
55aa5714
PW
1575 # Note that we do not try to de-mangle keywords on utf16 files,
1576 # even though in theory somebody may want that.
9cffb8c8
PW
1577 if type_base in ("text", "unicode", "binary"):
1578 if "ko" in type_mods:
cb585a9c
PW
1579 text = ''.join(contents)
1580 text = re.sub(r'\$(Id|Header):[^$]*\$', r'$\1$', text)
1581 contents = [ text ]
9cffb8c8 1582 elif "k" in type_mods:
cb585a9c
PW
1583 text = ''.join(contents)
1584 text = re.sub(r'\$(Id|Header|Author|Date|DateTime|Change|File|Revision):[^$]*\$', r'$\1$', text)
1585 contents = [ text ]
b932705b 1586
9cffb8c8 1587 self.gitStream.write("M %s inline %s\n" % (git_mode, relPath))
b932705b
LD
1588
1589 # total length...
1590 length = 0
1591 for d in contents:
1592 length = length + len(d)
1593
1594 self.gitStream.write("data %d\n" % length)
1595 for d in contents:
1596 self.gitStream.write(d)
1597 self.gitStream.write("\n")
1598
1599 def streamOneP4Deletion(self, file):
1600 relPath = self.stripRepoPath(file['path'], self.branchPrefixes)
1601 if verbose:
1602 sys.stderr.write("delete %s\n" % relPath)
1603 self.gitStream.write("D %s\n" % relPath)
1604
1605 # handle another chunk of streaming data
1606 def streamP4FilesCb(self, marshalled):
1607
c3f6163b
AG
1608 if marshalled.has_key('depotFile') and self.stream_have_file_info:
1609 # start of a new file - output the old one first
1610 self.streamOneP4File(self.stream_file, self.stream_contents)
1611 self.stream_file = {}
1612 self.stream_contents = []
1613 self.stream_have_file_info = False
b932705b 1614
c3f6163b
AG
1615 # pick up the new file information... for the
1616 # 'data' field we need to append to our array
1617 for k in marshalled.keys():
1618 if k == 'data':
1619 self.stream_contents.append(marshalled['data'])
1620 else:
1621 self.stream_file[k] = marshalled[k]
b932705b 1622
c3f6163b 1623 self.stream_have_file_info = True
b932705b
LD
1624
1625 # Stream directly from "p4 files" into "git fast-import"
1626 def streamP4Files(self, files):
30b5940b
SH
1627 filesForCommit = []
1628 filesToRead = []
b932705b 1629 filesToDelete = []
30b5940b 1630
3a70cdfa 1631 for f in files:
ecb7cf98
PW
1632 # if using a client spec, only add the files that have
1633 # a path in the client
1634 if self.clientSpecDirs:
1635 if self.clientSpecDirs.map_in_client(f['path']) == "":
1636 continue
3a70cdfa 1637
ecb7cf98
PW
1638 filesForCommit.append(f)
1639 if f['action'] in self.delete_actions:
1640 filesToDelete.append(f)
1641 else:
1642 filesToRead.append(f)
6a49f8e2 1643
b932705b
LD
1644 # deleted files...
1645 for f in filesToDelete:
1646 self.streamOneP4Deletion(f)
1b9a4684 1647
b932705b
LD
1648 if len(filesToRead) > 0:
1649 self.stream_file = {}
1650 self.stream_contents = []
1651 self.stream_have_file_info = False
8ff45f2a 1652
c3f6163b
AG
1653 # curry self argument
1654 def streamP4FilesCbSelf(entry):
1655 self.streamP4FilesCb(entry)
6a49f8e2 1656
6de040df
LD
1657 fileArgs = ['%s#%s' % (f['path'], f['rev']) for f in filesToRead]
1658
1659 p4CmdList(["-x", "-", "print"],
1660 stdin=fileArgs,
1661 cb=streamP4FilesCbSelf)
30b5940b 1662
b932705b
LD
1663 # do the last chunk
1664 if self.stream_file.has_key('depotFile'):
1665 self.streamOneP4File(self.stream_file, self.stream_contents)
6a49f8e2 1666
6326aa58 1667 def commit(self, details, files, branch, branchPrefixes, parent = ""):
b984733c
SH
1668 epoch = details["time"]
1669 author = details["user"]
c3f6163b 1670 self.branchPrefixes = branchPrefixes
b984733c 1671
4b97ffb1
SH
1672 if self.verbose:
1673 print "commit into %s" % branch
1674
96e07dd2
HWN
1675 # start with reading files; if that fails, we should not
1676 # create a commit.
1677 new_files = []
1678 for f in files:
d53de8b9 1679 if [p for p in branchPrefixes if p4PathStartsWith(f['path'], p)]:
96e07dd2
HWN
1680 new_files.append (f)
1681 else:
afa1dd9a 1682 sys.stderr.write("Ignoring file outside of prefix: %s\n" % f['path'])
96e07dd2 1683
b984733c 1684 self.gitStream.write("commit %s\n" % branch)
6a49f8e2 1685# gitStream.write("mark :%s\n" % details["change"])
b984733c
SH
1686 self.committedChanges.add(int(details["change"]))
1687 committer = ""
b607e71e
SH
1688 if author not in self.users:
1689 self.getUserMapFromPerforceServer()
b984733c 1690 if author in self.users:
0828ab14 1691 committer = "%s %s %s" % (self.users[author], epoch, self.tz)
b984733c 1692 else:
0828ab14 1693 committer = "%s <a@b> %s %s" % (author, epoch, self.tz)
b984733c
SH
1694
1695 self.gitStream.write("committer %s\n" % committer)
1696
1697 self.gitStream.write("data <<EOT\n")
1698 self.gitStream.write(details["desc"])
6581de09
SH
1699 self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s"
1700 % (','.join (branchPrefixes), details["change"]))
1701 if len(details['options']) > 0:
1702 self.gitStream.write(": options = %s" % details['options'])
1703 self.gitStream.write("]\nEOT\n\n")
b984733c
SH
1704
1705 if len(parent) > 0:
4b97ffb1
SH
1706 if self.verbose:
1707 print "parent %s" % parent
b984733c
SH
1708 self.gitStream.write("from %s\n" % parent)
1709
b932705b 1710 self.streamP4Files(new_files)
b984733c
SH
1711 self.gitStream.write("\n")
1712
1f4ba1cb
SH
1713 change = int(details["change"])
1714
9bda3a85 1715 if self.labels.has_key(change):
1f4ba1cb
SH
1716 label = self.labels[change]
1717 labelDetails = label[0]
1718 labelRevisions = label[1]
71b112d4
SH
1719 if self.verbose:
1720 print "Change %s is labelled %s" % (change, labelDetails)
1f4ba1cb 1721
6de040df
LD
1722 files = p4CmdList(["files"] + ["%s...@%s" % (p, change)
1723 for p in branchPrefixes])
1f4ba1cb
SH
1724
1725 if len(files) == len(labelRevisions):
1726
1727 cleanedFiles = {}
1728 for info in files:
56c09345 1729 if info["action"] in self.delete_actions:
1f4ba1cb
SH
1730 continue
1731 cleanedFiles[info["depotFile"]] = info["rev"]
1732
1733 if cleanedFiles == labelRevisions:
1734 self.gitStream.write("tag tag_%s\n" % labelDetails["label"])
1735 self.gitStream.write("from %s\n" % branch)
1736
1737 owner = labelDetails["Owner"]
1738 tagger = ""
1739 if author in self.users:
1740 tagger = "%s %s %s" % (self.users[owner], epoch, self.tz)
1741 else:
1742 tagger = "%s <a@b> %s %s" % (owner, epoch, self.tz)
1743 self.gitStream.write("tagger %s\n" % tagger)
a37a8de8
LD
1744
1745 description = labelDetails["Description"]
1746 self.gitStream.write("data %d\n" % len(description))
1747 self.gitStream.write(description)
1748 self.gitStream.write("\n")
1f4ba1cb
SH
1749
1750 else:
a46668fa 1751 if not self.silent:
cebdf5af
HWN
1752 print ("Tag %s does not match with change %s: files do not match."
1753 % (labelDetails["label"], change))
1f4ba1cb
SH
1754
1755 else:
a46668fa 1756 if not self.silent:
cebdf5af
HWN
1757 print ("Tag %s does not match with change %s: file count is different."
1758 % (labelDetails["label"], change))
b984733c 1759
1f4ba1cb
SH
1760 def getLabels(self):
1761 self.labels = {}
1762
52a4880b 1763 l = p4CmdList(["labels"] + ["%s..." % p for p in self.depotPaths])
10c3211b 1764 if len(l) > 0 and not self.silent:
183f8436 1765 print "Finding files belonging to labels in %s" % `self.depotPaths`
01ce1fe9
SH
1766
1767 for output in l:
1f4ba1cb
SH
1768 label = output["label"]
1769 revisions = {}
1770 newestChange = 0
71b112d4
SH
1771 if self.verbose:
1772 print "Querying files for label %s" % label
6de040df
LD
1773 for file in p4CmdList(["files"] +
1774 ["%s...@%s" % (p, label)
1775 for p in self.depotPaths]):
1f4ba1cb
SH
1776 revisions[file["depotFile"]] = file["rev"]
1777 change = int(file["change"])
1778 if change > newestChange:
1779 newestChange = change
1780
9bda3a85
SH
1781 self.labels[newestChange] = [output, revisions]
1782
1783 if self.verbose:
1784 print "Label changes: %s" % self.labels.keys()
1f4ba1cb 1785
86dff6b6
HWN
1786 def guessProjectName(self):
1787 for p in self.depotPaths:
6e5295c4
SH
1788 if p.endswith("/"):
1789 p = p[:-1]
1790 p = p[p.strip().rfind("/") + 1:]
1791 if not p.endswith("/"):
1792 p += "/"
1793 return p
86dff6b6 1794
4b97ffb1 1795 def getBranchMapping(self):
6555b2cc
SH
1796 lostAndFoundBranches = set()
1797
8ace74c0
VA
1798 user = gitConfig("git-p4.branchUser")
1799 if len(user) > 0:
1800 command = "branches -u %s" % user
1801 else:
1802 command = "branches"
1803
1804 for info in p4CmdList(command):
52a4880b 1805 details = p4Cmd(["branch", "-o", info["branch"]])
4b97ffb1
SH
1806 viewIdx = 0
1807 while details.has_key("View%s" % viewIdx):
1808 paths = details["View%s" % viewIdx].split(" ")
1809 viewIdx = viewIdx + 1
1810 # require standard //depot/foo/... //depot/bar/... mapping
1811 if len(paths) != 2 or not paths[0].endswith("/...") or not paths[1].endswith("/..."):
1812 continue
1813 source = paths[0]
1814 destination = paths[1]
6509e19c 1815 ## HACK
d53de8b9 1816 if p4PathStartsWith(source, self.depotPaths[0]) and p4PathStartsWith(destination, self.depotPaths[0]):
6509e19c
SH
1817 source = source[len(self.depotPaths[0]):-4]
1818 destination = destination[len(self.depotPaths[0]):-4]
6555b2cc 1819
1a2edf4e
SH
1820 if destination in self.knownBranches:
1821 if not self.silent:
1822 print "p4 branch %s defines a mapping from %s to %s" % (info["branch"], source, destination)
1823 print "but there exists another mapping from %s to %s already!" % (self.knownBranches[destination], destination)
1824 continue
1825
6555b2cc
SH
1826 self.knownBranches[destination] = source
1827
1828 lostAndFoundBranches.discard(destination)
1829
29bdbac1 1830 if source not in self.knownBranches:
6555b2cc
SH
1831 lostAndFoundBranches.add(source)
1832
7199cf13
VA
1833 # Perforce does not strictly require branches to be defined, so we also
1834 # check git config for a branch list.
1835 #
1836 # Example of branch definition in git config file:
1837 # [git-p4]
1838 # branchList=main:branchA
1839 # branchList=main:branchB
1840 # branchList=branchA:branchC
1841 configBranches = gitConfigList("git-p4.branchList")
1842 for branch in configBranches:
1843 if branch:
1844 (source, destination) = branch.split(":")
1845 self.knownBranches[destination] = source
1846
1847 lostAndFoundBranches.discard(destination)
1848
1849 if source not in self.knownBranches:
1850 lostAndFoundBranches.add(source)
1851
6555b2cc
SH
1852
1853 for branch in lostAndFoundBranches:
1854 self.knownBranches[branch] = branch
29bdbac1 1855
38f9f5ec
SH
1856 def getBranchMappingFromGitBranches(self):
1857 branches = p4BranchesInGit(self.importIntoRemotes)
1858 for branch in branches.keys():
1859 if branch == "master":
1860 branch = "main"
1861 else:
1862 branch = branch[len(self.projectName):]
1863 self.knownBranches[branch] = branch
1864
29bdbac1 1865 def listExistingP4GitBranches(self):
144ff46b
SH
1866 # branches holds mapping from name to commit
1867 branches = p4BranchesInGit(self.importIntoRemotes)
1868 self.p4BranchesInGit = branches.keys()
1869 for branch in branches.keys():
1870 self.initialParents[self.refPrefix + branch] = branches[branch]
4b97ffb1 1871
bb6e09b2
HWN
1872 def updateOptionDict(self, d):
1873 option_keys = {}
1874 if self.keepRepoPath:
1875 option_keys['keepRepoPath'] = 1
1876
1877 d["options"] = ' '.join(sorted(option_keys.keys()))
1878
1879 def readOptions(self, d):
1880 self.keepRepoPath = (d.has_key('options')
1881 and ('keepRepoPath' in d['options']))
6326aa58 1882
8134f69c
SH
1883 def gitRefForBranch(self, branch):
1884 if branch == "main":
1885 return self.refPrefix + "master"
1886
1887 if len(branch) <= 0:
1888 return branch
1889
1890 return self.refPrefix + self.projectName + branch
1891
1ca3d710
SH
1892 def gitCommitByP4Change(self, ref, change):
1893 if self.verbose:
1894 print "looking in ref " + ref + " for change %s using bisect..." % change
1895
1896 earliestCommit = ""
1897 latestCommit = parseRevision(ref)
1898
1899 while True:
1900 if self.verbose:
1901 print "trying: earliest %s latest %s" % (earliestCommit, latestCommit)
1902 next = read_pipe("git rev-list --bisect %s %s" % (latestCommit, earliestCommit)).strip()
1903 if len(next) == 0:
1904 if self.verbose:
1905 print "argh"
1906 return ""
1907 log = extractLogMessageFromGitCommit(next)
1908 settings = extractSettingsGitLog(log)
1909 currentChange = int(settings['change'])
1910 if self.verbose:
1911 print "current change %s" % currentChange
1912
1913 if currentChange == change:
1914 if self.verbose:
1915 print "found %s" % next
1916 return next
1917
1918 if currentChange < change:
1919 earliestCommit = "^%s" % next
1920 else:
1921 latestCommit = "%s" % next
1922
1923 return ""
1924
1925 def importNewBranch(self, branch, maxChange):
1926 # make fast-import flush all changes to disk and update the refs using the checkpoint
1927 # command so that we can try to find the branch parent in the git history
1928 self.gitStream.write("checkpoint\n\n");
1929 self.gitStream.flush();
1930 branchPrefix = self.depotPaths[0] + branch + "/"
1931 range = "@1,%s" % maxChange
1932 #print "prefix" + branchPrefix
1933 changes = p4ChangesForPaths([branchPrefix], range)
1934 if len(changes) <= 0:
1935 return False
1936 firstChange = changes[0]
1937 #print "first change in branch: %s" % firstChange
1938 sourceBranch = self.knownBranches[branch]
1939 sourceDepotPath = self.depotPaths[0] + sourceBranch
1940 sourceRef = self.gitRefForBranch(sourceBranch)
1941 #print "source " + sourceBranch
1942
52a4880b 1943 branchParentChange = int(p4Cmd(["changes", "-m", "1", "%s...@1,%s" % (sourceDepotPath, firstChange)])["change"])
1ca3d710
SH
1944 #print "branch parent: %s" % branchParentChange
1945 gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)
1946 if len(gitParent) > 0:
1947 self.initialParents[self.gitRefForBranch(branch)] = gitParent
1948 #print "parent git commit: %s" % gitParent
1949
1950 self.importChanges(changes)
1951 return True
1952
e87f37ae
SH
1953 def importChanges(self, changes):
1954 cnt = 1
1955 for change in changes:
1956 description = p4Cmd("describe %s" % change)
1957 self.updateOptionDict(description)
1958
1959 if not self.silent:
1960 sys.stdout.write("\rImporting revision %s (%s%%)" % (change, cnt * 100 / len(changes)))
1961 sys.stdout.flush()
1962 cnt = cnt + 1
1963
1964 try:
1965 if self.detectBranches:
1966 branches = self.splitFilesIntoBranches(description)
1967 for branch in branches.keys():
1968 ## HACK --hwn
1969 branchPrefix = self.depotPaths[0] + branch + "/"
1970
1971 parent = ""
1972
1973 filesForCommit = branches[branch]
1974
1975 if self.verbose:
1976 print "branch is %s" % branch
1977
1978 self.updatedBranches.add(branch)
1979
1980 if branch not in self.createdBranches:
1981 self.createdBranches.add(branch)
1982 parent = self.knownBranches[branch]
1983 if parent == branch:
1984 parent = ""
1ca3d710
SH
1985 else:
1986 fullBranch = self.projectName + branch
1987 if fullBranch not in self.p4BranchesInGit:
1988 if not self.silent:
1989 print("\n Importing new branch %s" % fullBranch);
1990 if self.importNewBranch(branch, change - 1):
1991 parent = ""
1992 self.p4BranchesInGit.append(fullBranch)
1993 if not self.silent:
1994 print("\n Resuming with change %s" % change);
1995
1996 if self.verbose:
1997 print "parent determined through known branches: %s" % parent
e87f37ae 1998
8134f69c
SH
1999 branch = self.gitRefForBranch(branch)
2000 parent = self.gitRefForBranch(parent)
e87f37ae
SH
2001
2002 if self.verbose:
2003 print "looking for initial parent for %s; current parent is %s" % (branch, parent)
2004
2005 if len(parent) == 0 and branch in self.initialParents:
2006 parent = self.initialParents[branch]
2007 del self.initialParents[branch]
2008
2009 self.commit(description, filesForCommit, branch, [branchPrefix], parent)
2010 else:
2011 files = self.extractFilesFromCommit(description)
2012 self.commit(description, files, self.branch, self.depotPaths,
2013 self.initialParent)
2014 self.initialParent = ""
2015 except IOError:
2016 print self.gitError.read()
2017 sys.exit(1)
2018
c208a243
SH
2019 def importHeadRevision(self, revision):
2020 print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), revision, self.branch)
2021
4e2e6ce4
PW
2022 details = {}
2023 details["user"] = "git perforce import user"
1494fcbb 2024 details["desc"] = ("Initial import of %s from the state at revision %s\n"
c208a243
SH
2025 % (' '.join(self.depotPaths), revision))
2026 details["change"] = revision
2027 newestRevision = 0
2028
2029 fileCnt = 0
6de040df
LD
2030 fileArgs = ["%s...%s" % (p,revision) for p in self.depotPaths]
2031
2032 for info in p4CmdList(["files"] + fileArgs):
c208a243 2033
68b28593 2034 if 'code' in info and info['code'] == 'error':
c208a243
SH
2035 sys.stderr.write("p4 returned an error: %s\n"
2036 % info['data'])
d88e707f
PW
2037 if info['data'].find("must refer to client") >= 0:
2038 sys.stderr.write("This particular p4 error is misleading.\n")
2039 sys.stderr.write("Perhaps the depot path was misspelled.\n");
2040 sys.stderr.write("Depot path: %s\n" % " ".join(self.depotPaths))
c208a243 2041 sys.exit(1)
68b28593
PW
2042 if 'p4ExitCode' in info:
2043 sys.stderr.write("p4 exitcode: %s\n" % info['p4ExitCode'])
c208a243
SH
2044 sys.exit(1)
2045
2046
2047 change = int(info["change"])
2048 if change > newestRevision:
2049 newestRevision = change
2050
56c09345 2051 if info["action"] in self.delete_actions:
c208a243
SH
2052 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
2053 #fileCnt = fileCnt + 1
2054 continue
2055
2056 for prop in ["depotFile", "rev", "action", "type" ]:
2057 details["%s%s" % (prop, fileCnt)] = info[prop]
2058
2059 fileCnt = fileCnt + 1
2060
2061 details["change"] = newestRevision
4e2e6ce4
PW
2062
2063 # Use time from top-most change so that all git-p4 clones of
2064 # the same p4 repo have the same commit SHA1s.
2065 res = p4CmdList("describe -s %d" % newestRevision)
2066 newestTime = None
2067 for r in res:
2068 if r.has_key('time'):
2069 newestTime = int(r['time'])
2070 if newestTime is None:
2071 die("\"describe -s\" on newest change %d did not give a time")
2072 details["time"] = newestTime
2073
c208a243
SH
2074 self.updateOptionDict(details)
2075 try:
2076 self.commit(details, self.extractFilesFromCommit(details), self.branch, self.depotPaths)
2077 except IOError:
2078 print "IO error with git fast-import. Is your git version recent enough?"
2079 print self.gitError.read()
2080
2081
3a70cdfa 2082 def getClientSpec(self):
ecb7cf98
PW
2083 specList = p4CmdList("client -o")
2084 if len(specList) != 1:
2085 die('Output from "client -o" is %d lines, expecting 1' %
2086 len(specList))
2087
2088 # dictionary of all client parameters
2089 entry = specList[0]
2090
2091 # just the keys that start with "View"
2092 view_keys = [ k for k in entry.keys() if k.startswith("View") ]
2093
2094 # hold this new View
2095 view = View()
3952710b 2096
ecb7cf98
PW
2097 # append the lines, in order, to the view
2098 for view_num in range(len(view_keys)):
2099 k = "View%d" % view_num
2100 if k not in view_keys:
2101 die("Expected view key %s missing" % k)
2102 view.append(entry[k])
3952710b 2103
ecb7cf98 2104 self.clientSpecDirs = view
df5ed907 2105 if self.verbose:
ecb7cf98
PW
2106 for i, m in enumerate(self.clientSpecDirs.mappings):
2107 print "clientSpecDirs %d: %s" % (i, str(m))
3a70cdfa 2108
b984733c 2109 def run(self, args):
6326aa58 2110 self.depotPaths = []
179caebf
SH
2111 self.changeRange = ""
2112 self.initialParent = ""
6326aa58 2113 self.previousDepotPaths = []
ce6f33c8 2114
29bdbac1
SH
2115 # map from branch depot path to parent branch
2116 self.knownBranches = {}
2117 self.initialParents = {}
5ca44617 2118 self.hasOrigin = originP4BranchesExist()
a43ff00c
SH
2119 if not self.syncWithOrigin:
2120 self.hasOrigin = False
29bdbac1 2121
a028a98e
SH
2122 if self.importIntoRemotes:
2123 self.refPrefix = "refs/remotes/p4/"
2124 else:
db775559 2125 self.refPrefix = "refs/heads/p4/"
a028a98e 2126
cebdf5af
HWN
2127 if self.syncWithOrigin and self.hasOrigin:
2128 if not self.silent:
2129 print "Syncing with origin first by calling git fetch origin"
2130 system("git fetch origin")
10f880f8 2131
569d1bd4 2132 if len(self.branch) == 0:
db775559 2133 self.branch = self.refPrefix + "master"
a028a98e 2134 if gitBranchExists("refs/heads/p4") and self.importIntoRemotes:
48df6fd8 2135 system("git update-ref %s refs/heads/p4" % self.branch)
48df6fd8 2136 system("git branch -D p4");
faf1bd20 2137 # create it /after/ importing, when master exists
0058a33a 2138 if not gitBranchExists(self.refPrefix + "HEAD") and self.importIntoRemotes and gitBranchExists(self.branch):
a3c55c09 2139 system("git symbolic-ref %sHEAD %s" % (self.refPrefix, self.branch))
967f72e2 2140
09fca77b
PW
2141 if not self.useClientSpec:
2142 if gitConfig("git-p4.useclientspec", "--bool") == "true":
2143 self.useClientSpec = True
2144 if self.useClientSpec:
3a70cdfa
TAL
2145 self.getClientSpec()
2146
6a49f8e2
HWN
2147 # TODO: should always look at previous commits,
2148 # merge with previous imports, if possible.
2149 if args == []:
d414c74a 2150 if self.hasOrigin:
5ca44617 2151 createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)
abcd790f
SH
2152 self.listExistingP4GitBranches()
2153
2154 if len(self.p4BranchesInGit) > 1:
2155 if not self.silent:
2156 print "Importing from/into multiple branches"
2157 self.detectBranches = True
967f72e2 2158
29bdbac1
SH
2159 if self.verbose:
2160 print "branches: %s" % self.p4BranchesInGit
2161
2162 p4Change = 0
2163 for branch in self.p4BranchesInGit:
cebdf5af 2164 logMsg = extractLogMessageFromGitCommit(self.refPrefix + branch)
bb6e09b2
HWN
2165
2166 settings = extractSettingsGitLog(logMsg)
29bdbac1 2167
bb6e09b2
HWN
2168 self.readOptions(settings)
2169 if (settings.has_key('depot-paths')
2170 and settings.has_key ('change')):
2171 change = int(settings['change']) + 1
29bdbac1
SH
2172 p4Change = max(p4Change, change)
2173
bb6e09b2
HWN
2174 depotPaths = sorted(settings['depot-paths'])
2175 if self.previousDepotPaths == []:
6326aa58 2176 self.previousDepotPaths = depotPaths
29bdbac1 2177 else:
6326aa58
HWN
2178 paths = []
2179 for (prev, cur) in zip(self.previousDepotPaths, depotPaths):
04d277b3
VA
2180 prev_list = prev.split("/")
2181 cur_list = cur.split("/")
2182 for i in range(0, min(len(cur_list), len(prev_list))):
2183 if cur_list[i] <> prev_list[i]:
583e1707 2184 i = i - 1
6326aa58
HWN
2185 break
2186
04d277b3 2187 paths.append ("/".join(cur_list[:i + 1]))
6326aa58
HWN
2188
2189 self.previousDepotPaths = paths
29bdbac1
SH
2190
2191 if p4Change > 0:
bb6e09b2 2192 self.depotPaths = sorted(self.previousDepotPaths)
d5904674 2193 self.changeRange = "@%s,#head" % p4Change
330f53b8
SH
2194 if not self.detectBranches:
2195 self.initialParent = parseRevision(self.branch)
341dc1c1 2196 if not self.silent and not self.detectBranches:
967f72e2 2197 print "Performing incremental import into %s git branch" % self.branch
569d1bd4 2198
f9162f6a
SH
2199 if not self.branch.startswith("refs/"):
2200 self.branch = "refs/heads/" + self.branch
179caebf 2201
6326aa58 2202 if len(args) == 0 and self.depotPaths:
b984733c 2203 if not self.silent:
6326aa58 2204 print "Depot paths: %s" % ' '.join(self.depotPaths)
b984733c 2205 else:
6326aa58 2206 if self.depotPaths and self.depotPaths != args:
cebdf5af 2207 print ("previous import used depot path %s and now %s was specified. "
6326aa58
HWN
2208 "This doesn't work!" % (' '.join (self.depotPaths),
2209 ' '.join (args)))
b984733c 2210 sys.exit(1)
6326aa58 2211
bb6e09b2 2212 self.depotPaths = sorted(args)
b984733c 2213
1c49fc19 2214 revision = ""
b984733c 2215 self.users = {}
b984733c 2216
58c8bc7c
PW
2217 # Make sure no revision specifiers are used when --changesfile
2218 # is specified.
2219 bad_changesfile = False
2220 if len(self.changesFile) > 0:
2221 for p in self.depotPaths:
2222 if p.find("@") >= 0 or p.find("#") >= 0:
2223 bad_changesfile = True
2224 break
2225 if bad_changesfile:
2226 die("Option --changesfile is incompatible with revision specifiers")
2227
6326aa58
HWN
2228 newPaths = []
2229 for p in self.depotPaths:
2230 if p.find("@") != -1:
2231 atIdx = p.index("@")
2232 self.changeRange = p[atIdx:]
2233 if self.changeRange == "@all":
2234 self.changeRange = ""
6a49f8e2 2235 elif ',' not in self.changeRange:
1c49fc19 2236 revision = self.changeRange
6326aa58 2237 self.changeRange = ""
7fcff9de 2238 p = p[:atIdx]
6326aa58
HWN
2239 elif p.find("#") != -1:
2240 hashIdx = p.index("#")
1c49fc19 2241 revision = p[hashIdx:]
7fcff9de 2242 p = p[:hashIdx]
6326aa58 2243 elif self.previousDepotPaths == []:
58c8bc7c
PW
2244 # pay attention to changesfile, if given, else import
2245 # the entire p4 tree at the head revision
2246 if len(self.changesFile) == 0:
2247 revision = "#head"
6326aa58
HWN
2248
2249 p = re.sub ("\.\.\.$", "", p)
2250 if not p.endswith("/"):
2251 p += "/"
2252
2253 newPaths.append(p)
2254
2255 self.depotPaths = newPaths
2256
b984733c 2257
b607e71e 2258 self.loadUserMapFromCache()
cb53e1f8
SH
2259 self.labels = {}
2260 if self.detectLabels:
2261 self.getLabels();
b984733c 2262
4b97ffb1 2263 if self.detectBranches:
df450923
SH
2264 ## FIXME - what's a P4 projectName ?
2265 self.projectName = self.guessProjectName()
2266
38f9f5ec
SH
2267 if self.hasOrigin:
2268 self.getBranchMappingFromGitBranches()
2269 else:
2270 self.getBranchMapping()
29bdbac1
SH
2271 if self.verbose:
2272 print "p4-git branches: %s" % self.p4BranchesInGit
2273 print "initial parents: %s" % self.initialParents
2274 for b in self.p4BranchesInGit:
2275 if b != "master":
6326aa58
HWN
2276
2277 ## FIXME
29bdbac1
SH
2278 b = b[len(self.projectName):]
2279 self.createdBranches.add(b)
4b97ffb1 2280
f291b4e3 2281 self.tz = "%+03d%02d" % (- time.timezone / 3600, ((- time.timezone % 3600) / 60))
b984733c 2282
cebdf5af 2283 importProcess = subprocess.Popen(["git", "fast-import"],
6326aa58
HWN
2284 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
2285 stderr=subprocess.PIPE);
08483580
SH
2286 self.gitOutput = importProcess.stdout
2287 self.gitStream = importProcess.stdin
2288 self.gitError = importProcess.stderr
b984733c 2289
1c49fc19 2290 if revision:
c208a243 2291 self.importHeadRevision(revision)
b984733c
SH
2292 else:
2293 changes = []
2294
0828ab14 2295 if len(self.changesFile) > 0:
b984733c 2296 output = open(self.changesFile).readlines()
1d7367dc 2297 changeSet = set()
b984733c
SH
2298 for line in output:
2299 changeSet.add(int(line))
2300
2301 for change in changeSet:
2302 changes.append(change)
2303
2304 changes.sort()
2305 else:
accad8e0
PW
2306 # catch "git-p4 sync" with no new branches, in a repo that
2307 # does not have any existing git-p4 branches
2308 if len(args) == 0 and not self.p4BranchesInGit:
e32e00dc 2309 die("No remote p4 branches. Perhaps you never did \"git p4 clone\" in here.");
29bdbac1 2310 if self.verbose:
86dff6b6 2311 print "Getting p4 changes for %s...%s" % (', '.join(self.depotPaths),
6326aa58 2312 self.changeRange)
4f6432d8 2313 changes = p4ChangesForPaths(self.depotPaths, self.changeRange)
b984733c 2314
01a9c9c5 2315 if len(self.maxChanges) > 0:
7fcff9de 2316 changes = changes[:min(int(self.maxChanges), len(changes))]
01a9c9c5 2317
b984733c 2318 if len(changes) == 0:
0828ab14 2319 if not self.silent:
341dc1c1 2320 print "No changes to import!"
1f52af6c 2321 return True
b984733c 2322
a9d1a27a
SH
2323 if not self.silent and not self.detectBranches:
2324 print "Import destination: %s" % self.branch
2325
341dc1c1
SH
2326 self.updatedBranches = set()
2327
e87f37ae 2328 self.importChanges(changes)
b984733c 2329
341dc1c1
SH
2330 if not self.silent:
2331 print ""
2332 if len(self.updatedBranches) > 0:
2333 sys.stdout.write("Updated branches: ")
2334 for b in self.updatedBranches:
2335 sys.stdout.write("%s " % b)
2336 sys.stdout.write("\n")
b984733c 2337
b984733c 2338 self.gitStream.close()
29bdbac1
SH
2339 if importProcess.wait() != 0:
2340 die("fast-import failed: %s" % self.gitError.read())
b984733c
SH
2341 self.gitOutput.close()
2342 self.gitError.close()
2343
b984733c
SH
2344 return True
2345
01ce1fe9
SH
2346class P4Rebase(Command):
2347 def __init__(self):
2348 Command.__init__(self)
01265103 2349 self.options = [ ]
cebdf5af
HWN
2350 self.description = ("Fetches the latest revision from perforce and "
2351 + "rebases the current work (branch) against it")
68c42153 2352 self.verbose = False
01ce1fe9
SH
2353
2354 def run(self, args):
2355 sync = P4Sync()
2356 sync.run([])
d7e3868c 2357
14594f4b
SH
2358 return self.rebase()
2359
2360 def rebase(self):
36ee4ee4
SH
2361 if os.system("git update-index --refresh") != 0:
2362 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.");
2363 if len(read_pipe("git diff-index HEAD --")) > 0:
2364 die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
2365
d7e3868c
SH
2366 [upstream, settings] = findUpstreamBranchPoint()
2367 if len(upstream) == 0:
2368 die("Cannot find upstream branchpoint for rebase")
2369
2370 # the branchpoint may be p4/foo~3, so strip off the parent
2371 upstream = re.sub("~[0-9]+$", "", upstream)
2372
2373 print "Rebasing the current branch onto %s" % upstream
b25b2065 2374 oldHead = read_pipe("git rev-parse HEAD").strip()
d7e3868c 2375 system("git rebase %s" % upstream)
1f52af6c 2376 system("git diff-tree --stat --summary -M %s HEAD" % oldHead)
01ce1fe9
SH
2377 return True
2378
f9a3a4f7
SH
2379class P4Clone(P4Sync):
2380 def __init__(self):
2381 P4Sync.__init__(self)
2382 self.description = "Creates a new git repository and imports from Perforce into it"
bb6e09b2 2383 self.usage = "usage: %prog [options] //depot/path[@revRange]"
354081d5 2384 self.options += [
bb6e09b2
HWN
2385 optparse.make_option("--destination", dest="cloneDestination",
2386 action='store', default=None,
354081d5
TT
2387 help="where to leave result of the clone"),
2388 optparse.make_option("-/", dest="cloneExclude",
2389 action="append", type="string",
38200076
PW
2390 help="exclude depot path"),
2391 optparse.make_option("--bare", dest="cloneBare",
2392 action="store_true", default=False),
354081d5 2393 ]
bb6e09b2 2394 self.cloneDestination = None
f9a3a4f7 2395 self.needsGit = False
38200076 2396 self.cloneBare = False
f9a3a4f7 2397
354081d5
TT
2398 # This is required for the "append" cloneExclude action
2399 def ensure_value(self, attr, value):
2400 if not hasattr(self, attr) or getattr(self, attr) is None:
2401 setattr(self, attr, value)
2402 return getattr(self, attr)
2403
6a49f8e2
HWN
2404 def defaultDestination(self, args):
2405 ## TODO: use common prefix of args?
2406 depotPath = args[0]
2407 depotDir = re.sub("(@[^@]*)$", "", depotPath)
2408 depotDir = re.sub("(#[^#]*)$", "", depotDir)
053d9e43 2409 depotDir = re.sub(r"\.\.\.$", "", depotDir)
6a49f8e2
HWN
2410 depotDir = re.sub(r"/$", "", depotDir)
2411 return os.path.split(depotDir)[1]
2412
f9a3a4f7
SH
2413 def run(self, args):
2414 if len(args) < 1:
2415 return False
bb6e09b2
HWN
2416
2417 if self.keepRepoPath and not self.cloneDestination:
2418 sys.stderr.write("Must specify destination for --keep-path\n")
2419 sys.exit(1)
f9a3a4f7 2420
6326aa58 2421 depotPaths = args
5e100b5c
SH
2422
2423 if not self.cloneDestination and len(depotPaths) > 1:
2424 self.cloneDestination = depotPaths[-1]
2425 depotPaths = depotPaths[:-1]
2426
354081d5 2427 self.cloneExclude = ["/"+p for p in self.cloneExclude]
6326aa58
HWN
2428 for p in depotPaths:
2429 if not p.startswith("//"):
2430 return False
f9a3a4f7 2431
bb6e09b2 2432 if not self.cloneDestination:
98ad4faf 2433 self.cloneDestination = self.defaultDestination(args)
f9a3a4f7 2434
86dff6b6 2435 print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
38200076 2436
c3bf3f13
KG
2437 if not os.path.exists(self.cloneDestination):
2438 os.makedirs(self.cloneDestination)
053fd0c1 2439 chdir(self.cloneDestination)
38200076
PW
2440
2441 init_cmd = [ "git", "init" ]
2442 if self.cloneBare:
2443 init_cmd.append("--bare")
2444 subprocess.check_call(init_cmd)
2445
6326aa58 2446 if not P4Sync.run(self, depotPaths):
f9a3a4f7 2447 return False
f9a3a4f7 2448 if self.branch != "master":
e9905013
TAL
2449 if self.importIntoRemotes:
2450 masterbranch = "refs/remotes/p4/master"
2451 else:
2452 masterbranch = "refs/heads/p4/master"
2453 if gitBranchExists(masterbranch):
2454 system("git branch master %s" % masterbranch)
38200076
PW
2455 if not self.cloneBare:
2456 system("git checkout -f")
8f9b2e08
SH
2457 else:
2458 print "Could not detect main branch. No checkout/master branch created."
86dff6b6 2459
f9a3a4f7
SH
2460 return True
2461
09d89de2
SH
2462class P4Branches(Command):
2463 def __init__(self):
2464 Command.__init__(self)
2465 self.options = [ ]
2466 self.description = ("Shows the git branches that hold imports and their "
2467 + "corresponding perforce depot paths")
2468 self.verbose = False
2469
2470 def run(self, args):
5ca44617
SH
2471 if originP4BranchesExist():
2472 createOrUpdateBranchesFromOrigin()
2473
09d89de2
SH
2474 cmdline = "git rev-parse --symbolic "
2475 cmdline += " --remotes"
2476
2477 for line in read_pipe_lines(cmdline):
2478 line = line.strip()
2479
2480 if not line.startswith('p4/') or line == "p4/HEAD":
2481 continue
2482 branch = line
2483
2484 log = extractLogMessageFromGitCommit("refs/remotes/%s" % branch)
2485 settings = extractSettingsGitLog(log)
2486
2487 print "%s <= %s (%s)" % (branch, ",".join(settings["depot-paths"]), settings["change"])
2488 return True
2489
b984733c
SH
2490class HelpFormatter(optparse.IndentedHelpFormatter):
2491 def __init__(self):
2492 optparse.IndentedHelpFormatter.__init__(self)
2493
2494 def format_description(self, description):
2495 if description:
2496 return description + "\n"
2497 else:
2498 return ""
4f5cf76a 2499
86949eef
SH
2500def printUsage(commands):
2501 print "usage: %s <command> [options]" % sys.argv[0]
2502 print ""
2503 print "valid commands: %s" % ", ".join(commands)
2504 print ""
2505 print "Try %s <command> --help for command specific help." % sys.argv[0]
2506 print ""
2507
2508commands = {
b86f7378
HWN
2509 "debug" : P4Debug,
2510 "submit" : P4Submit,
a9834f58 2511 "commit" : P4Submit,
b86f7378
HWN
2512 "sync" : P4Sync,
2513 "rebase" : P4Rebase,
2514 "clone" : P4Clone,
09d89de2
SH
2515 "rollback" : P4RollBack,
2516 "branches" : P4Branches
86949eef
SH
2517}
2518
86949eef 2519
bb6e09b2
HWN
2520def main():
2521 if len(sys.argv[1:]) == 0:
2522 printUsage(commands.keys())
2523 sys.exit(2)
4f5cf76a 2524
bb6e09b2
HWN
2525 cmd = ""
2526 cmdName = sys.argv[1]
2527 try:
b86f7378
HWN
2528 klass = commands[cmdName]
2529 cmd = klass()
bb6e09b2
HWN
2530 except KeyError:
2531 print "unknown command %s" % cmdName
2532 print ""
2533 printUsage(commands.keys())
2534 sys.exit(2)
2535
2536 options = cmd.options
b86f7378 2537 cmd.gitdir = os.environ.get("GIT_DIR", None)
bb6e09b2
HWN
2538
2539 args = sys.argv[2:]
2540
2541 if len(options) > 0:
ef86890c
PW
2542 if cmd.needsGit:
2543 options.append(optparse.make_option("--git-dir", dest="gitdir"))
bb6e09b2
HWN
2544
2545 parser = optparse.OptionParser(cmd.usage.replace("%prog", "%prog " + cmdName),
2546 options,
2547 description = cmd.description,
2548 formatter = HelpFormatter())
2549
2550 (cmd, args) = parser.parse_args(sys.argv[2:], cmd);
2551 global verbose
2552 verbose = cmd.verbose
2553 if cmd.needsGit:
b86f7378
HWN
2554 if cmd.gitdir == None:
2555 cmd.gitdir = os.path.abspath(".git")
2556 if not isValidGitDir(cmd.gitdir):
2557 cmd.gitdir = read_pipe("git rev-parse --git-dir").strip()
2558 if os.path.exists(cmd.gitdir):
bb6e09b2
HWN
2559 cdup = read_pipe("git rev-parse --show-cdup").strip()
2560 if len(cdup) > 0:
053fd0c1 2561 chdir(cdup);
e20a9e53 2562
b86f7378
HWN
2563 if not isValidGitDir(cmd.gitdir):
2564 if isValidGitDir(cmd.gitdir + "/.git"):
2565 cmd.gitdir += "/.git"
bb6e09b2 2566 else:
b86f7378 2567 die("fatal: cannot locate git repository at %s" % cmd.gitdir)
e20a9e53 2568
b86f7378 2569 os.environ["GIT_DIR"] = cmd.gitdir
86949eef 2570
bb6e09b2
HWN
2571 if not cmd.run(args):
2572 parser.print_help()
09fca77b 2573 sys.exit(2)
4f5cf76a 2574
4f5cf76a 2575
bb6e09b2
HWN
2576if __name__ == '__main__':
2577 main()