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