git-p4: Fix sync errors due to new server version
[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 """
abcaf073
AK
25 real_cmd = "%s " % "p4"
26
27 user = gitConfig("git-p4.user")
28 if len(user) > 0:
29 real_cmd += "-u %s " % user
30
31 password = gitConfig("git-p4.password")
32 if len(password) > 0:
33 real_cmd += "-P %s " % password
34
35 port = gitConfig("git-p4.port")
36 if len(port) > 0:
37 real_cmd += "-p %s " % port
38
39 host = gitConfig("git-p4.host")
40 if len(host) > 0:
41 real_cmd += "-h %s " % host
42
43 client = gitConfig("git-p4.client")
44 if len(client) > 0:
45 real_cmd += "-c %s " % client
46
47 real_cmd += "%s" % (cmd)
ee06427a
AK
48 if verbose:
49 print real_cmd
21a50753
AK
50 return real_cmd
51
053fd0c1
RB
52def chdir(dir):
53 if os.name == 'nt':
54 os.environ['PWD']=dir
55 os.chdir(dir)
56
86dff6b6
HWN
57def die(msg):
58 if verbose:
59 raise Exception(msg)
60 else:
61 sys.stderr.write(msg + "\n")
62 sys.exit(1)
63
bce4c5fc 64def write_pipe(c, str):
4addad22 65 if verbose:
86dff6b6 66 sys.stderr.write('Writing pipe: %s\n' % c)
b016d397 67
bce4c5fc 68 pipe = os.popen(c, 'w')
b016d397 69 val = pipe.write(str)
bce4c5fc 70 if pipe.close():
86dff6b6 71 die('Command failed: %s' % c)
b016d397
HWN
72
73 return val
74
d9429194
AK
75def p4_write_pipe(c, str):
76 real_cmd = p4_build_cmd(c)
893d340f 77 return write_pipe(real_cmd, str)
d9429194 78
4addad22
HWN
79def read_pipe(c, ignore_error=False):
80 if verbose:
86dff6b6 81 sys.stderr.write('Reading pipe: %s\n' % c)
8b41a97f 82
bce4c5fc 83 pipe = os.popen(c, 'rb')
b016d397 84 val = pipe.read()
4addad22 85 if pipe.close() and not ignore_error:
86dff6b6 86 die('Command failed: %s' % c)
b016d397
HWN
87
88 return val
89
d9429194
AK
90def p4_read_pipe(c, ignore_error=False):
91 real_cmd = p4_build_cmd(c)
92 return read_pipe(real_cmd, ignore_error)
b016d397 93
bce4c5fc 94def read_pipe_lines(c):
4addad22 95 if verbose:
86dff6b6 96 sys.stderr.write('Reading pipe: %s\n' % c)
b016d397 97 ## todo: check return status
bce4c5fc 98 pipe = os.popen(c, 'rb')
b016d397 99 val = pipe.readlines()
bce4c5fc 100 if pipe.close():
86dff6b6 101 die('Command failed: %s' % c)
b016d397
HWN
102
103 return val
caace111 104
2318121b
AK
105def p4_read_pipe_lines(c):
106 """Specifically invoke p4 on the command supplied. """
155af834 107 real_cmd = p4_build_cmd(c)
2318121b
AK
108 return read_pipe_lines(real_cmd)
109
6754a299 110def system(cmd):
4addad22 111 if verbose:
bb6e09b2 112 sys.stderr.write("executing %s\n" % cmd)
6754a299
HWN
113 if os.system(cmd) != 0:
114 die("command failed: %s" % cmd)
115
bf9320f1
AK
116def p4_system(cmd):
117 """Specifically invoke p4 as the system command. """
155af834 118 real_cmd = p4_build_cmd(cmd)
bf9320f1
AK
119 return system(real_cmd)
120
b9fc6ea9
DB
121def isP4Exec(kind):
122 """Determine if a Perforce 'kind' should have execute permission
123
124 'p4 help filetypes' gives a list of the types. If it starts with 'x',
125 or x follows one of a few letters. Otherwise, if there is an 'x' after
126 a plus sign, it is also executable"""
127 return (re.search(r"(^[cku]?x)|\+.*x", kind) != None)
128
c65b670e
CP
129def setP4ExecBit(file, mode):
130 # Reopens an already open file and changes the execute bit to match
131 # the execute bit setting in the passed in mode.
132
133 p4Type = "+x"
134
135 if not isModeExec(mode):
136 p4Type = getP4OpenedType(file)
137 p4Type = re.sub('^([cku]?)x(.*)', '\\1\\2', p4Type)
138 p4Type = re.sub('(.*?\+.*?)x(.*?)', '\\1\\2', p4Type)
139 if p4Type[-1] == "+":
140 p4Type = p4Type[0:-1]
141
87b611d5 142 p4_system("reopen -t %s %s" % (p4Type, file))
c65b670e
CP
143
144def getP4OpenedType(file):
145 # Returns the perforce file type for the given file.
146
a7d3ef9d 147 result = p4_read_pipe("opened %s" % file)
f3e5ae4f 148 match = re.match(".*\((.+)\)\r?$", result)
c65b670e
CP
149 if match:
150 return match.group(1)
151 else:
f3e5ae4f 152 die("Could not determine file type for %s (result: '%s')" % (file, result))
c65b670e 153
b43b0a3c
CP
154def diffTreePattern():
155 # This is a simple generator for the diff tree regex pattern. This could be
156 # a class variable if this and parseDiffTreeEntry were a part of a class.
157 pattern = re.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)')
158 while True:
159 yield pattern
160
161def parseDiffTreeEntry(entry):
162 """Parses a single diff tree entry into its component elements.
163
164 See git-diff-tree(1) manpage for details about the format of the diff
165 output. This method returns a dictionary with the following elements:
166
167 src_mode - The mode of the source file
168 dst_mode - The mode of the destination file
169 src_sha1 - The sha1 for the source file
170 dst_sha1 - The sha1 fr the destination file
171 status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc)
172 status_score - The score for the status (applicable for 'C' and 'R'
173 statuses). This is None if there is no score.
174 src - The path for the source file.
175 dst - The path for the destination file. This is only present for
176 copy or renames. If it is not present, this is None.
177
178 If the pattern is not matched, None is returned."""
179
180 match = diffTreePattern().next().match(entry)
181 if match:
182 return {
183 'src_mode': match.group(1),
184 'dst_mode': match.group(2),
185 'src_sha1': match.group(3),
186 'dst_sha1': match.group(4),
187 'status': match.group(5),
188 'status_score': match.group(6),
189 'src': match.group(7),
190 'dst': match.group(10)
191 }
192 return None
193
c65b670e
CP
194def isModeExec(mode):
195 # Returns True if the given git mode represents an executable file,
196 # otherwise False.
197 return mode[-3:] == "755"
198
199def isModeExecChanged(src_mode, dst_mode):
200 return isModeExec(src_mode) != isModeExec(dst_mode)
201
b932705b 202def p4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None):
155af834 203 cmd = p4_build_cmd("-G %s" % (cmd))
6a49f8e2
HWN
204 if verbose:
205 sys.stderr.write("Opening pipe: %s\n" % cmd)
9f90c733
SL
206
207 # Use a temporary file to avoid deadlocks without
208 # subprocess.communicate(), which would put another copy
209 # of stdout into memory.
210 stdin_file = None
211 if stdin is not None:
212 stdin_file = tempfile.TemporaryFile(prefix='p4-stdin', mode=stdin_mode)
213 stdin_file.write(stdin)
214 stdin_file.flush()
215 stdin_file.seek(0)
216
217 p4 = subprocess.Popen(cmd, shell=True,
218 stdin=stdin_file,
219 stdout=subprocess.PIPE)
86949eef
SH
220
221 result = []
222 try:
223 while True:
9f90c733 224 entry = marshal.load(p4.stdout)
b932705b
LD
225 if cb is not None:
226 cb(entry)
227 else:
228 result.append(entry)
86949eef
SH
229 except EOFError:
230 pass
9f90c733
SL
231 exitCode = p4.wait()
232 if exitCode != 0:
ac3e0d79
SH
233 entry = {}
234 entry["p4ExitCode"] = exitCode
235 result.append(entry)
86949eef
SH
236
237 return result
238
239def p4Cmd(cmd):
240 list = p4CmdList(cmd)
241 result = {}
242 for entry in list:
243 result.update(entry)
244 return result;
245
cb2c9db5
SH
246def p4Where(depotPath):
247 if not depotPath.endswith("/"):
248 depotPath += "/"
7f705dc3
TAL
249 depotPath = depotPath + "..."
250 outputList = p4CmdList("where %s" % depotPath)
251 output = None
252 for entry in outputList:
75bc9573
TAL
253 if "depotFile" in entry:
254 if entry["depotFile"] == depotPath:
255 output = entry
256 break
257 elif "data" in entry:
258 data = entry.get("data")
259 space = data.find(" ")
260 if data[:space] == depotPath:
261 output = entry
262 break
7f705dc3
TAL
263 if output == None:
264 return ""
dc524036
SH
265 if output["code"] == "error":
266 return ""
cb2c9db5
SH
267 clientPath = ""
268 if "path" in output:
269 clientPath = output.get("path")
270 elif "data" in output:
271 data = output.get("data")
272 lastSpace = data.rfind(" ")
273 clientPath = data[lastSpace + 1:]
274
275 if clientPath.endswith("..."):
276 clientPath = clientPath[:-3]
277 return clientPath
278
86949eef 279def currentGitBranch():
b25b2065 280 return read_pipe("git name-rev HEAD").split(" ")[1].strip()
86949eef 281
4f5cf76a 282def isValidGitDir(path):
bb6e09b2
HWN
283 if (os.path.exists(path + "/HEAD")
284 and os.path.exists(path + "/refs") and os.path.exists(path + "/objects")):
4f5cf76a
SH
285 return True;
286 return False
287
463e8af6 288def parseRevision(ref):
b25b2065 289 return read_pipe("git rev-parse %s" % ref).strip()
463e8af6 290
6ae8de88
SH
291def extractLogMessageFromGitCommit(commit):
292 logMessage = ""
b016d397
HWN
293
294 ## fixme: title is first line of commit, not 1st paragraph.
6ae8de88 295 foundTitle = False
b016d397 296 for log in read_pipe_lines("git cat-file commit %s" % commit):
6ae8de88
SH
297 if not foundTitle:
298 if len(log) == 1:
1c094184 299 foundTitle = True
6ae8de88
SH
300 continue
301
302 logMessage += log
303 return logMessage
304
bb6e09b2 305def extractSettingsGitLog(log):
6ae8de88
SH
306 values = {}
307 for line in log.split("\n"):
308 line = line.strip()
6326aa58
HWN
309 m = re.search (r"^ *\[git-p4: (.*)\]$", line)
310 if not m:
311 continue
312
313 assignments = m.group(1).split (':')
314 for a in assignments:
315 vals = a.split ('=')
316 key = vals[0].strip()
317 val = ('='.join (vals[1:])).strip()
318 if val.endswith ('\"') and val.startswith('"'):
319 val = val[1:-1]
320
321 values[key] = val
322
845b42cb
SH
323 paths = values.get("depot-paths")
324 if not paths:
325 paths = values.get("depot-path")
a3fdd579
SH
326 if paths:
327 values['depot-paths'] = paths.split(',')
bb6e09b2 328 return values
6ae8de88 329
8136a639 330def gitBranchExists(branch):
bb6e09b2
HWN
331 proc = subprocess.Popen(["git", "rev-parse", branch],
332 stderr=subprocess.PIPE, stdout=subprocess.PIPE);
caace111 333 return proc.wait() == 0;
8136a639 334
36bd8446 335_gitConfig = {}
01265103 336def gitConfig(key):
36bd8446
JC
337 if not _gitConfig.has_key(key):
338 _gitConfig[key] = read_pipe("git config %s" % key, ignore_error=True).strip()
339 return _gitConfig[key]
01265103 340
062410bb
SH
341def p4BranchesInGit(branchesAreInRemotes = True):
342 branches = {}
343
344 cmdline = "git rev-parse --symbolic "
345 if branchesAreInRemotes:
346 cmdline += " --remotes"
347 else:
348 cmdline += " --branches"
349
350 for line in read_pipe_lines(cmdline):
351 line = line.strip()
352
353 ## only import to p4/
354 if not line.startswith('p4/') or line == "p4/HEAD":
355 continue
356 branch = line
357
358 # strip off p4
359 branch = re.sub ("^p4/", "", line)
360
361 branches[branch] = parseRevision(line)
362 return branches
363
9ceab363 364def findUpstreamBranchPoint(head = "HEAD"):
86506fe5
SH
365 branches = p4BranchesInGit()
366 # map from depot-path to branch name
367 branchByDepotPath = {}
368 for branch in branches.keys():
369 tip = branches[branch]
370 log = extractLogMessageFromGitCommit(tip)
371 settings = extractSettingsGitLog(log)
372 if settings.has_key("depot-paths"):
373 paths = ",".join(settings["depot-paths"])
374 branchByDepotPath[paths] = "remotes/p4/" + branch
375
27d2d811 376 settings = None
27d2d811
SH
377 parent = 0
378 while parent < 65535:
9ceab363 379 commit = head + "~%s" % parent
27d2d811
SH
380 log = extractLogMessageFromGitCommit(commit)
381 settings = extractSettingsGitLog(log)
86506fe5
SH
382 if settings.has_key("depot-paths"):
383 paths = ",".join(settings["depot-paths"])
384 if branchByDepotPath.has_key(paths):
385 return [branchByDepotPath[paths], settings]
27d2d811 386
86506fe5 387 parent = parent + 1
27d2d811 388
86506fe5 389 return ["", settings]
27d2d811 390
5ca44617
SH
391def createOrUpdateBranchesFromOrigin(localRefPrefix = "refs/remotes/p4/", silent=True):
392 if not silent:
393 print ("Creating/updating branch(es) in %s based on origin branch(es)"
394 % localRefPrefix)
395
396 originPrefix = "origin/p4/"
397
398 for line in read_pipe_lines("git rev-parse --symbolic --remotes"):
399 line = line.strip()
400 if (not line.startswith(originPrefix)) or line.endswith("HEAD"):
401 continue
402
403 headName = line[len(originPrefix):]
404 remoteHead = localRefPrefix + headName
405 originHead = line
406
407 original = extractSettingsGitLog(extractLogMessageFromGitCommit(originHead))
408 if (not original.has_key('depot-paths')
409 or not original.has_key('change')):
410 continue
411
412 update = False
413 if not gitBranchExists(remoteHead):
414 if verbose:
415 print "creating %s" % remoteHead
416 update = True
417 else:
418 settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead))
419 if settings.has_key('change') > 0:
420 if settings['depot-paths'] == original['depot-paths']:
421 originP4Change = int(original['change'])
422 p4Change = int(settings['change'])
423 if originP4Change > p4Change:
424 print ("%s (%s) is newer than %s (%s). "
425 "Updating p4 branch from origin."
426 % (originHead, originP4Change,
427 remoteHead, p4Change))
428 update = True
429 else:
430 print ("Ignoring: %s was imported from %s while "
431 "%s was imported from %s"
432 % (originHead, ','.join(original['depot-paths']),
433 remoteHead, ','.join(settings['depot-paths'])))
434
435 if update:
436 system("git update-ref %s %s" % (remoteHead, originHead))
437
438def originP4BranchesExist():
439 return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
440
4f6432d8
SH
441def p4ChangesForPaths(depotPaths, changeRange):
442 assert depotPaths
b340fa43 443 output = p4_read_pipe_lines("changes " + ' '.join (["%s...%s" % (p, changeRange)
4f6432d8
SH
444 for p in depotPaths]))
445
b4b0ba06 446 changes = {}
4f6432d8 447 for line in output:
b4b0ba06
PW
448 changeNum = int(line.split(" ")[1])
449 changes[changeNum] = True
4f6432d8 450
b4b0ba06
PW
451 changelist = changes.keys()
452 changelist.sort()
453 return changelist
4f6432d8 454
b984733c
SH
455class Command:
456 def __init__(self):
457 self.usage = "usage: %prog [options]"
8910ac0e 458 self.needsGit = True
b984733c
SH
459
460class P4Debug(Command):
86949eef 461 def __init__(self):
6ae8de88 462 Command.__init__(self)
86949eef 463 self.options = [
b1ce9447
HWN
464 optparse.make_option("--verbose", dest="verbose", action="store_true",
465 default=False),
4addad22 466 ]
c8c39116 467 self.description = "A tool to debug the output of p4 -G."
8910ac0e 468 self.needsGit = False
b1ce9447 469 self.verbose = False
86949eef
SH
470
471 def run(self, args):
b1ce9447 472 j = 0
86949eef 473 for output in p4CmdList(" ".join(args)):
b1ce9447
HWN
474 print 'Element: %d' % j
475 j += 1
86949eef 476 print output
b984733c 477 return True
86949eef 478
5834684d
SH
479class P4RollBack(Command):
480 def __init__(self):
481 Command.__init__(self)
482 self.options = [
0c66a783
SH
483 optparse.make_option("--verbose", dest="verbose", action="store_true"),
484 optparse.make_option("--local", dest="rollbackLocalBranches", action="store_true")
5834684d
SH
485 ]
486 self.description = "A tool to debug the multi-branch import. Don't use :)"
52102d47 487 self.verbose = False
0c66a783 488 self.rollbackLocalBranches = False
5834684d
SH
489
490 def run(self, args):
491 if len(args) != 1:
492 return False
493 maxChange = int(args[0])
0c66a783 494
ad192f28 495 if "p4ExitCode" in p4Cmd("changes -m 1"):
66a2f523
SH
496 die("Problems executing p4");
497
0c66a783
SH
498 if self.rollbackLocalBranches:
499 refPrefix = "refs/heads/"
b016d397 500 lines = read_pipe_lines("git rev-parse --symbolic --branches")
0c66a783
SH
501 else:
502 refPrefix = "refs/remotes/"
b016d397 503 lines = read_pipe_lines("git rev-parse --symbolic --remotes")
0c66a783
SH
504
505 for line in lines:
506 if self.rollbackLocalBranches or (line.startswith("p4/") and line != "p4/HEAD\n"):
b25b2065
HWN
507 line = line.strip()
508 ref = refPrefix + line
5834684d 509 log = extractLogMessageFromGitCommit(ref)
bb6e09b2
HWN
510 settings = extractSettingsGitLog(log)
511
512 depotPaths = settings['depot-paths']
513 change = settings['change']
514
5834684d 515 changed = False
52102d47 516
6326aa58
HWN
517 if len(p4Cmd("changes -m 1 " + ' '.join (['%s...@%s' % (p, maxChange)
518 for p in depotPaths]))) == 0:
52102d47
SH
519 print "Branch %s did not exist at change %s, deleting." % (ref, maxChange)
520 system("git update-ref -d %s `git rev-parse %s`" % (ref, ref))
521 continue
522
bb6e09b2 523 while change and int(change) > maxChange:
5834684d 524 changed = True
52102d47
SH
525 if self.verbose:
526 print "%s is at %s ; rewinding towards %s" % (ref, change, maxChange)
5834684d
SH
527 system("git update-ref %s \"%s^\"" % (ref, ref))
528 log = extractLogMessageFromGitCommit(ref)
bb6e09b2
HWN
529 settings = extractSettingsGitLog(log)
530
531
532 depotPaths = settings['depot-paths']
533 change = settings['change']
5834684d
SH
534
535 if changed:
52102d47 536 print "%s rewound to %s" % (ref, change)
5834684d
SH
537
538 return True
539
711544b0 540class P4Submit(Command):
4f5cf76a 541 def __init__(self):
b984733c 542 Command.__init__(self)
4f5cf76a 543 self.options = [
4addad22 544 optparse.make_option("--verbose", dest="verbose", action="store_true"),
4f5cf76a 545 optparse.make_option("--origin", dest="origin"),
d9a5f25b 546 optparse.make_option("-M", dest="detectRename", action="store_true"),
4f5cf76a
SH
547 ]
548 self.description = "Submit changes from git to the perforce depot."
c9b50e63 549 self.usage += " [name of git branch to submit into perforce depot]"
4f5cf76a 550 self.interactive = True
9512497b 551 self.origin = ""
d9a5f25b 552 self.detectRename = False
b0d10df7 553 self.verbose = False
f7baba8b 554 self.isWindows = (platform.system() == "Windows")
4f5cf76a 555
4f5cf76a
SH
556 def check(self):
557 if len(p4CmdList("opened ...")) > 0:
558 die("You have files opened with perforce! Close them before starting the sync.")
559
edae1e2f
SH
560 # replaces everything between 'Description:' and the next P4 submit template field with the
561 # commit message
4f5cf76a
SH
562 def prepareLogMessage(self, template, message):
563 result = ""
564
edae1e2f
SH
565 inDescriptionSection = False
566
4f5cf76a
SH
567 for line in template.split("\n"):
568 if line.startswith("#"):
569 result += line + "\n"
570 continue
571
edae1e2f
SH
572 if inDescriptionSection:
573 if line.startswith("Files:"):
574 inDescriptionSection = False
575 else:
576 continue
577 else:
578 if line.startswith("Description:"):
579 inDescriptionSection = True
580 line += "\n"
581 for messageLine in message.split("\n"):
582 line += "\t" + messageLine + "\n"
583
584 result += line + "\n"
4f5cf76a
SH
585
586 return result
587
ea99c3ae
SH
588 def prepareSubmitTemplate(self):
589 # remove lines in the Files section that show changes to files outside the depot path we're committing into
590 template = ""
591 inFilesSection = False
b340fa43 592 for line in p4_read_pipe_lines("change -o"):
f3e5ae4f
MSO
593 if line.endswith("\r\n"):
594 line = line[:-2] + "\n"
ea99c3ae
SH
595 if inFilesSection:
596 if line.startswith("\t"):
597 # path starts and ends with a tab
598 path = line[1:]
599 lastTab = path.rfind("\t")
600 if lastTab != -1:
601 path = path[:lastTab]
602 if not path.startswith(self.depotPath):
603 continue
604 else:
605 inFilesSection = False
606 else:
607 if line.startswith("Files:"):
608 inFilesSection = True
609
610 template += line
611
612 return template
613
7cb5cbef 614 def applyCommit(self, id):
0e36f2d7
SH
615 print "Applying %s" % (read_pipe("git log --max-count=1 --pretty=oneline %s" % id))
616 diffOpts = ("", "-M")[self.detectRename]
617 diff = read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (diffOpts, id, id))
4f5cf76a
SH
618 filesToAdd = set()
619 filesToDelete = set()
d336c158 620 editedFiles = set()
c65b670e 621 filesToChangeExecBit = {}
4f5cf76a 622 for line in diff:
b43b0a3c
CP
623 diff = parseDiffTreeEntry(line)
624 modifier = diff['status']
625 path = diff['src']
4f5cf76a 626 if modifier == "M":
87b611d5 627 p4_system("edit \"%s\"" % path)
c65b670e
CP
628 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
629 filesToChangeExecBit[path] = diff['dst_mode']
d336c158 630 editedFiles.add(path)
4f5cf76a
SH
631 elif modifier == "A":
632 filesToAdd.add(path)
c65b670e 633 filesToChangeExecBit[path] = diff['dst_mode']
4f5cf76a
SH
634 if path in filesToDelete:
635 filesToDelete.remove(path)
636 elif modifier == "D":
637 filesToDelete.add(path)
638 if path in filesToAdd:
639 filesToAdd.remove(path)
d9a5f25b 640 elif modifier == "R":
b43b0a3c 641 src, dest = diff['src'], diff['dst']
87b611d5
AK
642 p4_system("integrate -Dt \"%s\" \"%s\"" % (src, dest))
643 p4_system("edit \"%s\"" % (dest))
c65b670e
CP
644 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
645 filesToChangeExecBit[dest] = diff['dst_mode']
d9a5f25b
CP
646 os.unlink(dest)
647 editedFiles.add(dest)
648 filesToDelete.add(src)
4f5cf76a
SH
649 else:
650 die("unknown modifier %s for %s" % (modifier, path))
651
0e36f2d7 652 diffcmd = "git format-patch -k --stdout \"%s^\"..\"%s\"" % (id, id)
47a130b7 653 patchcmd = diffcmd + " | git apply "
c1b296b9
SH
654 tryPatchCmd = patchcmd + "--check -"
655 applyPatchCmd = patchcmd + "--check --apply -"
51a2640a 656
47a130b7 657 if os.system(tryPatchCmd) != 0:
51a2640a
SH
658 print "Unfortunately applying the change failed!"
659 print "What do you want to do?"
660 response = "x"
661 while response != "s" and response != "a" and response != "w":
cebdf5af
HWN
662 response = raw_input("[s]kip this patch / [a]pply the patch forcibly "
663 "and with .rej files / [w]rite the patch to a file (patch.txt) ")
51a2640a
SH
664 if response == "s":
665 print "Skipping! Good luck with the next patches..."
20947149 666 for f in editedFiles:
87b611d5 667 p4_system("revert \"%s\"" % f);
20947149
SH
668 for f in filesToAdd:
669 system("rm %s" %f)
51a2640a
SH
670 return
671 elif response == "a":
47a130b7 672 os.system(applyPatchCmd)
51a2640a
SH
673 if len(filesToAdd) > 0:
674 print "You may also want to call p4 add on the following files:"
675 print " ".join(filesToAdd)
676 if len(filesToDelete):
677 print "The following files should be scheduled for deletion with p4 delete:"
678 print " ".join(filesToDelete)
cebdf5af
HWN
679 die("Please resolve and submit the conflict manually and "
680 + "continue afterwards with git-p4 submit --continue")
51a2640a
SH
681 elif response == "w":
682 system(diffcmd + " > patch.txt")
683 print "Patch saved to patch.txt in %s !" % self.clientPath
cebdf5af
HWN
684 die("Please resolve and submit the conflict manually and "
685 "continue afterwards with git-p4 submit --continue")
51a2640a 686
47a130b7 687 system(applyPatchCmd)
4f5cf76a
SH
688
689 for f in filesToAdd:
87b611d5 690 p4_system("add \"%s\"" % f)
4f5cf76a 691 for f in filesToDelete:
87b611d5
AK
692 p4_system("revert \"%s\"" % f)
693 p4_system("delete \"%s\"" % f)
4f5cf76a 694
c65b670e
CP
695 # Set/clear executable bits
696 for f in filesToChangeExecBit.keys():
697 mode = filesToChangeExecBit[f]
698 setP4ExecBit(f, mode)
699
0e36f2d7 700 logMessage = extractLogMessageFromGitCommit(id)
0e36f2d7 701 logMessage = logMessage.strip()
4f5cf76a 702
ea99c3ae 703 template = self.prepareSubmitTemplate()
4f5cf76a
SH
704
705 if self.interactive:
706 submitTemplate = self.prepareLogMessage(template, logMessage)
67abd417
SB
707 if os.environ.has_key("P4DIFF"):
708 del(os.environ["P4DIFF"])
a7d3ef9d 709 diff = p4_read_pipe("diff -du ...")
4f5cf76a 710
f3e5ae4f 711 newdiff = ""
4f5cf76a 712 for newFile in filesToAdd:
f3e5ae4f
MSO
713 newdiff += "==== new file ====\n"
714 newdiff += "--- /dev/null\n"
715 newdiff += "+++ %s\n" % newFile
4f5cf76a
SH
716 f = open(newFile, "r")
717 for line in f.readlines():
f3e5ae4f 718 newdiff += "+" + line
4f5cf76a
SH
719 f.close()
720
f3e5ae4f 721 separatorLine = "######## everything below this line is just the diff #######\n"
4f5cf76a 722
e96e400f
SH
723 [handle, fileName] = tempfile.mkstemp()
724 tmpFile = os.fdopen(handle, "w+")
f3e5ae4f
MSO
725 if self.isWindows:
726 submitTemplate = submitTemplate.replace("\n", "\r\n")
727 separatorLine = separatorLine.replace("\n", "\r\n")
728 newdiff = newdiff.replace("\n", "\r\n")
729 tmpFile.write(submitTemplate + separatorLine + diff + newdiff)
e96e400f 730 tmpFile.close()
cdc7e388 731 mtime = os.stat(fileName).st_mtime
82cea9ff
SB
732 if os.environ.has_key("P4EDITOR"):
733 editor = os.environ.get("P4EDITOR")
734 else:
8b187e6b 735 editor = read_pipe("git var GIT_EDITOR").strip()
e96e400f 736 system(editor + " " + fileName)
e96e400f 737
cdc7e388
SH
738 response = "y"
739 if os.stat(fileName).st_mtime <= mtime:
740 response = "x"
741 while response != "y" and response != "n":
742 response = raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")
743
744 if response == "y":
745 tmpFile = open(fileName, "rb")
746 message = tmpFile.read()
747 tmpFile.close()
748 submitTemplate = message[:message.index(separatorLine)]
749 if self.isWindows:
750 submitTemplate = submitTemplate.replace("\r\n", "\n")
751 p4_write_pipe("submit -i", submitTemplate)
752 else:
753 for f in editedFiles:
754 p4_system("revert \"%s\"" % f);
755 for f in filesToAdd:
756 p4_system("revert \"%s\"" % f);
757 system("rm %s" %f)
758
759 os.remove(fileName)
4f5cf76a
SH
760 else:
761 fileName = "submit.txt"
762 file = open(fileName, "w+")
763 file.write(self.prepareLogMessage(template, logMessage))
764 file.close()
cebdf5af
HWN
765 print ("Perforce submit template written as %s. "
766 + "Please review/edit and then use p4 submit -i < %s to submit directly!"
767 % (fileName, fileName))
4f5cf76a
SH
768
769 def run(self, args):
c9b50e63
SH
770 if len(args) == 0:
771 self.master = currentGitBranch()
4280e533 772 if len(self.master) == 0 or not gitBranchExists("refs/heads/%s" % self.master):
c9b50e63
SH
773 die("Detecting current git branch failed!")
774 elif len(args) == 1:
775 self.master = args[0]
776 else:
777 return False
778
4c2d5d72
JX
779 allowSubmit = gitConfig("git-p4.allowSubmit")
780 if len(allowSubmit) > 0 and not self.master in allowSubmit.split(","):
781 die("%s is not in git-p4.allowSubmit" % self.master)
782
27d2d811 783 [upstream, settings] = findUpstreamBranchPoint()
ea99c3ae 784 self.depotPath = settings['depot-paths'][0]
27d2d811
SH
785 if len(self.origin) == 0:
786 self.origin = upstream
a3fdd579
SH
787
788 if self.verbose:
789 print "Origin branch is " + self.origin
9512497b 790
ea99c3ae 791 if len(self.depotPath) == 0:
9512497b
SH
792 print "Internal error: cannot locate perforce depot path from existing branches"
793 sys.exit(128)
794
ea99c3ae 795 self.clientPath = p4Where(self.depotPath)
9512497b 796
51a2640a 797 if len(self.clientPath) == 0:
ea99c3ae 798 print "Error: Cannot locate perforce checkout of %s in client view" % self.depotPath
9512497b
SH
799 sys.exit(128)
800
ea99c3ae 801 print "Perforce checkout for depot path %s located at %s" % (self.depotPath, self.clientPath)
7944f142 802 self.oldWorkingDirectory = os.getcwd()
c1b296b9 803
053fd0c1 804 chdir(self.clientPath)
31f9ec12 805 print "Syncronizing p4 checkout..."
87b611d5 806 p4_system("sync ...")
9512497b 807
4f5cf76a 808 self.check()
4f5cf76a 809
4c750c0d
SH
810 commits = []
811 for line in read_pipe_lines("git rev-list --no-merges %s..%s" % (self.origin, self.master)):
812 commits.append(line.strip())
813 commits.reverse()
4f5cf76a
SH
814
815 while len(commits) > 0:
4f5cf76a
SH
816 commit = commits[0]
817 commits = commits[1:]
7cb5cbef 818 self.applyCommit(commit)
4f5cf76a
SH
819 if not self.interactive:
820 break
821
4f5cf76a 822 if len(commits) == 0:
4c750c0d 823 print "All changes applied!"
053fd0c1 824 chdir(self.oldWorkingDirectory)
14594f4b 825
4c750c0d
SH
826 sync = P4Sync()
827 sync.run([])
14594f4b 828
4c750c0d
SH
829 rebase = P4Rebase()
830 rebase.rebase()
4f5cf76a 831
b984733c
SH
832 return True
833
711544b0 834class P4Sync(Command):
b984733c
SH
835 def __init__(self):
836 Command.__init__(self)
837 self.options = [
838 optparse.make_option("--branch", dest="branch"),
839 optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"),
840 optparse.make_option("--changesfile", dest="changesFile"),
841 optparse.make_option("--silent", dest="silent", action="store_true"),
ef48f909 842 optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),
a028a98e 843 optparse.make_option("--verbose", dest="verbose", action="store_true"),
d2c6dd30
HWN
844 optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",
845 help="Import into refs/heads/ , not refs/remotes"),
8b41a97f 846 optparse.make_option("--max-changes", dest="maxChanges"),
86dff6b6 847 optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',
3a70cdfa
TAL
848 help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),
849 optparse.make_option("--use-client-spec", dest="useClientSpec", action='store_true',
850 help="Only sync files that are included in the Perforce Client Spec")
b984733c
SH
851 ]
852 self.description = """Imports from Perforce into a git repository.\n
853 example:
854 //depot/my/project/ -- to import the current head
855 //depot/my/project/@all -- to import everything
856 //depot/my/project/@1,6 -- to import only from revision 1 to 6
857
858 (a ... is not needed in the path p4 specification, it's added implicitly)"""
859
860 self.usage += " //depot/path[@revRange]"
b984733c 861 self.silent = False
1d7367dc
RG
862 self.createdBranches = set()
863 self.committedChanges = set()
569d1bd4 864 self.branch = ""
b984733c 865 self.detectBranches = False
cb53e1f8 866 self.detectLabels = False
b984733c 867 self.changesFile = ""
01265103 868 self.syncWithOrigin = True
4b97ffb1 869 self.verbose = False
a028a98e 870 self.importIntoRemotes = True
01a9c9c5 871 self.maxChanges = ""
c1f9197f 872 self.isWindows = (platform.system() == "Windows")
8b41a97f 873 self.keepRepoPath = False
6326aa58 874 self.depotPaths = None
3c699645 875 self.p4BranchesInGit = []
354081d5 876 self.cloneExclude = []
3a70cdfa
TAL
877 self.useClientSpec = False
878 self.clientSpecDirs = []
b984733c 879
01265103
SH
880 if gitConfig("git-p4.syncFromOrigin") == "false":
881 self.syncWithOrigin = False
882
b984733c 883 def extractFilesFromCommit(self, commit):
354081d5
TT
884 self.cloneExclude = [re.sub(r"\.\.\.$", "", path)
885 for path in self.cloneExclude]
b984733c
SH
886 files = []
887 fnum = 0
888 while commit.has_key("depotFile%s" % fnum):
889 path = commit["depotFile%s" % fnum]
6326aa58 890
354081d5
TT
891 if [p for p in self.cloneExclude
892 if path.startswith (p)]:
893 found = False
894 else:
895 found = [p for p in self.depotPaths
896 if path.startswith (p)]
6326aa58 897 if not found:
b984733c
SH
898 fnum = fnum + 1
899 continue
900
901 file = {}
902 file["path"] = path
903 file["rev"] = commit["rev%s" % fnum]
904 file["action"] = commit["action%s" % fnum]
905 file["type"] = commit["type%s" % fnum]
906 files.append(file)
907 fnum = fnum + 1
908 return files
909
6326aa58 910 def stripRepoPath(self, path, prefixes):
8b41a97f 911 if self.keepRepoPath:
6326aa58
HWN
912 prefixes = [re.sub("^(//[^/]+/).*", r'\1', prefixes[0])]
913
914 for p in prefixes:
915 if path.startswith(p):
916 path = path[len(p):]
8b41a97f 917
6326aa58 918 return path
6754a299 919
71b112d4 920 def splitFilesIntoBranches(self, commit):
d5904674 921 branches = {}
71b112d4
SH
922 fnum = 0
923 while commit.has_key("depotFile%s" % fnum):
924 path = commit["depotFile%s" % fnum]
6326aa58
HWN
925 found = [p for p in self.depotPaths
926 if path.startswith (p)]
927 if not found:
71b112d4
SH
928 fnum = fnum + 1
929 continue
930
931 file = {}
932 file["path"] = path
933 file["rev"] = commit["rev%s" % fnum]
934 file["action"] = commit["action%s" % fnum]
935 file["type"] = commit["type%s" % fnum]
936 fnum = fnum + 1
937
6326aa58 938 relPath = self.stripRepoPath(path, self.depotPaths)
b984733c 939
4b97ffb1 940 for branch in self.knownBranches.keys():
6754a299
HWN
941
942 # add a trailing slash so that a commit into qt/4.2foo doesn't end up in qt/4.2
943 if relPath.startswith(branch + "/"):
d5904674
SH
944 if branch not in branches:
945 branches[branch] = []
71b112d4 946 branches[branch].append(file)
6555b2cc 947 break
b984733c
SH
948
949 return branches
950
b932705b
LD
951 # output one file from the P4 stream
952 # - helper for streamP4Files
953
954 def streamOneP4File(self, file, contents):
955 if file["type"] == "apple":
956 print "\nfile %s is a strange apple file that forks. Ignoring" % \
957 file['depotFile']
958 return
959
960 relPath = self.stripRepoPath(file['depotFile'], self.branchPrefixes)
961 if verbose:
962 sys.stderr.write("%s\n" % relPath)
963
964 mode = "644"
965 if isP4Exec(file["type"]):
966 mode = "755"
967 elif file["type"] == "symlink":
968 mode = "120000"
969 # p4 print on a symlink contains "target\n", so strip it off
970 last = contents.pop()
971 last = last[:-1]
972 contents.append(last)
973
974 if self.isWindows and file["type"].endswith("text"):
975 mangled = []
976 for data in contents:
977 data = data.replace("\r\n", "\n")
978 mangled.append(data)
979 contents = mangled
980
981 if file['type'] in ('text+ko', 'unicode+ko', 'binary+ko'):
982 contents = map(lambda text: re.sub(r'(?i)\$(Id|Header):[^$]*\$',r'$\1$', text), contents)
983 elif file['type'] in ('text+k', 'ktext', 'kxtext', 'unicode+k', 'binary+k'):
984 contents = map(lambda text: re.sub(r'\$(Id|Header|Author|Date|DateTime|Change|File|Revision):[^$\n]*\$',r'$\1$', text), contents)
985
986 self.gitStream.write("M %s inline %s\n" % (mode, relPath))
987
988 # total length...
989 length = 0
990 for d in contents:
991 length = length + len(d)
992
993 self.gitStream.write("data %d\n" % length)
994 for d in contents:
995 self.gitStream.write(d)
996 self.gitStream.write("\n")
997
998 def streamOneP4Deletion(self, file):
999 relPath = self.stripRepoPath(file['path'], self.branchPrefixes)
1000 if verbose:
1001 sys.stderr.write("delete %s\n" % relPath)
1002 self.gitStream.write("D %s\n" % relPath)
1003
1004 # handle another chunk of streaming data
1005 def streamP4FilesCb(self, marshalled):
1006
1007 if marshalled.has_key('depotFile') and self.stream_have_file_info:
1008 # start of a new file - output the old one first
1009 self.streamOneP4File(self.stream_file, self.stream_contents)
1010 self.stream_file = {}
1011 self.stream_contents = []
1012 self.stream_have_file_info = False
1013
1014 # pick up the new file information... for the
1015 # 'data' field we need to append to our array
1016 for k in marshalled.keys():
1017 if k == 'data':
1018 self.stream_contents.append(marshalled['data'])
1019 else:
1020 self.stream_file[k] = marshalled[k]
1021
1022 self.stream_have_file_info = True
1023
1024 # Stream directly from "p4 files" into "git fast-import"
1025 def streamP4Files(self, files):
30b5940b
SH
1026 filesForCommit = []
1027 filesToRead = []
b932705b 1028 filesToDelete = []
30b5940b 1029
3a70cdfa 1030 for f in files:
30b5940b 1031 includeFile = True
3a70cdfa
TAL
1032 for val in self.clientSpecDirs:
1033 if f['path'].startswith(val[0]):
30b5940b
SH
1034 if val[1] <= 0:
1035 includeFile = False
3a70cdfa
TAL
1036 break
1037
30b5940b
SH
1038 if includeFile:
1039 filesForCommit.append(f)
562d53fa 1040 if f['action'] not in ('delete', 'move/delete', 'purge'):
30b5940b 1041 filesToRead.append(f)
b932705b
LD
1042 else:
1043 filesToDelete.append(f)
6a49f8e2 1044
b932705b
LD
1045 # deleted files...
1046 for f in filesToDelete:
1047 self.streamOneP4Deletion(f)
1b9a4684 1048
b932705b
LD
1049 if len(filesToRead) > 0:
1050 self.stream_file = {}
1051 self.stream_contents = []
1052 self.stream_have_file_info = False
8ff45f2a 1053
b932705b
LD
1054 # curry self argument
1055 def streamP4FilesCbSelf(entry):
1056 self.streamP4FilesCb(entry)
6a49f8e2 1057
b932705b
LD
1058 p4CmdList("-x - print",
1059 '\n'.join(['%s#%s' % (f['path'], f['rev'])
1060 for f in filesToRead]),
1061 cb=streamP4FilesCbSelf)
30b5940b 1062
b932705b
LD
1063 # do the last chunk
1064 if self.stream_file.has_key('depotFile'):
1065 self.streamOneP4File(self.stream_file, self.stream_contents)
6a49f8e2 1066
6326aa58 1067 def commit(self, details, files, branch, branchPrefixes, parent = ""):
b984733c
SH
1068 epoch = details["time"]
1069 author = details["user"]
b932705b 1070 self.branchPrefixes = branchPrefixes
b984733c 1071
4b97ffb1
SH
1072 if self.verbose:
1073 print "commit into %s" % branch
1074
96e07dd2
HWN
1075 # start with reading files; if that fails, we should not
1076 # create a commit.
1077 new_files = []
1078 for f in files:
1079 if [p for p in branchPrefixes if f['path'].startswith(p)]:
1080 new_files.append (f)
1081 else:
1082 sys.stderr.write("Ignoring file outside of prefix: %s\n" % path)
96e07dd2 1083
b984733c 1084 self.gitStream.write("commit %s\n" % branch)
6a49f8e2 1085# gitStream.write("mark :%s\n" % details["change"])
b984733c
SH
1086 self.committedChanges.add(int(details["change"]))
1087 committer = ""
b607e71e
SH
1088 if author not in self.users:
1089 self.getUserMapFromPerforceServer()
b984733c 1090 if author in self.users:
0828ab14 1091 committer = "%s %s %s" % (self.users[author], epoch, self.tz)
b984733c 1092 else:
0828ab14 1093 committer = "%s <a@b> %s %s" % (author, epoch, self.tz)
b984733c
SH
1094
1095 self.gitStream.write("committer %s\n" % committer)
1096
1097 self.gitStream.write("data <<EOT\n")
1098 self.gitStream.write(details["desc"])
6581de09
SH
1099 self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s"
1100 % (','.join (branchPrefixes), details["change"]))
1101 if len(details['options']) > 0:
1102 self.gitStream.write(": options = %s" % details['options'])
1103 self.gitStream.write("]\nEOT\n\n")
b984733c
SH
1104
1105 if len(parent) > 0:
4b97ffb1
SH
1106 if self.verbose:
1107 print "parent %s" % parent
b984733c
SH
1108 self.gitStream.write("from %s\n" % parent)
1109
b932705b 1110 self.streamP4Files(new_files)
b984733c
SH
1111 self.gitStream.write("\n")
1112
1f4ba1cb
SH
1113 change = int(details["change"])
1114
9bda3a85 1115 if self.labels.has_key(change):
1f4ba1cb
SH
1116 label = self.labels[change]
1117 labelDetails = label[0]
1118 labelRevisions = label[1]
71b112d4
SH
1119 if self.verbose:
1120 print "Change %s is labelled %s" % (change, labelDetails)
1f4ba1cb 1121
6326aa58
HWN
1122 files = p4CmdList("files " + ' '.join (["%s...@%s" % (p, change)
1123 for p in branchPrefixes]))
1f4ba1cb
SH
1124
1125 if len(files) == len(labelRevisions):
1126
1127 cleanedFiles = {}
1128 for info in files:
7f96e2e2 1129 if info["action"] in ("delete", "purge"):
1f4ba1cb
SH
1130 continue
1131 cleanedFiles[info["depotFile"]] = info["rev"]
1132
1133 if cleanedFiles == labelRevisions:
1134 self.gitStream.write("tag tag_%s\n" % labelDetails["label"])
1135 self.gitStream.write("from %s\n" % branch)
1136
1137 owner = labelDetails["Owner"]
1138 tagger = ""
1139 if author in self.users:
1140 tagger = "%s %s %s" % (self.users[owner], epoch, self.tz)
1141 else:
1142 tagger = "%s <a@b> %s %s" % (owner, epoch, self.tz)
1143 self.gitStream.write("tagger %s\n" % tagger)
1144 self.gitStream.write("data <<EOT\n")
1145 self.gitStream.write(labelDetails["Description"])
1146 self.gitStream.write("EOT\n\n")
1147
1148 else:
a46668fa 1149 if not self.silent:
cebdf5af
HWN
1150 print ("Tag %s does not match with change %s: files do not match."
1151 % (labelDetails["label"], change))
1f4ba1cb
SH
1152
1153 else:
a46668fa 1154 if not self.silent:
cebdf5af
HWN
1155 print ("Tag %s does not match with change %s: file count is different."
1156 % (labelDetails["label"], change))
b984733c 1157
183b8ef8 1158 def getUserCacheFilename(self):
b2d2d16a
SH
1159 home = os.environ.get("HOME", os.environ.get("USERPROFILE"))
1160 return home + "/.gitp4-usercache.txt"
183b8ef8 1161
b607e71e 1162 def getUserMapFromPerforceServer(self):
ebd81168
SH
1163 if self.userMapFromPerforceServer:
1164 return
b984733c
SH
1165 self.users = {}
1166
1167 for output in p4CmdList("users"):
1168 if not output.has_key("User"):
1169 continue
1170 self.users[output["User"]] = output["FullName"] + " <" + output["Email"] + ">"
1171
183b8ef8
HWN
1172
1173 s = ''
1174 for (key, val) in self.users.items():
3b167396 1175 s += "%s\t%s\n" % (key.expandtabs(1), val.expandtabs(1))
183b8ef8
HWN
1176
1177 open(self.getUserCacheFilename(), "wb").write(s)
ebd81168 1178 self.userMapFromPerforceServer = True
b607e71e
SH
1179
1180 def loadUserMapFromCache(self):
1181 self.users = {}
ebd81168 1182 self.userMapFromPerforceServer = False
b607e71e 1183 try:
183b8ef8 1184 cache = open(self.getUserCacheFilename(), "rb")
b607e71e
SH
1185 lines = cache.readlines()
1186 cache.close()
1187 for line in lines:
b25b2065 1188 entry = line.strip().split("\t")
b607e71e
SH
1189 self.users[entry[0]] = entry[1]
1190 except IOError:
1191 self.getUserMapFromPerforceServer()
1192
1f4ba1cb
SH
1193 def getLabels(self):
1194 self.labels = {}
1195
6326aa58 1196 l = p4CmdList("labels %s..." % ' '.join (self.depotPaths))
10c3211b 1197 if len(l) > 0 and not self.silent:
183f8436 1198 print "Finding files belonging to labels in %s" % `self.depotPaths`
01ce1fe9
SH
1199
1200 for output in l:
1f4ba1cb
SH
1201 label = output["label"]
1202 revisions = {}
1203 newestChange = 0
71b112d4
SH
1204 if self.verbose:
1205 print "Querying files for label %s" % label
6326aa58
HWN
1206 for file in p4CmdList("files "
1207 + ' '.join (["%s...@%s" % (p, label)
1208 for p in self.depotPaths])):
1f4ba1cb
SH
1209 revisions[file["depotFile"]] = file["rev"]
1210 change = int(file["change"])
1211 if change > newestChange:
1212 newestChange = change
1213
9bda3a85
SH
1214 self.labels[newestChange] = [output, revisions]
1215
1216 if self.verbose:
1217 print "Label changes: %s" % self.labels.keys()
1f4ba1cb 1218
86dff6b6
HWN
1219 def guessProjectName(self):
1220 for p in self.depotPaths:
6e5295c4
SH
1221 if p.endswith("/"):
1222 p = p[:-1]
1223 p = p[p.strip().rfind("/") + 1:]
1224 if not p.endswith("/"):
1225 p += "/"
1226 return p
86dff6b6 1227
4b97ffb1 1228 def getBranchMapping(self):
6555b2cc
SH
1229 lostAndFoundBranches = set()
1230
4b97ffb1
SH
1231 for info in p4CmdList("branches"):
1232 details = p4Cmd("branch -o %s" % info["branch"])
1233 viewIdx = 0
1234 while details.has_key("View%s" % viewIdx):
1235 paths = details["View%s" % viewIdx].split(" ")
1236 viewIdx = viewIdx + 1
1237 # require standard //depot/foo/... //depot/bar/... mapping
1238 if len(paths) != 2 or not paths[0].endswith("/...") or not paths[1].endswith("/..."):
1239 continue
1240 source = paths[0]
1241 destination = paths[1]
6509e19c
SH
1242 ## HACK
1243 if source.startswith(self.depotPaths[0]) and destination.startswith(self.depotPaths[0]):
1244 source = source[len(self.depotPaths[0]):-4]
1245 destination = destination[len(self.depotPaths[0]):-4]
6555b2cc 1246
1a2edf4e
SH
1247 if destination in self.knownBranches:
1248 if not self.silent:
1249 print "p4 branch %s defines a mapping from %s to %s" % (info["branch"], source, destination)
1250 print "but there exists another mapping from %s to %s already!" % (self.knownBranches[destination], destination)
1251 continue
1252
6555b2cc
SH
1253 self.knownBranches[destination] = source
1254
1255 lostAndFoundBranches.discard(destination)
1256
29bdbac1 1257 if source not in self.knownBranches:
6555b2cc
SH
1258 lostAndFoundBranches.add(source)
1259
1260
1261 for branch in lostAndFoundBranches:
1262 self.knownBranches[branch] = branch
29bdbac1 1263
38f9f5ec
SH
1264 def getBranchMappingFromGitBranches(self):
1265 branches = p4BranchesInGit(self.importIntoRemotes)
1266 for branch in branches.keys():
1267 if branch == "master":
1268 branch = "main"
1269 else:
1270 branch = branch[len(self.projectName):]
1271 self.knownBranches[branch] = branch
1272
29bdbac1 1273 def listExistingP4GitBranches(self):
144ff46b
SH
1274 # branches holds mapping from name to commit
1275 branches = p4BranchesInGit(self.importIntoRemotes)
1276 self.p4BranchesInGit = branches.keys()
1277 for branch in branches.keys():
1278 self.initialParents[self.refPrefix + branch] = branches[branch]
4b97ffb1 1279
bb6e09b2
HWN
1280 def updateOptionDict(self, d):
1281 option_keys = {}
1282 if self.keepRepoPath:
1283 option_keys['keepRepoPath'] = 1
1284
1285 d["options"] = ' '.join(sorted(option_keys.keys()))
1286
1287 def readOptions(self, d):
1288 self.keepRepoPath = (d.has_key('options')
1289 and ('keepRepoPath' in d['options']))
6326aa58 1290
8134f69c
SH
1291 def gitRefForBranch(self, branch):
1292 if branch == "main":
1293 return self.refPrefix + "master"
1294
1295 if len(branch) <= 0:
1296 return branch
1297
1298 return self.refPrefix + self.projectName + branch
1299
1ca3d710
SH
1300 def gitCommitByP4Change(self, ref, change):
1301 if self.verbose:
1302 print "looking in ref " + ref + " for change %s using bisect..." % change
1303
1304 earliestCommit = ""
1305 latestCommit = parseRevision(ref)
1306
1307 while True:
1308 if self.verbose:
1309 print "trying: earliest %s latest %s" % (earliestCommit, latestCommit)
1310 next = read_pipe("git rev-list --bisect %s %s" % (latestCommit, earliestCommit)).strip()
1311 if len(next) == 0:
1312 if self.verbose:
1313 print "argh"
1314 return ""
1315 log = extractLogMessageFromGitCommit(next)
1316 settings = extractSettingsGitLog(log)
1317 currentChange = int(settings['change'])
1318 if self.verbose:
1319 print "current change %s" % currentChange
1320
1321 if currentChange == change:
1322 if self.verbose:
1323 print "found %s" % next
1324 return next
1325
1326 if currentChange < change:
1327 earliestCommit = "^%s" % next
1328 else:
1329 latestCommit = "%s" % next
1330
1331 return ""
1332
1333 def importNewBranch(self, branch, maxChange):
1334 # make fast-import flush all changes to disk and update the refs using the checkpoint
1335 # command so that we can try to find the branch parent in the git history
1336 self.gitStream.write("checkpoint\n\n");
1337 self.gitStream.flush();
1338 branchPrefix = self.depotPaths[0] + branch + "/"
1339 range = "@1,%s" % maxChange
1340 #print "prefix" + branchPrefix
1341 changes = p4ChangesForPaths([branchPrefix], range)
1342 if len(changes) <= 0:
1343 return False
1344 firstChange = changes[0]
1345 #print "first change in branch: %s" % firstChange
1346 sourceBranch = self.knownBranches[branch]
1347 sourceDepotPath = self.depotPaths[0] + sourceBranch
1348 sourceRef = self.gitRefForBranch(sourceBranch)
1349 #print "source " + sourceBranch
1350
1351 branchParentChange = int(p4Cmd("changes -m 1 %s...@1,%s" % (sourceDepotPath, firstChange))["change"])
1352 #print "branch parent: %s" % branchParentChange
1353 gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)
1354 if len(gitParent) > 0:
1355 self.initialParents[self.gitRefForBranch(branch)] = gitParent
1356 #print "parent git commit: %s" % gitParent
1357
1358 self.importChanges(changes)
1359 return True
1360
e87f37ae
SH
1361 def importChanges(self, changes):
1362 cnt = 1
1363 for change in changes:
1364 description = p4Cmd("describe %s" % change)
1365 self.updateOptionDict(description)
1366
1367 if not self.silent:
1368 sys.stdout.write("\rImporting revision %s (%s%%)" % (change, cnt * 100 / len(changes)))
1369 sys.stdout.flush()
1370 cnt = cnt + 1
1371
1372 try:
1373 if self.detectBranches:
1374 branches = self.splitFilesIntoBranches(description)
1375 for branch in branches.keys():
1376 ## HACK --hwn
1377 branchPrefix = self.depotPaths[0] + branch + "/"
1378
1379 parent = ""
1380
1381 filesForCommit = branches[branch]
1382
1383 if self.verbose:
1384 print "branch is %s" % branch
1385
1386 self.updatedBranches.add(branch)
1387
1388 if branch not in self.createdBranches:
1389 self.createdBranches.add(branch)
1390 parent = self.knownBranches[branch]
1391 if parent == branch:
1392 parent = ""
1ca3d710
SH
1393 else:
1394 fullBranch = self.projectName + branch
1395 if fullBranch not in self.p4BranchesInGit:
1396 if not self.silent:
1397 print("\n Importing new branch %s" % fullBranch);
1398 if self.importNewBranch(branch, change - 1):
1399 parent = ""
1400 self.p4BranchesInGit.append(fullBranch)
1401 if not self.silent:
1402 print("\n Resuming with change %s" % change);
1403
1404 if self.verbose:
1405 print "parent determined through known branches: %s" % parent
e87f37ae 1406
8134f69c
SH
1407 branch = self.gitRefForBranch(branch)
1408 parent = self.gitRefForBranch(parent)
e87f37ae
SH
1409
1410 if self.verbose:
1411 print "looking for initial parent for %s; current parent is %s" % (branch, parent)
1412
1413 if len(parent) == 0 and branch in self.initialParents:
1414 parent = self.initialParents[branch]
1415 del self.initialParents[branch]
1416
1417 self.commit(description, filesForCommit, branch, [branchPrefix], parent)
1418 else:
1419 files = self.extractFilesFromCommit(description)
1420 self.commit(description, files, self.branch, self.depotPaths,
1421 self.initialParent)
1422 self.initialParent = ""
1423 except IOError:
1424 print self.gitError.read()
1425 sys.exit(1)
1426
c208a243
SH
1427 def importHeadRevision(self, revision):
1428 print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), revision, self.branch)
1429
1430 details = { "user" : "git perforce import user", "time" : int(time.time()) }
1431 details["desc"] = ("Initial import of %s from the state at revision %s"
1432 % (' '.join(self.depotPaths), revision))
1433 details["change"] = revision
1434 newestRevision = 0
1435
1436 fileCnt = 0
1437 for info in p4CmdList("files "
1438 + ' '.join(["%s...%s"
1439 % (p, revision)
1440 for p in self.depotPaths])):
1441
1442 if info['code'] == 'error':
1443 sys.stderr.write("p4 returned an error: %s\n"
1444 % info['data'])
1445 sys.exit(1)
1446
1447
1448 change = int(info["change"])
1449 if change > newestRevision:
1450 newestRevision = change
1451
7f96e2e2 1452 if info["action"] in ("delete", "purge"):
c208a243
SH
1453 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
1454 #fileCnt = fileCnt + 1
1455 continue
1456
1457 for prop in ["depotFile", "rev", "action", "type" ]:
1458 details["%s%s" % (prop, fileCnt)] = info[prop]
1459
1460 fileCnt = fileCnt + 1
1461
1462 details["change"] = newestRevision
1463 self.updateOptionDict(details)
1464 try:
1465 self.commit(details, self.extractFilesFromCommit(details), self.branch, self.depotPaths)
1466 except IOError:
1467 print "IO error with git fast-import. Is your git version recent enough?"
1468 print self.gitError.read()
1469
1470
3a70cdfa
TAL
1471 def getClientSpec(self):
1472 specList = p4CmdList( "client -o" )
1473 temp = {}
1474 for entry in specList:
1475 for k,v in entry.iteritems():
1476 if k.startswith("View"):
1477 if v.startswith('"'):
1478 start = 1
1479 else:
1480 start = 0
1481 index = v.find("...")
1482 v = v[start:index]
1483 if v.startswith("-"):
1484 v = v[1:]
1485 temp[v] = -len(v)
1486 else:
1487 temp[v] = len(v)
1488 self.clientSpecDirs = temp.items()
1489 self.clientSpecDirs.sort( lambda x, y: abs( y[1] ) - abs( x[1] ) )
1490
b984733c 1491 def run(self, args):
6326aa58 1492 self.depotPaths = []
179caebf
SH
1493 self.changeRange = ""
1494 self.initialParent = ""
6326aa58 1495 self.previousDepotPaths = []
ce6f33c8 1496
29bdbac1
SH
1497 # map from branch depot path to parent branch
1498 self.knownBranches = {}
1499 self.initialParents = {}
5ca44617 1500 self.hasOrigin = originP4BranchesExist()
a43ff00c
SH
1501 if not self.syncWithOrigin:
1502 self.hasOrigin = False
29bdbac1 1503
a028a98e
SH
1504 if self.importIntoRemotes:
1505 self.refPrefix = "refs/remotes/p4/"
1506 else:
db775559 1507 self.refPrefix = "refs/heads/p4/"
a028a98e 1508
cebdf5af
HWN
1509 if self.syncWithOrigin and self.hasOrigin:
1510 if not self.silent:
1511 print "Syncing with origin first by calling git fetch origin"
1512 system("git fetch origin")
10f880f8 1513
569d1bd4 1514 if len(self.branch) == 0:
db775559 1515 self.branch = self.refPrefix + "master"
a028a98e 1516 if gitBranchExists("refs/heads/p4") and self.importIntoRemotes:
48df6fd8 1517 system("git update-ref %s refs/heads/p4" % self.branch)
48df6fd8 1518 system("git branch -D p4");
faf1bd20 1519 # create it /after/ importing, when master exists
0058a33a 1520 if not gitBranchExists(self.refPrefix + "HEAD") and self.importIntoRemotes and gitBranchExists(self.branch):
a3c55c09 1521 system("git symbolic-ref %sHEAD %s" % (self.refPrefix, self.branch))
967f72e2 1522
3cafb7d8 1523 if self.useClientSpec or gitConfig("git-p4.useclientspec") == "true":
3a70cdfa
TAL
1524 self.getClientSpec()
1525
6a49f8e2
HWN
1526 # TODO: should always look at previous commits,
1527 # merge with previous imports, if possible.
1528 if args == []:
d414c74a 1529 if self.hasOrigin:
5ca44617 1530 createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)
abcd790f
SH
1531 self.listExistingP4GitBranches()
1532
1533 if len(self.p4BranchesInGit) > 1:
1534 if not self.silent:
1535 print "Importing from/into multiple branches"
1536 self.detectBranches = True
967f72e2 1537
29bdbac1
SH
1538 if self.verbose:
1539 print "branches: %s" % self.p4BranchesInGit
1540
1541 p4Change = 0
1542 for branch in self.p4BranchesInGit:
cebdf5af 1543 logMsg = extractLogMessageFromGitCommit(self.refPrefix + branch)
bb6e09b2
HWN
1544
1545 settings = extractSettingsGitLog(logMsg)
29bdbac1 1546
bb6e09b2
HWN
1547 self.readOptions(settings)
1548 if (settings.has_key('depot-paths')
1549 and settings.has_key ('change')):
1550 change = int(settings['change']) + 1
29bdbac1
SH
1551 p4Change = max(p4Change, change)
1552
bb6e09b2
HWN
1553 depotPaths = sorted(settings['depot-paths'])
1554 if self.previousDepotPaths == []:
6326aa58 1555 self.previousDepotPaths = depotPaths
29bdbac1 1556 else:
6326aa58
HWN
1557 paths = []
1558 for (prev, cur) in zip(self.previousDepotPaths, depotPaths):
583e1707 1559 for i in range(0, min(len(cur), len(prev))):
6326aa58 1560 if cur[i] <> prev[i]:
583e1707 1561 i = i - 1
6326aa58
HWN
1562 break
1563
583e1707 1564 paths.append (cur[:i + 1])
6326aa58
HWN
1565
1566 self.previousDepotPaths = paths
29bdbac1
SH
1567
1568 if p4Change > 0:
bb6e09b2 1569 self.depotPaths = sorted(self.previousDepotPaths)
d5904674 1570 self.changeRange = "@%s,#head" % p4Change
330f53b8
SH
1571 if not self.detectBranches:
1572 self.initialParent = parseRevision(self.branch)
341dc1c1 1573 if not self.silent and not self.detectBranches:
967f72e2 1574 print "Performing incremental import into %s git branch" % self.branch
569d1bd4 1575
f9162f6a
SH
1576 if not self.branch.startswith("refs/"):
1577 self.branch = "refs/heads/" + self.branch
179caebf 1578
6326aa58 1579 if len(args) == 0 and self.depotPaths:
b984733c 1580 if not self.silent:
6326aa58 1581 print "Depot paths: %s" % ' '.join(self.depotPaths)
b984733c 1582 else:
6326aa58 1583 if self.depotPaths and self.depotPaths != args:
cebdf5af 1584 print ("previous import used depot path %s and now %s was specified. "
6326aa58
HWN
1585 "This doesn't work!" % (' '.join (self.depotPaths),
1586 ' '.join (args)))
b984733c 1587 sys.exit(1)
6326aa58 1588
bb6e09b2 1589 self.depotPaths = sorted(args)
b984733c 1590
1c49fc19 1591 revision = ""
b984733c 1592 self.users = {}
b984733c 1593
6326aa58
HWN
1594 newPaths = []
1595 for p in self.depotPaths:
1596 if p.find("@") != -1:
1597 atIdx = p.index("@")
1598 self.changeRange = p[atIdx:]
1599 if self.changeRange == "@all":
1600 self.changeRange = ""
6a49f8e2 1601 elif ',' not in self.changeRange:
1c49fc19 1602 revision = self.changeRange
6326aa58 1603 self.changeRange = ""
7fcff9de 1604 p = p[:atIdx]
6326aa58
HWN
1605 elif p.find("#") != -1:
1606 hashIdx = p.index("#")
1c49fc19 1607 revision = p[hashIdx:]
7fcff9de 1608 p = p[:hashIdx]
6326aa58 1609 elif self.previousDepotPaths == []:
1c49fc19 1610 revision = "#head"
6326aa58
HWN
1611
1612 p = re.sub ("\.\.\.$", "", p)
1613 if not p.endswith("/"):
1614 p += "/"
1615
1616 newPaths.append(p)
1617
1618 self.depotPaths = newPaths
1619
b984733c 1620
b607e71e 1621 self.loadUserMapFromCache()
cb53e1f8
SH
1622 self.labels = {}
1623 if self.detectLabels:
1624 self.getLabels();
b984733c 1625
4b97ffb1 1626 if self.detectBranches:
df450923
SH
1627 ## FIXME - what's a P4 projectName ?
1628 self.projectName = self.guessProjectName()
1629
38f9f5ec
SH
1630 if self.hasOrigin:
1631 self.getBranchMappingFromGitBranches()
1632 else:
1633 self.getBranchMapping()
29bdbac1
SH
1634 if self.verbose:
1635 print "p4-git branches: %s" % self.p4BranchesInGit
1636 print "initial parents: %s" % self.initialParents
1637 for b in self.p4BranchesInGit:
1638 if b != "master":
6326aa58
HWN
1639
1640 ## FIXME
29bdbac1
SH
1641 b = b[len(self.projectName):]
1642 self.createdBranches.add(b)
4b97ffb1 1643
f291b4e3 1644 self.tz = "%+03d%02d" % (- time.timezone / 3600, ((- time.timezone % 3600) / 60))
b984733c 1645
cebdf5af 1646 importProcess = subprocess.Popen(["git", "fast-import"],
6326aa58
HWN
1647 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
1648 stderr=subprocess.PIPE);
08483580
SH
1649 self.gitOutput = importProcess.stdout
1650 self.gitStream = importProcess.stdin
1651 self.gitError = importProcess.stderr
b984733c 1652
1c49fc19 1653 if revision:
c208a243 1654 self.importHeadRevision(revision)
b984733c
SH
1655 else:
1656 changes = []
1657
0828ab14 1658 if len(self.changesFile) > 0:
b984733c 1659 output = open(self.changesFile).readlines()
1d7367dc 1660 changeSet = set()
b984733c
SH
1661 for line in output:
1662 changeSet.add(int(line))
1663
1664 for change in changeSet:
1665 changes.append(change)
1666
1667 changes.sort()
1668 else:
29bdbac1 1669 if self.verbose:
86dff6b6 1670 print "Getting p4 changes for %s...%s" % (', '.join(self.depotPaths),
6326aa58 1671 self.changeRange)
4f6432d8 1672 changes = p4ChangesForPaths(self.depotPaths, self.changeRange)
b984733c 1673
01a9c9c5 1674 if len(self.maxChanges) > 0:
7fcff9de 1675 changes = changes[:min(int(self.maxChanges), len(changes))]
01a9c9c5 1676
b984733c 1677 if len(changes) == 0:
0828ab14 1678 if not self.silent:
341dc1c1 1679 print "No changes to import!"
1f52af6c 1680 return True
b984733c 1681
a9d1a27a
SH
1682 if not self.silent and not self.detectBranches:
1683 print "Import destination: %s" % self.branch
1684
341dc1c1
SH
1685 self.updatedBranches = set()
1686
e87f37ae 1687 self.importChanges(changes)
b984733c 1688
341dc1c1
SH
1689 if not self.silent:
1690 print ""
1691 if len(self.updatedBranches) > 0:
1692 sys.stdout.write("Updated branches: ")
1693 for b in self.updatedBranches:
1694 sys.stdout.write("%s " % b)
1695 sys.stdout.write("\n")
b984733c 1696
b984733c 1697 self.gitStream.close()
29bdbac1
SH
1698 if importProcess.wait() != 0:
1699 die("fast-import failed: %s" % self.gitError.read())
b984733c
SH
1700 self.gitOutput.close()
1701 self.gitError.close()
1702
b984733c
SH
1703 return True
1704
01ce1fe9
SH
1705class P4Rebase(Command):
1706 def __init__(self):
1707 Command.__init__(self)
01265103 1708 self.options = [ ]
cebdf5af
HWN
1709 self.description = ("Fetches the latest revision from perforce and "
1710 + "rebases the current work (branch) against it")
68c42153 1711 self.verbose = False
01ce1fe9
SH
1712
1713 def run(self, args):
1714 sync = P4Sync()
1715 sync.run([])
d7e3868c 1716
14594f4b
SH
1717 return self.rebase()
1718
1719 def rebase(self):
36ee4ee4
SH
1720 if os.system("git update-index --refresh") != 0:
1721 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.");
1722 if len(read_pipe("git diff-index HEAD --")) > 0:
1723 die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
1724
d7e3868c
SH
1725 [upstream, settings] = findUpstreamBranchPoint()
1726 if len(upstream) == 0:
1727 die("Cannot find upstream branchpoint for rebase")
1728
1729 # the branchpoint may be p4/foo~3, so strip off the parent
1730 upstream = re.sub("~[0-9]+$", "", upstream)
1731
1732 print "Rebasing the current branch onto %s" % upstream
b25b2065 1733 oldHead = read_pipe("git rev-parse HEAD").strip()
d7e3868c 1734 system("git rebase %s" % upstream)
1f52af6c 1735 system("git diff-tree --stat --summary -M %s HEAD" % oldHead)
01ce1fe9
SH
1736 return True
1737
f9a3a4f7
SH
1738class P4Clone(P4Sync):
1739 def __init__(self):
1740 P4Sync.__init__(self)
1741 self.description = "Creates a new git repository and imports from Perforce into it"
bb6e09b2 1742 self.usage = "usage: %prog [options] //depot/path[@revRange]"
354081d5 1743 self.options += [
bb6e09b2
HWN
1744 optparse.make_option("--destination", dest="cloneDestination",
1745 action='store', default=None,
354081d5
TT
1746 help="where to leave result of the clone"),
1747 optparse.make_option("-/", dest="cloneExclude",
1748 action="append", type="string",
1749 help="exclude depot path")
1750 ]
bb6e09b2 1751 self.cloneDestination = None
f9a3a4f7 1752 self.needsGit = False
f9a3a4f7 1753
354081d5
TT
1754 # This is required for the "append" cloneExclude action
1755 def ensure_value(self, attr, value):
1756 if not hasattr(self, attr) or getattr(self, attr) is None:
1757 setattr(self, attr, value)
1758 return getattr(self, attr)
1759
6a49f8e2
HWN
1760 def defaultDestination(self, args):
1761 ## TODO: use common prefix of args?
1762 depotPath = args[0]
1763 depotDir = re.sub("(@[^@]*)$", "", depotPath)
1764 depotDir = re.sub("(#[^#]*)$", "", depotDir)
053d9e43 1765 depotDir = re.sub(r"\.\.\.$", "", depotDir)
6a49f8e2
HWN
1766 depotDir = re.sub(r"/$", "", depotDir)
1767 return os.path.split(depotDir)[1]
1768
f9a3a4f7
SH
1769 def run(self, args):
1770 if len(args) < 1:
1771 return False
bb6e09b2
HWN
1772
1773 if self.keepRepoPath and not self.cloneDestination:
1774 sys.stderr.write("Must specify destination for --keep-path\n")
1775 sys.exit(1)
f9a3a4f7 1776
6326aa58 1777 depotPaths = args
5e100b5c
SH
1778
1779 if not self.cloneDestination and len(depotPaths) > 1:
1780 self.cloneDestination = depotPaths[-1]
1781 depotPaths = depotPaths[:-1]
1782
354081d5 1783 self.cloneExclude = ["/"+p for p in self.cloneExclude]
6326aa58
HWN
1784 for p in depotPaths:
1785 if not p.startswith("//"):
1786 return False
f9a3a4f7 1787
bb6e09b2 1788 if not self.cloneDestination:
98ad4faf 1789 self.cloneDestination = self.defaultDestination(args)
f9a3a4f7 1790
86dff6b6 1791 print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
c3bf3f13
KG
1792 if not os.path.exists(self.cloneDestination):
1793 os.makedirs(self.cloneDestination)
053fd0c1 1794 chdir(self.cloneDestination)
f9a3a4f7 1795 system("git init")
b86f7378 1796 self.gitdir = os.getcwd() + "/.git"
6326aa58 1797 if not P4Sync.run(self, depotPaths):
f9a3a4f7 1798 return False
f9a3a4f7 1799 if self.branch != "master":
e9905013
TAL
1800 if self.importIntoRemotes:
1801 masterbranch = "refs/remotes/p4/master"
1802 else:
1803 masterbranch = "refs/heads/p4/master"
1804 if gitBranchExists(masterbranch):
1805 system("git branch master %s" % masterbranch)
8f9b2e08
SH
1806 system("git checkout -f")
1807 else:
1808 print "Could not detect main branch. No checkout/master branch created."
86dff6b6 1809
f9a3a4f7
SH
1810 return True
1811
09d89de2
SH
1812class P4Branches(Command):
1813 def __init__(self):
1814 Command.__init__(self)
1815 self.options = [ ]
1816 self.description = ("Shows the git branches that hold imports and their "
1817 + "corresponding perforce depot paths")
1818 self.verbose = False
1819
1820 def run(self, args):
5ca44617
SH
1821 if originP4BranchesExist():
1822 createOrUpdateBranchesFromOrigin()
1823
09d89de2
SH
1824 cmdline = "git rev-parse --symbolic "
1825 cmdline += " --remotes"
1826
1827 for line in read_pipe_lines(cmdline):
1828 line = line.strip()
1829
1830 if not line.startswith('p4/') or line == "p4/HEAD":
1831 continue
1832 branch = line
1833
1834 log = extractLogMessageFromGitCommit("refs/remotes/%s" % branch)
1835 settings = extractSettingsGitLog(log)
1836
1837 print "%s <= %s (%s)" % (branch, ",".join(settings["depot-paths"]), settings["change"])
1838 return True
1839
b984733c
SH
1840class HelpFormatter(optparse.IndentedHelpFormatter):
1841 def __init__(self):
1842 optparse.IndentedHelpFormatter.__init__(self)
1843
1844 def format_description(self, description):
1845 if description:
1846 return description + "\n"
1847 else:
1848 return ""
4f5cf76a 1849
86949eef
SH
1850def printUsage(commands):
1851 print "usage: %s <command> [options]" % sys.argv[0]
1852 print ""
1853 print "valid commands: %s" % ", ".join(commands)
1854 print ""
1855 print "Try %s <command> --help for command specific help." % sys.argv[0]
1856 print ""
1857
1858commands = {
b86f7378
HWN
1859 "debug" : P4Debug,
1860 "submit" : P4Submit,
a9834f58 1861 "commit" : P4Submit,
b86f7378
HWN
1862 "sync" : P4Sync,
1863 "rebase" : P4Rebase,
1864 "clone" : P4Clone,
09d89de2
SH
1865 "rollback" : P4RollBack,
1866 "branches" : P4Branches
86949eef
SH
1867}
1868
86949eef 1869
bb6e09b2
HWN
1870def main():
1871 if len(sys.argv[1:]) == 0:
1872 printUsage(commands.keys())
1873 sys.exit(2)
4f5cf76a 1874
bb6e09b2
HWN
1875 cmd = ""
1876 cmdName = sys.argv[1]
1877 try:
b86f7378
HWN
1878 klass = commands[cmdName]
1879 cmd = klass()
bb6e09b2
HWN
1880 except KeyError:
1881 print "unknown command %s" % cmdName
1882 print ""
1883 printUsage(commands.keys())
1884 sys.exit(2)
1885
1886 options = cmd.options
b86f7378 1887 cmd.gitdir = os.environ.get("GIT_DIR", None)
bb6e09b2
HWN
1888
1889 args = sys.argv[2:]
1890
1891 if len(options) > 0:
1892 options.append(optparse.make_option("--git-dir", dest="gitdir"))
1893
1894 parser = optparse.OptionParser(cmd.usage.replace("%prog", "%prog " + cmdName),
1895 options,
1896 description = cmd.description,
1897 formatter = HelpFormatter())
1898
1899 (cmd, args) = parser.parse_args(sys.argv[2:], cmd);
1900 global verbose
1901 verbose = cmd.verbose
1902 if cmd.needsGit:
b86f7378
HWN
1903 if cmd.gitdir == None:
1904 cmd.gitdir = os.path.abspath(".git")
1905 if not isValidGitDir(cmd.gitdir):
1906 cmd.gitdir = read_pipe("git rev-parse --git-dir").strip()
1907 if os.path.exists(cmd.gitdir):
bb6e09b2
HWN
1908 cdup = read_pipe("git rev-parse --show-cdup").strip()
1909 if len(cdup) > 0:
053fd0c1 1910 chdir(cdup);
e20a9e53 1911
b86f7378
HWN
1912 if not isValidGitDir(cmd.gitdir):
1913 if isValidGitDir(cmd.gitdir + "/.git"):
1914 cmd.gitdir += "/.git"
bb6e09b2 1915 else:
b86f7378 1916 die("fatal: cannot locate git repository at %s" % cmd.gitdir)
e20a9e53 1917
b86f7378 1918 os.environ["GIT_DIR"] = cmd.gitdir
86949eef 1919
bb6e09b2
HWN
1920 if not cmd.run(args):
1921 parser.print_help()
4f5cf76a 1922
4f5cf76a 1923
bb6e09b2
HWN
1924if __name__ == '__main__':
1925 main()