README: point to Documentation/SubmittingPatches
[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.
ecdba36d 802 results = p4CmdList("protects %s" % 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)
1744 self.gitStream.write("data <<EOT\n")
1745 self.gitStream.write(labelDetails["Description"])
1746 self.gitStream.write("EOT\n\n")
1747
1748 else:
a46668fa 1749 if not self.silent:
cebdf5af
HWN
1750 print ("Tag %s does not match with change %s: files do not match."
1751 % (labelDetails["label"], change))
1f4ba1cb
SH
1752
1753 else:
a46668fa 1754 if not self.silent:
cebdf5af
HWN
1755 print ("Tag %s does not match with change %s: file count is different."
1756 % (labelDetails["label"], change))
b984733c 1757
1f4ba1cb
SH
1758 def getLabels(self):
1759 self.labels = {}
1760
6326aa58 1761 l = p4CmdList("labels %s..." % ' '.join (self.depotPaths))
10c3211b 1762 if len(l) > 0 and not self.silent:
183f8436 1763 print "Finding files belonging to labels in %s" % `self.depotPaths`
01ce1fe9
SH
1764
1765 for output in l:
1f4ba1cb
SH
1766 label = output["label"]
1767 revisions = {}
1768 newestChange = 0
71b112d4
SH
1769 if self.verbose:
1770 print "Querying files for label %s" % label
6de040df
LD
1771 for file in p4CmdList(["files"] +
1772 ["%s...@%s" % (p, label)
1773 for p in self.depotPaths]):
1f4ba1cb
SH
1774 revisions[file["depotFile"]] = file["rev"]
1775 change = int(file["change"])
1776 if change > newestChange:
1777 newestChange = change
1778
9bda3a85
SH
1779 self.labels[newestChange] = [output, revisions]
1780
1781 if self.verbose:
1782 print "Label changes: %s" % self.labels.keys()
1f4ba1cb 1783
86dff6b6
HWN
1784 def guessProjectName(self):
1785 for p in self.depotPaths:
6e5295c4
SH
1786 if p.endswith("/"):
1787 p = p[:-1]
1788 p = p[p.strip().rfind("/") + 1:]
1789 if not p.endswith("/"):
1790 p += "/"
1791 return p
86dff6b6 1792
4b97ffb1 1793 def getBranchMapping(self):
6555b2cc
SH
1794 lostAndFoundBranches = set()
1795
8ace74c0
VA
1796 user = gitConfig("git-p4.branchUser")
1797 if len(user) > 0:
1798 command = "branches -u %s" % user
1799 else:
1800 command = "branches"
1801
1802 for info in p4CmdList(command):
4b97ffb1
SH
1803 details = p4Cmd("branch -o %s" % info["branch"])
1804 viewIdx = 0
1805 while details.has_key("View%s" % viewIdx):
1806 paths = details["View%s" % viewIdx].split(" ")
1807 viewIdx = viewIdx + 1
1808 # require standard //depot/foo/... //depot/bar/... mapping
1809 if len(paths) != 2 or not paths[0].endswith("/...") or not paths[1].endswith("/..."):
1810 continue
1811 source = paths[0]
1812 destination = paths[1]
6509e19c 1813 ## HACK
d53de8b9 1814 if p4PathStartsWith(source, self.depotPaths[0]) and p4PathStartsWith(destination, self.depotPaths[0]):
6509e19c
SH
1815 source = source[len(self.depotPaths[0]):-4]
1816 destination = destination[len(self.depotPaths[0]):-4]
6555b2cc 1817
1a2edf4e
SH
1818 if destination in self.knownBranches:
1819 if not self.silent:
1820 print "p4 branch %s defines a mapping from %s to %s" % (info["branch"], source, destination)
1821 print "but there exists another mapping from %s to %s already!" % (self.knownBranches[destination], destination)
1822 continue
1823
6555b2cc
SH
1824 self.knownBranches[destination] = source
1825
1826 lostAndFoundBranches.discard(destination)
1827
29bdbac1 1828 if source not in self.knownBranches:
6555b2cc
SH
1829 lostAndFoundBranches.add(source)
1830
7199cf13
VA
1831 # Perforce does not strictly require branches to be defined, so we also
1832 # check git config for a branch list.
1833 #
1834 # Example of branch definition in git config file:
1835 # [git-p4]
1836 # branchList=main:branchA
1837 # branchList=main:branchB
1838 # branchList=branchA:branchC
1839 configBranches = gitConfigList("git-p4.branchList")
1840 for branch in configBranches:
1841 if branch:
1842 (source, destination) = branch.split(":")
1843 self.knownBranches[destination] = source
1844
1845 lostAndFoundBranches.discard(destination)
1846
1847 if source not in self.knownBranches:
1848 lostAndFoundBranches.add(source)
1849
6555b2cc
SH
1850
1851 for branch in lostAndFoundBranches:
1852 self.knownBranches[branch] = branch
29bdbac1 1853
38f9f5ec
SH
1854 def getBranchMappingFromGitBranches(self):
1855 branches = p4BranchesInGit(self.importIntoRemotes)
1856 for branch in branches.keys():
1857 if branch == "master":
1858 branch = "main"
1859 else:
1860 branch = branch[len(self.projectName):]
1861 self.knownBranches[branch] = branch
1862
29bdbac1 1863 def listExistingP4GitBranches(self):
144ff46b
SH
1864 # branches holds mapping from name to commit
1865 branches = p4BranchesInGit(self.importIntoRemotes)
1866 self.p4BranchesInGit = branches.keys()
1867 for branch in branches.keys():
1868 self.initialParents[self.refPrefix + branch] = branches[branch]
4b97ffb1 1869
bb6e09b2
HWN
1870 def updateOptionDict(self, d):
1871 option_keys = {}
1872 if self.keepRepoPath:
1873 option_keys['keepRepoPath'] = 1
1874
1875 d["options"] = ' '.join(sorted(option_keys.keys()))
1876
1877 def readOptions(self, d):
1878 self.keepRepoPath = (d.has_key('options')
1879 and ('keepRepoPath' in d['options']))
6326aa58 1880
8134f69c
SH
1881 def gitRefForBranch(self, branch):
1882 if branch == "main":
1883 return self.refPrefix + "master"
1884
1885 if len(branch) <= 0:
1886 return branch
1887
1888 return self.refPrefix + self.projectName + branch
1889
1ca3d710
SH
1890 def gitCommitByP4Change(self, ref, change):
1891 if self.verbose:
1892 print "looking in ref " + ref + " for change %s using bisect..." % change
1893
1894 earliestCommit = ""
1895 latestCommit = parseRevision(ref)
1896
1897 while True:
1898 if self.verbose:
1899 print "trying: earliest %s latest %s" % (earliestCommit, latestCommit)
1900 next = read_pipe("git rev-list --bisect %s %s" % (latestCommit, earliestCommit)).strip()
1901 if len(next) == 0:
1902 if self.verbose:
1903 print "argh"
1904 return ""
1905 log = extractLogMessageFromGitCommit(next)
1906 settings = extractSettingsGitLog(log)
1907 currentChange = int(settings['change'])
1908 if self.verbose:
1909 print "current change %s" % currentChange
1910
1911 if currentChange == change:
1912 if self.verbose:
1913 print "found %s" % next
1914 return next
1915
1916 if currentChange < change:
1917 earliestCommit = "^%s" % next
1918 else:
1919 latestCommit = "%s" % next
1920
1921 return ""
1922
1923 def importNewBranch(self, branch, maxChange):
1924 # make fast-import flush all changes to disk and update the refs using the checkpoint
1925 # command so that we can try to find the branch parent in the git history
1926 self.gitStream.write("checkpoint\n\n");
1927 self.gitStream.flush();
1928 branchPrefix = self.depotPaths[0] + branch + "/"
1929 range = "@1,%s" % maxChange
1930 #print "prefix" + branchPrefix
1931 changes = p4ChangesForPaths([branchPrefix], range)
1932 if len(changes) <= 0:
1933 return False
1934 firstChange = changes[0]
1935 #print "first change in branch: %s" % firstChange
1936 sourceBranch = self.knownBranches[branch]
1937 sourceDepotPath = self.depotPaths[0] + sourceBranch
1938 sourceRef = self.gitRefForBranch(sourceBranch)
1939 #print "source " + sourceBranch
1940
1941 branchParentChange = int(p4Cmd("changes -m 1 %s...@1,%s" % (sourceDepotPath, firstChange))["change"])
1942 #print "branch parent: %s" % branchParentChange
1943 gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)
1944 if len(gitParent) > 0:
1945 self.initialParents[self.gitRefForBranch(branch)] = gitParent
1946 #print "parent git commit: %s" % gitParent
1947
1948 self.importChanges(changes)
1949 return True
1950
e87f37ae
SH
1951 def importChanges(self, changes):
1952 cnt = 1
1953 for change in changes:
1954 description = p4Cmd("describe %s" % change)
1955 self.updateOptionDict(description)
1956
1957 if not self.silent:
1958 sys.stdout.write("\rImporting revision %s (%s%%)" % (change, cnt * 100 / len(changes)))
1959 sys.stdout.flush()
1960 cnt = cnt + 1
1961
1962 try:
1963 if self.detectBranches:
1964 branches = self.splitFilesIntoBranches(description)
1965 for branch in branches.keys():
1966 ## HACK --hwn
1967 branchPrefix = self.depotPaths[0] + branch + "/"
1968
1969 parent = ""
1970
1971 filesForCommit = branches[branch]
1972
1973 if self.verbose:
1974 print "branch is %s" % branch
1975
1976 self.updatedBranches.add(branch)
1977
1978 if branch not in self.createdBranches:
1979 self.createdBranches.add(branch)
1980 parent = self.knownBranches[branch]
1981 if parent == branch:
1982 parent = ""
1ca3d710
SH
1983 else:
1984 fullBranch = self.projectName + branch
1985 if fullBranch not in self.p4BranchesInGit:
1986 if not self.silent:
1987 print("\n Importing new branch %s" % fullBranch);
1988 if self.importNewBranch(branch, change - 1):
1989 parent = ""
1990 self.p4BranchesInGit.append(fullBranch)
1991 if not self.silent:
1992 print("\n Resuming with change %s" % change);
1993
1994 if self.verbose:
1995 print "parent determined through known branches: %s" % parent
e87f37ae 1996
8134f69c
SH
1997 branch = self.gitRefForBranch(branch)
1998 parent = self.gitRefForBranch(parent)
e87f37ae
SH
1999
2000 if self.verbose:
2001 print "looking for initial parent for %s; current parent is %s" % (branch, parent)
2002
2003 if len(parent) == 0 and branch in self.initialParents:
2004 parent = self.initialParents[branch]
2005 del self.initialParents[branch]
2006
2007 self.commit(description, filesForCommit, branch, [branchPrefix], parent)
2008 else:
2009 files = self.extractFilesFromCommit(description)
2010 self.commit(description, files, self.branch, self.depotPaths,
2011 self.initialParent)
2012 self.initialParent = ""
2013 except IOError:
2014 print self.gitError.read()
2015 sys.exit(1)
2016
c208a243
SH
2017 def importHeadRevision(self, revision):
2018 print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), revision, self.branch)
2019
4e2e6ce4
PW
2020 details = {}
2021 details["user"] = "git perforce import user"
1494fcbb 2022 details["desc"] = ("Initial import of %s from the state at revision %s\n"
c208a243
SH
2023 % (' '.join(self.depotPaths), revision))
2024 details["change"] = revision
2025 newestRevision = 0
2026
2027 fileCnt = 0
6de040df
LD
2028 fileArgs = ["%s...%s" % (p,revision) for p in self.depotPaths]
2029
2030 for info in p4CmdList(["files"] + fileArgs):
c208a243 2031
68b28593 2032 if 'code' in info and info['code'] == 'error':
c208a243
SH
2033 sys.stderr.write("p4 returned an error: %s\n"
2034 % info['data'])
d88e707f
PW
2035 if info['data'].find("must refer to client") >= 0:
2036 sys.stderr.write("This particular p4 error is misleading.\n")
2037 sys.stderr.write("Perhaps the depot path was misspelled.\n");
2038 sys.stderr.write("Depot path: %s\n" % " ".join(self.depotPaths))
c208a243 2039 sys.exit(1)
68b28593
PW
2040 if 'p4ExitCode' in info:
2041 sys.stderr.write("p4 exitcode: %s\n" % info['p4ExitCode'])
c208a243
SH
2042 sys.exit(1)
2043
2044
2045 change = int(info["change"])
2046 if change > newestRevision:
2047 newestRevision = change
2048
56c09345 2049 if info["action"] in self.delete_actions:
c208a243
SH
2050 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
2051 #fileCnt = fileCnt + 1
2052 continue
2053
2054 for prop in ["depotFile", "rev", "action", "type" ]:
2055 details["%s%s" % (prop, fileCnt)] = info[prop]
2056
2057 fileCnt = fileCnt + 1
2058
2059 details["change"] = newestRevision
4e2e6ce4
PW
2060
2061 # Use time from top-most change so that all git-p4 clones of
2062 # the same p4 repo have the same commit SHA1s.
2063 res = p4CmdList("describe -s %d" % newestRevision)
2064 newestTime = None
2065 for r in res:
2066 if r.has_key('time'):
2067 newestTime = int(r['time'])
2068 if newestTime is None:
2069 die("\"describe -s\" on newest change %d did not give a time")
2070 details["time"] = newestTime
2071
c208a243
SH
2072 self.updateOptionDict(details)
2073 try:
2074 self.commit(details, self.extractFilesFromCommit(details), self.branch, self.depotPaths)
2075 except IOError:
2076 print "IO error with git fast-import. Is your git version recent enough?"
2077 print self.gitError.read()
2078
2079
3a70cdfa 2080 def getClientSpec(self):
ecb7cf98
PW
2081 specList = p4CmdList("client -o")
2082 if len(specList) != 1:
2083 die('Output from "client -o" is %d lines, expecting 1' %
2084 len(specList))
2085
2086 # dictionary of all client parameters
2087 entry = specList[0]
2088
2089 # just the keys that start with "View"
2090 view_keys = [ k for k in entry.keys() if k.startswith("View") ]
2091
2092 # hold this new View
2093 view = View()
3952710b 2094
ecb7cf98
PW
2095 # append the lines, in order, to the view
2096 for view_num in range(len(view_keys)):
2097 k = "View%d" % view_num
2098 if k not in view_keys:
2099 die("Expected view key %s missing" % k)
2100 view.append(entry[k])
3952710b 2101
ecb7cf98 2102 self.clientSpecDirs = view
df5ed907 2103 if self.verbose:
ecb7cf98
PW
2104 for i, m in enumerate(self.clientSpecDirs.mappings):
2105 print "clientSpecDirs %d: %s" % (i, str(m))
3a70cdfa 2106
b984733c 2107 def run(self, args):
6326aa58 2108 self.depotPaths = []
179caebf
SH
2109 self.changeRange = ""
2110 self.initialParent = ""
6326aa58 2111 self.previousDepotPaths = []
ce6f33c8 2112
29bdbac1
SH
2113 # map from branch depot path to parent branch
2114 self.knownBranches = {}
2115 self.initialParents = {}
5ca44617 2116 self.hasOrigin = originP4BranchesExist()
a43ff00c
SH
2117 if not self.syncWithOrigin:
2118 self.hasOrigin = False
29bdbac1 2119
a028a98e
SH
2120 if self.importIntoRemotes:
2121 self.refPrefix = "refs/remotes/p4/"
2122 else:
db775559 2123 self.refPrefix = "refs/heads/p4/"
a028a98e 2124
cebdf5af
HWN
2125 if self.syncWithOrigin and self.hasOrigin:
2126 if not self.silent:
2127 print "Syncing with origin first by calling git fetch origin"
2128 system("git fetch origin")
10f880f8 2129
569d1bd4 2130 if len(self.branch) == 0:
db775559 2131 self.branch = self.refPrefix + "master"
a028a98e 2132 if gitBranchExists("refs/heads/p4") and self.importIntoRemotes:
48df6fd8 2133 system("git update-ref %s refs/heads/p4" % self.branch)
48df6fd8 2134 system("git branch -D p4");
faf1bd20 2135 # create it /after/ importing, when master exists
0058a33a 2136 if not gitBranchExists(self.refPrefix + "HEAD") and self.importIntoRemotes and gitBranchExists(self.branch):
a3c55c09 2137 system("git symbolic-ref %sHEAD %s" % (self.refPrefix, self.branch))
967f72e2 2138
09fca77b
PW
2139 if not self.useClientSpec:
2140 if gitConfig("git-p4.useclientspec", "--bool") == "true":
2141 self.useClientSpec = True
2142 if self.useClientSpec:
3a70cdfa
TAL
2143 self.getClientSpec()
2144
6a49f8e2
HWN
2145 # TODO: should always look at previous commits,
2146 # merge with previous imports, if possible.
2147 if args == []:
d414c74a 2148 if self.hasOrigin:
5ca44617 2149 createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)
abcd790f
SH
2150 self.listExistingP4GitBranches()
2151
2152 if len(self.p4BranchesInGit) > 1:
2153 if not self.silent:
2154 print "Importing from/into multiple branches"
2155 self.detectBranches = True
967f72e2 2156
29bdbac1
SH
2157 if self.verbose:
2158 print "branches: %s" % self.p4BranchesInGit
2159
2160 p4Change = 0
2161 for branch in self.p4BranchesInGit:
cebdf5af 2162 logMsg = extractLogMessageFromGitCommit(self.refPrefix + branch)
bb6e09b2
HWN
2163
2164 settings = extractSettingsGitLog(logMsg)
29bdbac1 2165
bb6e09b2
HWN
2166 self.readOptions(settings)
2167 if (settings.has_key('depot-paths')
2168 and settings.has_key ('change')):
2169 change = int(settings['change']) + 1
29bdbac1
SH
2170 p4Change = max(p4Change, change)
2171
bb6e09b2
HWN
2172 depotPaths = sorted(settings['depot-paths'])
2173 if self.previousDepotPaths == []:
6326aa58 2174 self.previousDepotPaths = depotPaths
29bdbac1 2175 else:
6326aa58
HWN
2176 paths = []
2177 for (prev, cur) in zip(self.previousDepotPaths, depotPaths):
04d277b3
VA
2178 prev_list = prev.split("/")
2179 cur_list = cur.split("/")
2180 for i in range(0, min(len(cur_list), len(prev_list))):
2181 if cur_list[i] <> prev_list[i]:
583e1707 2182 i = i - 1
6326aa58
HWN
2183 break
2184
04d277b3 2185 paths.append ("/".join(cur_list[:i + 1]))
6326aa58
HWN
2186
2187 self.previousDepotPaths = paths
29bdbac1
SH
2188
2189 if p4Change > 0:
bb6e09b2 2190 self.depotPaths = sorted(self.previousDepotPaths)
d5904674 2191 self.changeRange = "@%s,#head" % p4Change
330f53b8
SH
2192 if not self.detectBranches:
2193 self.initialParent = parseRevision(self.branch)
341dc1c1 2194 if not self.silent and not self.detectBranches:
967f72e2 2195 print "Performing incremental import into %s git branch" % self.branch
569d1bd4 2196
f9162f6a
SH
2197 if not self.branch.startswith("refs/"):
2198 self.branch = "refs/heads/" + self.branch
179caebf 2199
6326aa58 2200 if len(args) == 0 and self.depotPaths:
b984733c 2201 if not self.silent:
6326aa58 2202 print "Depot paths: %s" % ' '.join(self.depotPaths)
b984733c 2203 else:
6326aa58 2204 if self.depotPaths and self.depotPaths != args:
cebdf5af 2205 print ("previous import used depot path %s and now %s was specified. "
6326aa58
HWN
2206 "This doesn't work!" % (' '.join (self.depotPaths),
2207 ' '.join (args)))
b984733c 2208 sys.exit(1)
6326aa58 2209
bb6e09b2 2210 self.depotPaths = sorted(args)
b984733c 2211
1c49fc19 2212 revision = ""
b984733c 2213 self.users = {}
b984733c 2214
58c8bc7c
PW
2215 # Make sure no revision specifiers are used when --changesfile
2216 # is specified.
2217 bad_changesfile = False
2218 if len(self.changesFile) > 0:
2219 for p in self.depotPaths:
2220 if p.find("@") >= 0 or p.find("#") >= 0:
2221 bad_changesfile = True
2222 break
2223 if bad_changesfile:
2224 die("Option --changesfile is incompatible with revision specifiers")
2225
6326aa58
HWN
2226 newPaths = []
2227 for p in self.depotPaths:
2228 if p.find("@") != -1:
2229 atIdx = p.index("@")
2230 self.changeRange = p[atIdx:]
2231 if self.changeRange == "@all":
2232 self.changeRange = ""
6a49f8e2 2233 elif ',' not in self.changeRange:
1c49fc19 2234 revision = self.changeRange
6326aa58 2235 self.changeRange = ""
7fcff9de 2236 p = p[:atIdx]
6326aa58
HWN
2237 elif p.find("#") != -1:
2238 hashIdx = p.index("#")
1c49fc19 2239 revision = p[hashIdx:]
7fcff9de 2240 p = p[:hashIdx]
6326aa58 2241 elif self.previousDepotPaths == []:
58c8bc7c
PW
2242 # pay attention to changesfile, if given, else import
2243 # the entire p4 tree at the head revision
2244 if len(self.changesFile) == 0:
2245 revision = "#head"
6326aa58
HWN
2246
2247 p = re.sub ("\.\.\.$", "", p)
2248 if not p.endswith("/"):
2249 p += "/"
2250
2251 newPaths.append(p)
2252
2253 self.depotPaths = newPaths
2254
b984733c 2255
b607e71e 2256 self.loadUserMapFromCache()
cb53e1f8
SH
2257 self.labels = {}
2258 if self.detectLabels:
2259 self.getLabels();
b984733c 2260
4b97ffb1 2261 if self.detectBranches:
df450923
SH
2262 ## FIXME - what's a P4 projectName ?
2263 self.projectName = self.guessProjectName()
2264
38f9f5ec
SH
2265 if self.hasOrigin:
2266 self.getBranchMappingFromGitBranches()
2267 else:
2268 self.getBranchMapping()
29bdbac1
SH
2269 if self.verbose:
2270 print "p4-git branches: %s" % self.p4BranchesInGit
2271 print "initial parents: %s" % self.initialParents
2272 for b in self.p4BranchesInGit:
2273 if b != "master":
6326aa58
HWN
2274
2275 ## FIXME
29bdbac1
SH
2276 b = b[len(self.projectName):]
2277 self.createdBranches.add(b)
4b97ffb1 2278
f291b4e3 2279 self.tz = "%+03d%02d" % (- time.timezone / 3600, ((- time.timezone % 3600) / 60))
b984733c 2280
cebdf5af 2281 importProcess = subprocess.Popen(["git", "fast-import"],
6326aa58
HWN
2282 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
2283 stderr=subprocess.PIPE);
08483580
SH
2284 self.gitOutput = importProcess.stdout
2285 self.gitStream = importProcess.stdin
2286 self.gitError = importProcess.stderr
b984733c 2287
1c49fc19 2288 if revision:
c208a243 2289 self.importHeadRevision(revision)
b984733c
SH
2290 else:
2291 changes = []
2292
0828ab14 2293 if len(self.changesFile) > 0:
b984733c 2294 output = open(self.changesFile).readlines()
1d7367dc 2295 changeSet = set()
b984733c
SH
2296 for line in output:
2297 changeSet.add(int(line))
2298
2299 for change in changeSet:
2300 changes.append(change)
2301
2302 changes.sort()
2303 else:
accad8e0
PW
2304 # catch "git-p4 sync" with no new branches, in a repo that
2305 # does not have any existing git-p4 branches
2306 if len(args) == 0 and not self.p4BranchesInGit:
e32e00dc 2307 die("No remote p4 branches. Perhaps you never did \"git p4 clone\" in here.");
29bdbac1 2308 if self.verbose:
86dff6b6 2309 print "Getting p4 changes for %s...%s" % (', '.join(self.depotPaths),
6326aa58 2310 self.changeRange)
4f6432d8 2311 changes = p4ChangesForPaths(self.depotPaths, self.changeRange)
b984733c 2312
01a9c9c5 2313 if len(self.maxChanges) > 0:
7fcff9de 2314 changes = changes[:min(int(self.maxChanges), len(changes))]
01a9c9c5 2315
b984733c 2316 if len(changes) == 0:
0828ab14 2317 if not self.silent:
341dc1c1 2318 print "No changes to import!"
1f52af6c 2319 return True
b984733c 2320
a9d1a27a
SH
2321 if not self.silent and not self.detectBranches:
2322 print "Import destination: %s" % self.branch
2323
341dc1c1
SH
2324 self.updatedBranches = set()
2325
e87f37ae 2326 self.importChanges(changes)
b984733c 2327
341dc1c1
SH
2328 if not self.silent:
2329 print ""
2330 if len(self.updatedBranches) > 0:
2331 sys.stdout.write("Updated branches: ")
2332 for b in self.updatedBranches:
2333 sys.stdout.write("%s " % b)
2334 sys.stdout.write("\n")
b984733c 2335
b984733c 2336 self.gitStream.close()
29bdbac1
SH
2337 if importProcess.wait() != 0:
2338 die("fast-import failed: %s" % self.gitError.read())
b984733c
SH
2339 self.gitOutput.close()
2340 self.gitError.close()
2341
b984733c
SH
2342 return True
2343
01ce1fe9
SH
2344class P4Rebase(Command):
2345 def __init__(self):
2346 Command.__init__(self)
01265103 2347 self.options = [ ]
cebdf5af
HWN
2348 self.description = ("Fetches the latest revision from perforce and "
2349 + "rebases the current work (branch) against it")
68c42153 2350 self.verbose = False
01ce1fe9
SH
2351
2352 def run(self, args):
2353 sync = P4Sync()
2354 sync.run([])
d7e3868c 2355
14594f4b
SH
2356 return self.rebase()
2357
2358 def rebase(self):
36ee4ee4
SH
2359 if os.system("git update-index --refresh") != 0:
2360 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.");
2361 if len(read_pipe("git diff-index HEAD --")) > 0:
2362 die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
2363
d7e3868c
SH
2364 [upstream, settings] = findUpstreamBranchPoint()
2365 if len(upstream) == 0:
2366 die("Cannot find upstream branchpoint for rebase")
2367
2368 # the branchpoint may be p4/foo~3, so strip off the parent
2369 upstream = re.sub("~[0-9]+$", "", upstream)
2370
2371 print "Rebasing the current branch onto %s" % upstream
b25b2065 2372 oldHead = read_pipe("git rev-parse HEAD").strip()
d7e3868c 2373 system("git rebase %s" % upstream)
1f52af6c 2374 system("git diff-tree --stat --summary -M %s HEAD" % oldHead)
01ce1fe9
SH
2375 return True
2376
f9a3a4f7
SH
2377class P4Clone(P4Sync):
2378 def __init__(self):
2379 P4Sync.__init__(self)
2380 self.description = "Creates a new git repository and imports from Perforce into it"
bb6e09b2 2381 self.usage = "usage: %prog [options] //depot/path[@revRange]"
354081d5 2382 self.options += [
bb6e09b2
HWN
2383 optparse.make_option("--destination", dest="cloneDestination",
2384 action='store', default=None,
354081d5
TT
2385 help="where to leave result of the clone"),
2386 optparse.make_option("-/", dest="cloneExclude",
2387 action="append", type="string",
38200076
PW
2388 help="exclude depot path"),
2389 optparse.make_option("--bare", dest="cloneBare",
2390 action="store_true", default=False),
354081d5 2391 ]
bb6e09b2 2392 self.cloneDestination = None
f9a3a4f7 2393 self.needsGit = False
38200076 2394 self.cloneBare = False
f9a3a4f7 2395
354081d5
TT
2396 # This is required for the "append" cloneExclude action
2397 def ensure_value(self, attr, value):
2398 if not hasattr(self, attr) or getattr(self, attr) is None:
2399 setattr(self, attr, value)
2400 return getattr(self, attr)
2401
6a49f8e2
HWN
2402 def defaultDestination(self, args):
2403 ## TODO: use common prefix of args?
2404 depotPath = args[0]
2405 depotDir = re.sub("(@[^@]*)$", "", depotPath)
2406 depotDir = re.sub("(#[^#]*)$", "", depotDir)
053d9e43 2407 depotDir = re.sub(r"\.\.\.$", "", depotDir)
6a49f8e2
HWN
2408 depotDir = re.sub(r"/$", "", depotDir)
2409 return os.path.split(depotDir)[1]
2410
f9a3a4f7
SH
2411 def run(self, args):
2412 if len(args) < 1:
2413 return False
bb6e09b2
HWN
2414
2415 if self.keepRepoPath and not self.cloneDestination:
2416 sys.stderr.write("Must specify destination for --keep-path\n")
2417 sys.exit(1)
f9a3a4f7 2418
6326aa58 2419 depotPaths = args
5e100b5c
SH
2420
2421 if not self.cloneDestination and len(depotPaths) > 1:
2422 self.cloneDestination = depotPaths[-1]
2423 depotPaths = depotPaths[:-1]
2424
354081d5 2425 self.cloneExclude = ["/"+p for p in self.cloneExclude]
6326aa58
HWN
2426 for p in depotPaths:
2427 if not p.startswith("//"):
2428 return False
f9a3a4f7 2429
bb6e09b2 2430 if not self.cloneDestination:
98ad4faf 2431 self.cloneDestination = self.defaultDestination(args)
f9a3a4f7 2432
86dff6b6 2433 print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
38200076 2434
c3bf3f13
KG
2435 if not os.path.exists(self.cloneDestination):
2436 os.makedirs(self.cloneDestination)
053fd0c1 2437 chdir(self.cloneDestination)
38200076
PW
2438
2439 init_cmd = [ "git", "init" ]
2440 if self.cloneBare:
2441 init_cmd.append("--bare")
2442 subprocess.check_call(init_cmd)
2443
6326aa58 2444 if not P4Sync.run(self, depotPaths):
f9a3a4f7 2445 return False
f9a3a4f7 2446 if self.branch != "master":
e9905013
TAL
2447 if self.importIntoRemotes:
2448 masterbranch = "refs/remotes/p4/master"
2449 else:
2450 masterbranch = "refs/heads/p4/master"
2451 if gitBranchExists(masterbranch):
2452 system("git branch master %s" % masterbranch)
38200076
PW
2453 if not self.cloneBare:
2454 system("git checkout -f")
8f9b2e08
SH
2455 else:
2456 print "Could not detect main branch. No checkout/master branch created."
86dff6b6 2457
f9a3a4f7
SH
2458 return True
2459
09d89de2
SH
2460class P4Branches(Command):
2461 def __init__(self):
2462 Command.__init__(self)
2463 self.options = [ ]
2464 self.description = ("Shows the git branches that hold imports and their "
2465 + "corresponding perforce depot paths")
2466 self.verbose = False
2467
2468 def run(self, args):
5ca44617
SH
2469 if originP4BranchesExist():
2470 createOrUpdateBranchesFromOrigin()
2471
09d89de2
SH
2472 cmdline = "git rev-parse --symbolic "
2473 cmdline += " --remotes"
2474
2475 for line in read_pipe_lines(cmdline):
2476 line = line.strip()
2477
2478 if not line.startswith('p4/') or line == "p4/HEAD":
2479 continue
2480 branch = line
2481
2482 log = extractLogMessageFromGitCommit("refs/remotes/%s" % branch)
2483 settings = extractSettingsGitLog(log)
2484
2485 print "%s <= %s (%s)" % (branch, ",".join(settings["depot-paths"]), settings["change"])
2486 return True
2487
b984733c
SH
2488class HelpFormatter(optparse.IndentedHelpFormatter):
2489 def __init__(self):
2490 optparse.IndentedHelpFormatter.__init__(self)
2491
2492 def format_description(self, description):
2493 if description:
2494 return description + "\n"
2495 else:
2496 return ""
4f5cf76a 2497
86949eef
SH
2498def printUsage(commands):
2499 print "usage: %s <command> [options]" % sys.argv[0]
2500 print ""
2501 print "valid commands: %s" % ", ".join(commands)
2502 print ""
2503 print "Try %s <command> --help for command specific help." % sys.argv[0]
2504 print ""
2505
2506commands = {
b86f7378
HWN
2507 "debug" : P4Debug,
2508 "submit" : P4Submit,
a9834f58 2509 "commit" : P4Submit,
b86f7378
HWN
2510 "sync" : P4Sync,
2511 "rebase" : P4Rebase,
2512 "clone" : P4Clone,
09d89de2
SH
2513 "rollback" : P4RollBack,
2514 "branches" : P4Branches
86949eef
SH
2515}
2516
86949eef 2517
bb6e09b2
HWN
2518def main():
2519 if len(sys.argv[1:]) == 0:
2520 printUsage(commands.keys())
2521 sys.exit(2)
4f5cf76a 2522
bb6e09b2
HWN
2523 cmd = ""
2524 cmdName = sys.argv[1]
2525 try:
b86f7378
HWN
2526 klass = commands[cmdName]
2527 cmd = klass()
bb6e09b2
HWN
2528 except KeyError:
2529 print "unknown command %s" % cmdName
2530 print ""
2531 printUsage(commands.keys())
2532 sys.exit(2)
2533
2534 options = cmd.options
b86f7378 2535 cmd.gitdir = os.environ.get("GIT_DIR", None)
bb6e09b2
HWN
2536
2537 args = sys.argv[2:]
2538
2539 if len(options) > 0:
ef86890c
PW
2540 if cmd.needsGit:
2541 options.append(optparse.make_option("--git-dir", dest="gitdir"))
bb6e09b2
HWN
2542
2543 parser = optparse.OptionParser(cmd.usage.replace("%prog", "%prog " + cmdName),
2544 options,
2545 description = cmd.description,
2546 formatter = HelpFormatter())
2547
2548 (cmd, args) = parser.parse_args(sys.argv[2:], cmd);
2549 global verbose
2550 verbose = cmd.verbose
2551 if cmd.needsGit:
b86f7378
HWN
2552 if cmd.gitdir == None:
2553 cmd.gitdir = os.path.abspath(".git")
2554 if not isValidGitDir(cmd.gitdir):
2555 cmd.gitdir = read_pipe("git rev-parse --git-dir").strip()
2556 if os.path.exists(cmd.gitdir):
bb6e09b2
HWN
2557 cdup = read_pipe("git rev-parse --show-cdup").strip()
2558 if len(cdup) > 0:
053fd0c1 2559 chdir(cdup);
e20a9e53 2560
b86f7378
HWN
2561 if not isValidGitDir(cmd.gitdir):
2562 if isValidGitDir(cmd.gitdir + "/.git"):
2563 cmd.gitdir += "/.git"
bb6e09b2 2564 else:
b86f7378 2565 die("fatal: cannot locate git repository at %s" % cmd.gitdir)
e20a9e53 2566
b86f7378 2567 os.environ["GIT_DIR"] = cmd.gitdir
86949eef 2568
bb6e09b2
HWN
2569 if not cmd.run(args):
2570 parser.print_help()
09fca77b 2571 sys.exit(2)
4f5cf76a 2572
4f5cf76a 2573
bb6e09b2
HWN
2574if __name__ == '__main__':
2575 main()