Git 1.7.4
[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"])
8b130262
AW
709 diff = ""
710 for editedFile in editedFiles:
711 diff += p4_read_pipe("diff -du %r" % editedFile)
4f5cf76a 712
f3e5ae4f 713 newdiff = ""
4f5cf76a 714 for newFile in filesToAdd:
f3e5ae4f
MSO
715 newdiff += "==== new file ====\n"
716 newdiff += "--- /dev/null\n"
717 newdiff += "+++ %s\n" % newFile
4f5cf76a
SH
718 f = open(newFile, "r")
719 for line in f.readlines():
f3e5ae4f 720 newdiff += "+" + line
4f5cf76a
SH
721 f.close()
722
f3e5ae4f 723 separatorLine = "######## everything below this line is just the diff #######\n"
4f5cf76a 724
e96e400f
SH
725 [handle, fileName] = tempfile.mkstemp()
726 tmpFile = os.fdopen(handle, "w+")
f3e5ae4f
MSO
727 if self.isWindows:
728 submitTemplate = submitTemplate.replace("\n", "\r\n")
729 separatorLine = separatorLine.replace("\n", "\r\n")
730 newdiff = newdiff.replace("\n", "\r\n")
731 tmpFile.write(submitTemplate + separatorLine + diff + newdiff)
e96e400f 732 tmpFile.close()
cdc7e388 733 mtime = os.stat(fileName).st_mtime
82cea9ff
SB
734 if os.environ.has_key("P4EDITOR"):
735 editor = os.environ.get("P4EDITOR")
736 else:
8b187e6b 737 editor = read_pipe("git var GIT_EDITOR").strip()
e96e400f 738 system(editor + " " + fileName)
e96e400f 739
cdc7e388
SH
740 response = "y"
741 if os.stat(fileName).st_mtime <= mtime:
742 response = "x"
743 while response != "y" and response != "n":
744 response = raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")
745
746 if response == "y":
747 tmpFile = open(fileName, "rb")
748 message = tmpFile.read()
749 tmpFile.close()
750 submitTemplate = message[:message.index(separatorLine)]
751 if self.isWindows:
752 submitTemplate = submitTemplate.replace("\r\n", "\n")
753 p4_write_pipe("submit -i", submitTemplate)
754 else:
755 for f in editedFiles:
756 p4_system("revert \"%s\"" % f);
757 for f in filesToAdd:
758 p4_system("revert \"%s\"" % f);
759 system("rm %s" %f)
760
761 os.remove(fileName)
4f5cf76a
SH
762 else:
763 fileName = "submit.txt"
764 file = open(fileName, "w+")
765 file.write(self.prepareLogMessage(template, logMessage))
766 file.close()
cebdf5af
HWN
767 print ("Perforce submit template written as %s. "
768 + "Please review/edit and then use p4 submit -i < %s to submit directly!"
769 % (fileName, fileName))
4f5cf76a
SH
770
771 def run(self, args):
c9b50e63
SH
772 if len(args) == 0:
773 self.master = currentGitBranch()
4280e533 774 if len(self.master) == 0 or not gitBranchExists("refs/heads/%s" % self.master):
c9b50e63
SH
775 die("Detecting current git branch failed!")
776 elif len(args) == 1:
777 self.master = args[0]
778 else:
779 return False
780
4c2d5d72
JX
781 allowSubmit = gitConfig("git-p4.allowSubmit")
782 if len(allowSubmit) > 0 and not self.master in allowSubmit.split(","):
783 die("%s is not in git-p4.allowSubmit" % self.master)
784
27d2d811 785 [upstream, settings] = findUpstreamBranchPoint()
ea99c3ae 786 self.depotPath = settings['depot-paths'][0]
27d2d811
SH
787 if len(self.origin) == 0:
788 self.origin = upstream
a3fdd579
SH
789
790 if self.verbose:
791 print "Origin branch is " + self.origin
9512497b 792
ea99c3ae 793 if len(self.depotPath) == 0:
9512497b
SH
794 print "Internal error: cannot locate perforce depot path from existing branches"
795 sys.exit(128)
796
ea99c3ae 797 self.clientPath = p4Where(self.depotPath)
9512497b 798
51a2640a 799 if len(self.clientPath) == 0:
ea99c3ae 800 print "Error: Cannot locate perforce checkout of %s in client view" % self.depotPath
9512497b
SH
801 sys.exit(128)
802
ea99c3ae 803 print "Perforce checkout for depot path %s located at %s" % (self.depotPath, self.clientPath)
7944f142 804 self.oldWorkingDirectory = os.getcwd()
c1b296b9 805
053fd0c1 806 chdir(self.clientPath)
6a01298a 807 print "Synchronizing p4 checkout..."
87b611d5 808 p4_system("sync ...")
9512497b 809
4f5cf76a 810 self.check()
4f5cf76a 811
4c750c0d
SH
812 commits = []
813 for line in read_pipe_lines("git rev-list --no-merges %s..%s" % (self.origin, self.master)):
814 commits.append(line.strip())
815 commits.reverse()
4f5cf76a
SH
816
817 while len(commits) > 0:
4f5cf76a
SH
818 commit = commits[0]
819 commits = commits[1:]
7cb5cbef 820 self.applyCommit(commit)
4f5cf76a
SH
821 if not self.interactive:
822 break
823
4f5cf76a 824 if len(commits) == 0:
4c750c0d 825 print "All changes applied!"
053fd0c1 826 chdir(self.oldWorkingDirectory)
14594f4b 827
4c750c0d
SH
828 sync = P4Sync()
829 sync.run([])
14594f4b 830
4c750c0d
SH
831 rebase = P4Rebase()
832 rebase.rebase()
4f5cf76a 833
b984733c
SH
834 return True
835
711544b0 836class P4Sync(Command):
b984733c
SH
837 def __init__(self):
838 Command.__init__(self)
839 self.options = [
840 optparse.make_option("--branch", dest="branch"),
841 optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"),
842 optparse.make_option("--changesfile", dest="changesFile"),
843 optparse.make_option("--silent", dest="silent", action="store_true"),
ef48f909 844 optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),
a028a98e 845 optparse.make_option("--verbose", dest="verbose", action="store_true"),
d2c6dd30
HWN
846 optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",
847 help="Import into refs/heads/ , not refs/remotes"),
8b41a97f 848 optparse.make_option("--max-changes", dest="maxChanges"),
86dff6b6 849 optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',
3a70cdfa
TAL
850 help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),
851 optparse.make_option("--use-client-spec", dest="useClientSpec", action='store_true',
852 help="Only sync files that are included in the Perforce Client Spec")
b984733c
SH
853 ]
854 self.description = """Imports from Perforce into a git repository.\n
855 example:
856 //depot/my/project/ -- to import the current head
857 //depot/my/project/@all -- to import everything
858 //depot/my/project/@1,6 -- to import only from revision 1 to 6
859
860 (a ... is not needed in the path p4 specification, it's added implicitly)"""
861
862 self.usage += " //depot/path[@revRange]"
b984733c 863 self.silent = False
1d7367dc
RG
864 self.createdBranches = set()
865 self.committedChanges = set()
569d1bd4 866 self.branch = ""
b984733c 867 self.detectBranches = False
cb53e1f8 868 self.detectLabels = False
b984733c 869 self.changesFile = ""
01265103 870 self.syncWithOrigin = True
4b97ffb1 871 self.verbose = False
a028a98e 872 self.importIntoRemotes = True
01a9c9c5 873 self.maxChanges = ""
c1f9197f 874 self.isWindows = (platform.system() == "Windows")
8b41a97f 875 self.keepRepoPath = False
6326aa58 876 self.depotPaths = None
3c699645 877 self.p4BranchesInGit = []
354081d5 878 self.cloneExclude = []
3a70cdfa
TAL
879 self.useClientSpec = False
880 self.clientSpecDirs = []
b984733c 881
01265103
SH
882 if gitConfig("git-p4.syncFromOrigin") == "false":
883 self.syncWithOrigin = False
884
b984733c 885 def extractFilesFromCommit(self, commit):
354081d5
TT
886 self.cloneExclude = [re.sub(r"\.\.\.$", "", path)
887 for path in self.cloneExclude]
b984733c
SH
888 files = []
889 fnum = 0
890 while commit.has_key("depotFile%s" % fnum):
891 path = commit["depotFile%s" % fnum]
6326aa58 892
354081d5
TT
893 if [p for p in self.cloneExclude
894 if path.startswith (p)]:
895 found = False
896 else:
897 found = [p for p in self.depotPaths
898 if path.startswith (p)]
6326aa58 899 if not found:
b984733c
SH
900 fnum = fnum + 1
901 continue
902
903 file = {}
904 file["path"] = path
905 file["rev"] = commit["rev%s" % fnum]
906 file["action"] = commit["action%s" % fnum]
907 file["type"] = commit["type%s" % fnum]
908 files.append(file)
909 fnum = fnum + 1
910 return files
911
6326aa58 912 def stripRepoPath(self, path, prefixes):
8b41a97f 913 if self.keepRepoPath:
6326aa58
HWN
914 prefixes = [re.sub("^(//[^/]+/).*", r'\1', prefixes[0])]
915
916 for p in prefixes:
917 if path.startswith(p):
918 path = path[len(p):]
8b41a97f 919
6326aa58 920 return path
6754a299 921
71b112d4 922 def splitFilesIntoBranches(self, commit):
d5904674 923 branches = {}
71b112d4
SH
924 fnum = 0
925 while commit.has_key("depotFile%s" % fnum):
926 path = commit["depotFile%s" % fnum]
6326aa58
HWN
927 found = [p for p in self.depotPaths
928 if path.startswith (p)]
929 if not found:
71b112d4
SH
930 fnum = fnum + 1
931 continue
932
933 file = {}
934 file["path"] = path
935 file["rev"] = commit["rev%s" % fnum]
936 file["action"] = commit["action%s" % fnum]
937 file["type"] = commit["type%s" % fnum]
938 fnum = fnum + 1
939
6326aa58 940 relPath = self.stripRepoPath(path, self.depotPaths)
b984733c 941
4b97ffb1 942 for branch in self.knownBranches.keys():
6754a299
HWN
943
944 # add a trailing slash so that a commit into qt/4.2foo doesn't end up in qt/4.2
945 if relPath.startswith(branch + "/"):
d5904674
SH
946 if branch not in branches:
947 branches[branch] = []
71b112d4 948 branches[branch].append(file)
6555b2cc 949 break
b984733c
SH
950
951 return branches
952
b932705b
LD
953 # output one file from the P4 stream
954 # - helper for streamP4Files
955
956 def streamOneP4File(self, file, contents):
957 if file["type"] == "apple":
958 print "\nfile %s is a strange apple file that forks. Ignoring" % \
959 file['depotFile']
960 return
961
962 relPath = self.stripRepoPath(file['depotFile'], self.branchPrefixes)
963 if verbose:
964 sys.stderr.write("%s\n" % relPath)
965
966 mode = "644"
967 if isP4Exec(file["type"]):
968 mode = "755"
969 elif file["type"] == "symlink":
970 mode = "120000"
971 # p4 print on a symlink contains "target\n", so strip it off
b39c3612
EP
972 data = ''.join(contents)
973 contents = [data[:-1]]
b932705b
LD
974
975 if self.isWindows and file["type"].endswith("text"):
976 mangled = []
977 for data in contents:
978 data = data.replace("\r\n", "\n")
979 mangled.append(data)
980 contents = mangled
981
982 if file['type'] in ('text+ko', 'unicode+ko', 'binary+ko'):
983 contents = map(lambda text: re.sub(r'(?i)\$(Id|Header):[^$]*\$',r'$\1$', text), contents)
984 elif file['type'] in ('text+k', 'ktext', 'kxtext', 'unicode+k', 'binary+k'):
985 contents = map(lambda text: re.sub(r'\$(Id|Header|Author|Date|DateTime|Change|File|Revision):[^$\n]*\$',r'$\1$', text), contents)
986
987 self.gitStream.write("M %s inline %s\n" % (mode, relPath))
988
989 # total length...
990 length = 0
991 for d in contents:
992 length = length + len(d)
993
994 self.gitStream.write("data %d\n" % length)
995 for d in contents:
996 self.gitStream.write(d)
997 self.gitStream.write("\n")
998
999 def streamOneP4Deletion(self, file):
1000 relPath = self.stripRepoPath(file['path'], self.branchPrefixes)
1001 if verbose:
1002 sys.stderr.write("delete %s\n" % relPath)
1003 self.gitStream.write("D %s\n" % relPath)
1004
1005 # handle another chunk of streaming data
1006 def streamP4FilesCb(self, marshalled):
1007
1008 if marshalled.has_key('depotFile') and self.stream_have_file_info:
1009 # start of a new file - output the old one first
1010 self.streamOneP4File(self.stream_file, self.stream_contents)
1011 self.stream_file = {}
1012 self.stream_contents = []
1013 self.stream_have_file_info = False
1014
1015 # pick up the new file information... for the
1016 # 'data' field we need to append to our array
1017 for k in marshalled.keys():
1018 if k == 'data':
1019 self.stream_contents.append(marshalled['data'])
1020 else:
1021 self.stream_file[k] = marshalled[k]
1022
1023 self.stream_have_file_info = True
1024
1025 # Stream directly from "p4 files" into "git fast-import"
1026 def streamP4Files(self, files):
30b5940b
SH
1027 filesForCommit = []
1028 filesToRead = []
b932705b 1029 filesToDelete = []
30b5940b 1030
3a70cdfa 1031 for f in files:
30b5940b 1032 includeFile = True
3a70cdfa
TAL
1033 for val in self.clientSpecDirs:
1034 if f['path'].startswith(val[0]):
30b5940b
SH
1035 if val[1] <= 0:
1036 includeFile = False
3a70cdfa
TAL
1037 break
1038
30b5940b
SH
1039 if includeFile:
1040 filesForCommit.append(f)
562d53fa 1041 if f['action'] not in ('delete', 'move/delete', 'purge'):
30b5940b 1042 filesToRead.append(f)
b932705b
LD
1043 else:
1044 filesToDelete.append(f)
6a49f8e2 1045
b932705b
LD
1046 # deleted files...
1047 for f in filesToDelete:
1048 self.streamOneP4Deletion(f)
1b9a4684 1049
b932705b
LD
1050 if len(filesToRead) > 0:
1051 self.stream_file = {}
1052 self.stream_contents = []
1053 self.stream_have_file_info = False
8ff45f2a 1054
b932705b
LD
1055 # curry self argument
1056 def streamP4FilesCbSelf(entry):
1057 self.streamP4FilesCb(entry)
6a49f8e2 1058
b932705b
LD
1059 p4CmdList("-x - print",
1060 '\n'.join(['%s#%s' % (f['path'], f['rev'])
1061 for f in filesToRead]),
1062 cb=streamP4FilesCbSelf)
30b5940b 1063
b932705b
LD
1064 # do the last chunk
1065 if self.stream_file.has_key('depotFile'):
1066 self.streamOneP4File(self.stream_file, self.stream_contents)
6a49f8e2 1067
6326aa58 1068 def commit(self, details, files, branch, branchPrefixes, parent = ""):
b984733c
SH
1069 epoch = details["time"]
1070 author = details["user"]
b932705b 1071 self.branchPrefixes = branchPrefixes
b984733c 1072
4b97ffb1
SH
1073 if self.verbose:
1074 print "commit into %s" % branch
1075
96e07dd2
HWN
1076 # start with reading files; if that fails, we should not
1077 # create a commit.
1078 new_files = []
1079 for f in files:
1080 if [p for p in branchPrefixes if f['path'].startswith(p)]:
1081 new_files.append (f)
1082 else:
1083 sys.stderr.write("Ignoring file outside of prefix: %s\n" % path)
96e07dd2 1084
b984733c 1085 self.gitStream.write("commit %s\n" % branch)
6a49f8e2 1086# gitStream.write("mark :%s\n" % details["change"])
b984733c
SH
1087 self.committedChanges.add(int(details["change"]))
1088 committer = ""
b607e71e
SH
1089 if author not in self.users:
1090 self.getUserMapFromPerforceServer()
b984733c 1091 if author in self.users:
0828ab14 1092 committer = "%s %s %s" % (self.users[author], epoch, self.tz)
b984733c 1093 else:
0828ab14 1094 committer = "%s <a@b> %s %s" % (author, epoch, self.tz)
b984733c
SH
1095
1096 self.gitStream.write("committer %s\n" % committer)
1097
1098 self.gitStream.write("data <<EOT\n")
1099 self.gitStream.write(details["desc"])
6581de09
SH
1100 self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s"
1101 % (','.join (branchPrefixes), details["change"]))
1102 if len(details['options']) > 0:
1103 self.gitStream.write(": options = %s" % details['options'])
1104 self.gitStream.write("]\nEOT\n\n")
b984733c
SH
1105
1106 if len(parent) > 0:
4b97ffb1
SH
1107 if self.verbose:
1108 print "parent %s" % parent
b984733c
SH
1109 self.gitStream.write("from %s\n" % parent)
1110
b932705b 1111 self.streamP4Files(new_files)
b984733c
SH
1112 self.gitStream.write("\n")
1113
1f4ba1cb
SH
1114 change = int(details["change"])
1115
9bda3a85 1116 if self.labels.has_key(change):
1f4ba1cb
SH
1117 label = self.labels[change]
1118 labelDetails = label[0]
1119 labelRevisions = label[1]
71b112d4
SH
1120 if self.verbose:
1121 print "Change %s is labelled %s" % (change, labelDetails)
1f4ba1cb 1122
6326aa58
HWN
1123 files = p4CmdList("files " + ' '.join (["%s...@%s" % (p, change)
1124 for p in branchPrefixes]))
1f4ba1cb
SH
1125
1126 if len(files) == len(labelRevisions):
1127
1128 cleanedFiles = {}
1129 for info in files:
7f96e2e2 1130 if info["action"] in ("delete", "purge"):
1f4ba1cb
SH
1131 continue
1132 cleanedFiles[info["depotFile"]] = info["rev"]
1133
1134 if cleanedFiles == labelRevisions:
1135 self.gitStream.write("tag tag_%s\n" % labelDetails["label"])
1136 self.gitStream.write("from %s\n" % branch)
1137
1138 owner = labelDetails["Owner"]
1139 tagger = ""
1140 if author in self.users:
1141 tagger = "%s %s %s" % (self.users[owner], epoch, self.tz)
1142 else:
1143 tagger = "%s <a@b> %s %s" % (owner, epoch, self.tz)
1144 self.gitStream.write("tagger %s\n" % tagger)
1145 self.gitStream.write("data <<EOT\n")
1146 self.gitStream.write(labelDetails["Description"])
1147 self.gitStream.write("EOT\n\n")
1148
1149 else:
a46668fa 1150 if not self.silent:
cebdf5af
HWN
1151 print ("Tag %s does not match with change %s: files do not match."
1152 % (labelDetails["label"], change))
1f4ba1cb
SH
1153
1154 else:
a46668fa 1155 if not self.silent:
cebdf5af
HWN
1156 print ("Tag %s does not match with change %s: file count is different."
1157 % (labelDetails["label"], change))
b984733c 1158
183b8ef8 1159 def getUserCacheFilename(self):
b2d2d16a
SH
1160 home = os.environ.get("HOME", os.environ.get("USERPROFILE"))
1161 return home + "/.gitp4-usercache.txt"
183b8ef8 1162
b607e71e 1163 def getUserMapFromPerforceServer(self):
ebd81168
SH
1164 if self.userMapFromPerforceServer:
1165 return
b984733c
SH
1166 self.users = {}
1167
1168 for output in p4CmdList("users"):
1169 if not output.has_key("User"):
1170 continue
1171 self.users[output["User"]] = output["FullName"] + " <" + output["Email"] + ">"
1172
183b8ef8
HWN
1173
1174 s = ''
1175 for (key, val) in self.users.items():
3b167396 1176 s += "%s\t%s\n" % (key.expandtabs(1), val.expandtabs(1))
183b8ef8
HWN
1177
1178 open(self.getUserCacheFilename(), "wb").write(s)
ebd81168 1179 self.userMapFromPerforceServer = True
b607e71e
SH
1180
1181 def loadUserMapFromCache(self):
1182 self.users = {}
ebd81168 1183 self.userMapFromPerforceServer = False
b607e71e 1184 try:
183b8ef8 1185 cache = open(self.getUserCacheFilename(), "rb")
b607e71e
SH
1186 lines = cache.readlines()
1187 cache.close()
1188 for line in lines:
b25b2065 1189 entry = line.strip().split("\t")
b607e71e
SH
1190 self.users[entry[0]] = entry[1]
1191 except IOError:
1192 self.getUserMapFromPerforceServer()
1193
1f4ba1cb
SH
1194 def getLabels(self):
1195 self.labels = {}
1196
6326aa58 1197 l = p4CmdList("labels %s..." % ' '.join (self.depotPaths))
10c3211b 1198 if len(l) > 0 and not self.silent:
183f8436 1199 print "Finding files belonging to labels in %s" % `self.depotPaths`
01ce1fe9
SH
1200
1201 for output in l:
1f4ba1cb
SH
1202 label = output["label"]
1203 revisions = {}
1204 newestChange = 0
71b112d4
SH
1205 if self.verbose:
1206 print "Querying files for label %s" % label
6326aa58
HWN
1207 for file in p4CmdList("files "
1208 + ' '.join (["%s...@%s" % (p, label)
1209 for p in self.depotPaths])):
1f4ba1cb
SH
1210 revisions[file["depotFile"]] = file["rev"]
1211 change = int(file["change"])
1212 if change > newestChange:
1213 newestChange = change
1214
9bda3a85
SH
1215 self.labels[newestChange] = [output, revisions]
1216
1217 if self.verbose:
1218 print "Label changes: %s" % self.labels.keys()
1f4ba1cb 1219
86dff6b6
HWN
1220 def guessProjectName(self):
1221 for p in self.depotPaths:
6e5295c4
SH
1222 if p.endswith("/"):
1223 p = p[:-1]
1224 p = p[p.strip().rfind("/") + 1:]
1225 if not p.endswith("/"):
1226 p += "/"
1227 return p
86dff6b6 1228
4b97ffb1 1229 def getBranchMapping(self):
6555b2cc
SH
1230 lostAndFoundBranches = set()
1231
4b97ffb1
SH
1232 for info in p4CmdList("branches"):
1233 details = p4Cmd("branch -o %s" % info["branch"])
1234 viewIdx = 0
1235 while details.has_key("View%s" % viewIdx):
1236 paths = details["View%s" % viewIdx].split(" ")
1237 viewIdx = viewIdx + 1
1238 # require standard //depot/foo/... //depot/bar/... mapping
1239 if len(paths) != 2 or not paths[0].endswith("/...") or not paths[1].endswith("/..."):
1240 continue
1241 source = paths[0]
1242 destination = paths[1]
6509e19c
SH
1243 ## HACK
1244 if source.startswith(self.depotPaths[0]) and destination.startswith(self.depotPaths[0]):
1245 source = source[len(self.depotPaths[0]):-4]
1246 destination = destination[len(self.depotPaths[0]):-4]
6555b2cc 1247
1a2edf4e
SH
1248 if destination in self.knownBranches:
1249 if not self.silent:
1250 print "p4 branch %s defines a mapping from %s to %s" % (info["branch"], source, destination)
1251 print "but there exists another mapping from %s to %s already!" % (self.knownBranches[destination], destination)
1252 continue
1253
6555b2cc
SH
1254 self.knownBranches[destination] = source
1255
1256 lostAndFoundBranches.discard(destination)
1257
29bdbac1 1258 if source not in self.knownBranches:
6555b2cc
SH
1259 lostAndFoundBranches.add(source)
1260
1261
1262 for branch in lostAndFoundBranches:
1263 self.knownBranches[branch] = branch
29bdbac1 1264
38f9f5ec
SH
1265 def getBranchMappingFromGitBranches(self):
1266 branches = p4BranchesInGit(self.importIntoRemotes)
1267 for branch in branches.keys():
1268 if branch == "master":
1269 branch = "main"
1270 else:
1271 branch = branch[len(self.projectName):]
1272 self.knownBranches[branch] = branch
1273
29bdbac1 1274 def listExistingP4GitBranches(self):
144ff46b
SH
1275 # branches holds mapping from name to commit
1276 branches = p4BranchesInGit(self.importIntoRemotes)
1277 self.p4BranchesInGit = branches.keys()
1278 for branch in branches.keys():
1279 self.initialParents[self.refPrefix + branch] = branches[branch]
4b97ffb1 1280
bb6e09b2
HWN
1281 def updateOptionDict(self, d):
1282 option_keys = {}
1283 if self.keepRepoPath:
1284 option_keys['keepRepoPath'] = 1
1285
1286 d["options"] = ' '.join(sorted(option_keys.keys()))
1287
1288 def readOptions(self, d):
1289 self.keepRepoPath = (d.has_key('options')
1290 and ('keepRepoPath' in d['options']))
6326aa58 1291
8134f69c
SH
1292 def gitRefForBranch(self, branch):
1293 if branch == "main":
1294 return self.refPrefix + "master"
1295
1296 if len(branch) <= 0:
1297 return branch
1298
1299 return self.refPrefix + self.projectName + branch
1300
1ca3d710
SH
1301 def gitCommitByP4Change(self, ref, change):
1302 if self.verbose:
1303 print "looking in ref " + ref + " for change %s using bisect..." % change
1304
1305 earliestCommit = ""
1306 latestCommit = parseRevision(ref)
1307
1308 while True:
1309 if self.verbose:
1310 print "trying: earliest %s latest %s" % (earliestCommit, latestCommit)
1311 next = read_pipe("git rev-list --bisect %s %s" % (latestCommit, earliestCommit)).strip()
1312 if len(next) == 0:
1313 if self.verbose:
1314 print "argh"
1315 return ""
1316 log = extractLogMessageFromGitCommit(next)
1317 settings = extractSettingsGitLog(log)
1318 currentChange = int(settings['change'])
1319 if self.verbose:
1320 print "current change %s" % currentChange
1321
1322 if currentChange == change:
1323 if self.verbose:
1324 print "found %s" % next
1325 return next
1326
1327 if currentChange < change:
1328 earliestCommit = "^%s" % next
1329 else:
1330 latestCommit = "%s" % next
1331
1332 return ""
1333
1334 def importNewBranch(self, branch, maxChange):
1335 # make fast-import flush all changes to disk and update the refs using the checkpoint
1336 # command so that we can try to find the branch parent in the git history
1337 self.gitStream.write("checkpoint\n\n");
1338 self.gitStream.flush();
1339 branchPrefix = self.depotPaths[0] + branch + "/"
1340 range = "@1,%s" % maxChange
1341 #print "prefix" + branchPrefix
1342 changes = p4ChangesForPaths([branchPrefix], range)
1343 if len(changes) <= 0:
1344 return False
1345 firstChange = changes[0]
1346 #print "first change in branch: %s" % firstChange
1347 sourceBranch = self.knownBranches[branch]
1348 sourceDepotPath = self.depotPaths[0] + sourceBranch
1349 sourceRef = self.gitRefForBranch(sourceBranch)
1350 #print "source " + sourceBranch
1351
1352 branchParentChange = int(p4Cmd("changes -m 1 %s...@1,%s" % (sourceDepotPath, firstChange))["change"])
1353 #print "branch parent: %s" % branchParentChange
1354 gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)
1355 if len(gitParent) > 0:
1356 self.initialParents[self.gitRefForBranch(branch)] = gitParent
1357 #print "parent git commit: %s" % gitParent
1358
1359 self.importChanges(changes)
1360 return True
1361
e87f37ae
SH
1362 def importChanges(self, changes):
1363 cnt = 1
1364 for change in changes:
1365 description = p4Cmd("describe %s" % change)
1366 self.updateOptionDict(description)
1367
1368 if not self.silent:
1369 sys.stdout.write("\rImporting revision %s (%s%%)" % (change, cnt * 100 / len(changes)))
1370 sys.stdout.flush()
1371 cnt = cnt + 1
1372
1373 try:
1374 if self.detectBranches:
1375 branches = self.splitFilesIntoBranches(description)
1376 for branch in branches.keys():
1377 ## HACK --hwn
1378 branchPrefix = self.depotPaths[0] + branch + "/"
1379
1380 parent = ""
1381
1382 filesForCommit = branches[branch]
1383
1384 if self.verbose:
1385 print "branch is %s" % branch
1386
1387 self.updatedBranches.add(branch)
1388
1389 if branch not in self.createdBranches:
1390 self.createdBranches.add(branch)
1391 parent = self.knownBranches[branch]
1392 if parent == branch:
1393 parent = ""
1ca3d710
SH
1394 else:
1395 fullBranch = self.projectName + branch
1396 if fullBranch not in self.p4BranchesInGit:
1397 if not self.silent:
1398 print("\n Importing new branch %s" % fullBranch);
1399 if self.importNewBranch(branch, change - 1):
1400 parent = ""
1401 self.p4BranchesInGit.append(fullBranch)
1402 if not self.silent:
1403 print("\n Resuming with change %s" % change);
1404
1405 if self.verbose:
1406 print "parent determined through known branches: %s" % parent
e87f37ae 1407
8134f69c
SH
1408 branch = self.gitRefForBranch(branch)
1409 parent = self.gitRefForBranch(parent)
e87f37ae
SH
1410
1411 if self.verbose:
1412 print "looking for initial parent for %s; current parent is %s" % (branch, parent)
1413
1414 if len(parent) == 0 and branch in self.initialParents:
1415 parent = self.initialParents[branch]
1416 del self.initialParents[branch]
1417
1418 self.commit(description, filesForCommit, branch, [branchPrefix], parent)
1419 else:
1420 files = self.extractFilesFromCommit(description)
1421 self.commit(description, files, self.branch, self.depotPaths,
1422 self.initialParent)
1423 self.initialParent = ""
1424 except IOError:
1425 print self.gitError.read()
1426 sys.exit(1)
1427
c208a243
SH
1428 def importHeadRevision(self, revision):
1429 print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), revision, self.branch)
1430
1431 details = { "user" : "git perforce import user", "time" : int(time.time()) }
1432 details["desc"] = ("Initial import of %s from the state at revision %s"
1433 % (' '.join(self.depotPaths), revision))
1434 details["change"] = revision
1435 newestRevision = 0
1436
1437 fileCnt = 0
1438 for info in p4CmdList("files "
1439 + ' '.join(["%s...%s"
1440 % (p, revision)
1441 for p in self.depotPaths])):
1442
1443 if info['code'] == 'error':
1444 sys.stderr.write("p4 returned an error: %s\n"
1445 % info['data'])
1446 sys.exit(1)
1447
1448
1449 change = int(info["change"])
1450 if change > newestRevision:
1451 newestRevision = change
1452
7f96e2e2 1453 if info["action"] in ("delete", "purge"):
c208a243
SH
1454 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
1455 #fileCnt = fileCnt + 1
1456 continue
1457
1458 for prop in ["depotFile", "rev", "action", "type" ]:
1459 details["%s%s" % (prop, fileCnt)] = info[prop]
1460
1461 fileCnt = fileCnt + 1
1462
1463 details["change"] = newestRevision
1464 self.updateOptionDict(details)
1465 try:
1466 self.commit(details, self.extractFilesFromCommit(details), self.branch, self.depotPaths)
1467 except IOError:
1468 print "IO error with git fast-import. Is your git version recent enough?"
1469 print self.gitError.read()
1470
1471
3a70cdfa
TAL
1472 def getClientSpec(self):
1473 specList = p4CmdList( "client -o" )
1474 temp = {}
1475 for entry in specList:
1476 for k,v in entry.iteritems():
1477 if k.startswith("View"):
1478 if v.startswith('"'):
1479 start = 1
1480 else:
1481 start = 0
1482 index = v.find("...")
1483 v = v[start:index]
1484 if v.startswith("-"):
1485 v = v[1:]
1486 temp[v] = -len(v)
1487 else:
1488 temp[v] = len(v)
1489 self.clientSpecDirs = temp.items()
1490 self.clientSpecDirs.sort( lambda x, y: abs( y[1] ) - abs( x[1] ) )
1491
b984733c 1492 def run(self, args):
6326aa58 1493 self.depotPaths = []
179caebf
SH
1494 self.changeRange = ""
1495 self.initialParent = ""
6326aa58 1496 self.previousDepotPaths = []
ce6f33c8 1497
29bdbac1
SH
1498 # map from branch depot path to parent branch
1499 self.knownBranches = {}
1500 self.initialParents = {}
5ca44617 1501 self.hasOrigin = originP4BranchesExist()
a43ff00c
SH
1502 if not self.syncWithOrigin:
1503 self.hasOrigin = False
29bdbac1 1504
a028a98e
SH
1505 if self.importIntoRemotes:
1506 self.refPrefix = "refs/remotes/p4/"
1507 else:
db775559 1508 self.refPrefix = "refs/heads/p4/"
a028a98e 1509
cebdf5af
HWN
1510 if self.syncWithOrigin and self.hasOrigin:
1511 if not self.silent:
1512 print "Syncing with origin first by calling git fetch origin"
1513 system("git fetch origin")
10f880f8 1514
569d1bd4 1515 if len(self.branch) == 0:
db775559 1516 self.branch = self.refPrefix + "master"
a028a98e 1517 if gitBranchExists("refs/heads/p4") and self.importIntoRemotes:
48df6fd8 1518 system("git update-ref %s refs/heads/p4" % self.branch)
48df6fd8 1519 system("git branch -D p4");
faf1bd20 1520 # create it /after/ importing, when master exists
0058a33a 1521 if not gitBranchExists(self.refPrefix + "HEAD") and self.importIntoRemotes and gitBranchExists(self.branch):
a3c55c09 1522 system("git symbolic-ref %sHEAD %s" % (self.refPrefix, self.branch))
967f72e2 1523
3cafb7d8 1524 if self.useClientSpec or gitConfig("git-p4.useclientspec") == "true":
3a70cdfa
TAL
1525 self.getClientSpec()
1526
6a49f8e2
HWN
1527 # TODO: should always look at previous commits,
1528 # merge with previous imports, if possible.
1529 if args == []:
d414c74a 1530 if self.hasOrigin:
5ca44617 1531 createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)
abcd790f
SH
1532 self.listExistingP4GitBranches()
1533
1534 if len(self.p4BranchesInGit) > 1:
1535 if not self.silent:
1536 print "Importing from/into multiple branches"
1537 self.detectBranches = True
967f72e2 1538
29bdbac1
SH
1539 if self.verbose:
1540 print "branches: %s" % self.p4BranchesInGit
1541
1542 p4Change = 0
1543 for branch in self.p4BranchesInGit:
cebdf5af 1544 logMsg = extractLogMessageFromGitCommit(self.refPrefix + branch)
bb6e09b2
HWN
1545
1546 settings = extractSettingsGitLog(logMsg)
29bdbac1 1547
bb6e09b2
HWN
1548 self.readOptions(settings)
1549 if (settings.has_key('depot-paths')
1550 and settings.has_key ('change')):
1551 change = int(settings['change']) + 1
29bdbac1
SH
1552 p4Change = max(p4Change, change)
1553
bb6e09b2
HWN
1554 depotPaths = sorted(settings['depot-paths'])
1555 if self.previousDepotPaths == []:
6326aa58 1556 self.previousDepotPaths = depotPaths
29bdbac1 1557 else:
6326aa58
HWN
1558 paths = []
1559 for (prev, cur) in zip(self.previousDepotPaths, depotPaths):
583e1707 1560 for i in range(0, min(len(cur), len(prev))):
6326aa58 1561 if cur[i] <> prev[i]:
583e1707 1562 i = i - 1
6326aa58
HWN
1563 break
1564
583e1707 1565 paths.append (cur[:i + 1])
6326aa58
HWN
1566
1567 self.previousDepotPaths = paths
29bdbac1
SH
1568
1569 if p4Change > 0:
bb6e09b2 1570 self.depotPaths = sorted(self.previousDepotPaths)
d5904674 1571 self.changeRange = "@%s,#head" % p4Change
330f53b8
SH
1572 if not self.detectBranches:
1573 self.initialParent = parseRevision(self.branch)
341dc1c1 1574 if not self.silent and not self.detectBranches:
967f72e2 1575 print "Performing incremental import into %s git branch" % self.branch
569d1bd4 1576
f9162f6a
SH
1577 if not self.branch.startswith("refs/"):
1578 self.branch = "refs/heads/" + self.branch
179caebf 1579
6326aa58 1580 if len(args) == 0 and self.depotPaths:
b984733c 1581 if not self.silent:
6326aa58 1582 print "Depot paths: %s" % ' '.join(self.depotPaths)
b984733c 1583 else:
6326aa58 1584 if self.depotPaths and self.depotPaths != args:
cebdf5af 1585 print ("previous import used depot path %s and now %s was specified. "
6326aa58
HWN
1586 "This doesn't work!" % (' '.join (self.depotPaths),
1587 ' '.join (args)))
b984733c 1588 sys.exit(1)
6326aa58 1589
bb6e09b2 1590 self.depotPaths = sorted(args)
b984733c 1591
1c49fc19 1592 revision = ""
b984733c 1593 self.users = {}
b984733c 1594
6326aa58
HWN
1595 newPaths = []
1596 for p in self.depotPaths:
1597 if p.find("@") != -1:
1598 atIdx = p.index("@")
1599 self.changeRange = p[atIdx:]
1600 if self.changeRange == "@all":
1601 self.changeRange = ""
6a49f8e2 1602 elif ',' not in self.changeRange:
1c49fc19 1603 revision = self.changeRange
6326aa58 1604 self.changeRange = ""
7fcff9de 1605 p = p[:atIdx]
6326aa58
HWN
1606 elif p.find("#") != -1:
1607 hashIdx = p.index("#")
1c49fc19 1608 revision = p[hashIdx:]
7fcff9de 1609 p = p[:hashIdx]
6326aa58 1610 elif self.previousDepotPaths == []:
1c49fc19 1611 revision = "#head"
6326aa58
HWN
1612
1613 p = re.sub ("\.\.\.$", "", p)
1614 if not p.endswith("/"):
1615 p += "/"
1616
1617 newPaths.append(p)
1618
1619 self.depotPaths = newPaths
1620
b984733c 1621
b607e71e 1622 self.loadUserMapFromCache()
cb53e1f8
SH
1623 self.labels = {}
1624 if self.detectLabels:
1625 self.getLabels();
b984733c 1626
4b97ffb1 1627 if self.detectBranches:
df450923
SH
1628 ## FIXME - what's a P4 projectName ?
1629 self.projectName = self.guessProjectName()
1630
38f9f5ec
SH
1631 if self.hasOrigin:
1632 self.getBranchMappingFromGitBranches()
1633 else:
1634 self.getBranchMapping()
29bdbac1
SH
1635 if self.verbose:
1636 print "p4-git branches: %s" % self.p4BranchesInGit
1637 print "initial parents: %s" % self.initialParents
1638 for b in self.p4BranchesInGit:
1639 if b != "master":
6326aa58
HWN
1640
1641 ## FIXME
29bdbac1
SH
1642 b = b[len(self.projectName):]
1643 self.createdBranches.add(b)
4b97ffb1 1644
f291b4e3 1645 self.tz = "%+03d%02d" % (- time.timezone / 3600, ((- time.timezone % 3600) / 60))
b984733c 1646
cebdf5af 1647 importProcess = subprocess.Popen(["git", "fast-import"],
6326aa58
HWN
1648 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
1649 stderr=subprocess.PIPE);
08483580
SH
1650 self.gitOutput = importProcess.stdout
1651 self.gitStream = importProcess.stdin
1652 self.gitError = importProcess.stderr
b984733c 1653
1c49fc19 1654 if revision:
c208a243 1655 self.importHeadRevision(revision)
b984733c
SH
1656 else:
1657 changes = []
1658
0828ab14 1659 if len(self.changesFile) > 0:
b984733c 1660 output = open(self.changesFile).readlines()
1d7367dc 1661 changeSet = set()
b984733c
SH
1662 for line in output:
1663 changeSet.add(int(line))
1664
1665 for change in changeSet:
1666 changes.append(change)
1667
1668 changes.sort()
1669 else:
29bdbac1 1670 if self.verbose:
86dff6b6 1671 print "Getting p4 changes for %s...%s" % (', '.join(self.depotPaths),
6326aa58 1672 self.changeRange)
4f6432d8 1673 changes = p4ChangesForPaths(self.depotPaths, self.changeRange)
b984733c 1674
01a9c9c5 1675 if len(self.maxChanges) > 0:
7fcff9de 1676 changes = changes[:min(int(self.maxChanges), len(changes))]
01a9c9c5 1677
b984733c 1678 if len(changes) == 0:
0828ab14 1679 if not self.silent:
341dc1c1 1680 print "No changes to import!"
1f52af6c 1681 return True
b984733c 1682
a9d1a27a
SH
1683 if not self.silent and not self.detectBranches:
1684 print "Import destination: %s" % self.branch
1685
341dc1c1
SH
1686 self.updatedBranches = set()
1687
e87f37ae 1688 self.importChanges(changes)
b984733c 1689
341dc1c1
SH
1690 if not self.silent:
1691 print ""
1692 if len(self.updatedBranches) > 0:
1693 sys.stdout.write("Updated branches: ")
1694 for b in self.updatedBranches:
1695 sys.stdout.write("%s " % b)
1696 sys.stdout.write("\n")
b984733c 1697
b984733c 1698 self.gitStream.close()
29bdbac1
SH
1699 if importProcess.wait() != 0:
1700 die("fast-import failed: %s" % self.gitError.read())
b984733c
SH
1701 self.gitOutput.close()
1702 self.gitError.close()
1703
b984733c
SH
1704 return True
1705
01ce1fe9
SH
1706class P4Rebase(Command):
1707 def __init__(self):
1708 Command.__init__(self)
01265103 1709 self.options = [ ]
cebdf5af
HWN
1710 self.description = ("Fetches the latest revision from perforce and "
1711 + "rebases the current work (branch) against it")
68c42153 1712 self.verbose = False
01ce1fe9
SH
1713
1714 def run(self, args):
1715 sync = P4Sync()
1716 sync.run([])
d7e3868c 1717
14594f4b
SH
1718 return self.rebase()
1719
1720 def rebase(self):
36ee4ee4
SH
1721 if os.system("git update-index --refresh") != 0:
1722 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.");
1723 if len(read_pipe("git diff-index HEAD --")) > 0:
1724 die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
1725
d7e3868c
SH
1726 [upstream, settings] = findUpstreamBranchPoint()
1727 if len(upstream) == 0:
1728 die("Cannot find upstream branchpoint for rebase")
1729
1730 # the branchpoint may be p4/foo~3, so strip off the parent
1731 upstream = re.sub("~[0-9]+$", "", upstream)
1732
1733 print "Rebasing the current branch onto %s" % upstream
b25b2065 1734 oldHead = read_pipe("git rev-parse HEAD").strip()
d7e3868c 1735 system("git rebase %s" % upstream)
1f52af6c 1736 system("git diff-tree --stat --summary -M %s HEAD" % oldHead)
01ce1fe9
SH
1737 return True
1738
f9a3a4f7
SH
1739class P4Clone(P4Sync):
1740 def __init__(self):
1741 P4Sync.__init__(self)
1742 self.description = "Creates a new git repository and imports from Perforce into it"
bb6e09b2 1743 self.usage = "usage: %prog [options] //depot/path[@revRange]"
354081d5 1744 self.options += [
bb6e09b2
HWN
1745 optparse.make_option("--destination", dest="cloneDestination",
1746 action='store', default=None,
354081d5
TT
1747 help="where to leave result of the clone"),
1748 optparse.make_option("-/", dest="cloneExclude",
1749 action="append", type="string",
1750 help="exclude depot path")
1751 ]
bb6e09b2 1752 self.cloneDestination = None
f9a3a4f7 1753 self.needsGit = False
f9a3a4f7 1754
354081d5
TT
1755 # This is required for the "append" cloneExclude action
1756 def ensure_value(self, attr, value):
1757 if not hasattr(self, attr) or getattr(self, attr) is None:
1758 setattr(self, attr, value)
1759 return getattr(self, attr)
1760
6a49f8e2
HWN
1761 def defaultDestination(self, args):
1762 ## TODO: use common prefix of args?
1763 depotPath = args[0]
1764 depotDir = re.sub("(@[^@]*)$", "", depotPath)
1765 depotDir = re.sub("(#[^#]*)$", "", depotDir)
053d9e43 1766 depotDir = re.sub(r"\.\.\.$", "", depotDir)
6a49f8e2
HWN
1767 depotDir = re.sub(r"/$", "", depotDir)
1768 return os.path.split(depotDir)[1]
1769
f9a3a4f7
SH
1770 def run(self, args):
1771 if len(args) < 1:
1772 return False
bb6e09b2
HWN
1773
1774 if self.keepRepoPath and not self.cloneDestination:
1775 sys.stderr.write("Must specify destination for --keep-path\n")
1776 sys.exit(1)
f9a3a4f7 1777
6326aa58 1778 depotPaths = args
5e100b5c
SH
1779
1780 if not self.cloneDestination and len(depotPaths) > 1:
1781 self.cloneDestination = depotPaths[-1]
1782 depotPaths = depotPaths[:-1]
1783
354081d5 1784 self.cloneExclude = ["/"+p for p in self.cloneExclude]
6326aa58
HWN
1785 for p in depotPaths:
1786 if not p.startswith("//"):
1787 return False
f9a3a4f7 1788
bb6e09b2 1789 if not self.cloneDestination:
98ad4faf 1790 self.cloneDestination = self.defaultDestination(args)
f9a3a4f7 1791
86dff6b6 1792 print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
c3bf3f13
KG
1793 if not os.path.exists(self.cloneDestination):
1794 os.makedirs(self.cloneDestination)
053fd0c1 1795 chdir(self.cloneDestination)
f9a3a4f7 1796 system("git init")
b86f7378 1797 self.gitdir = os.getcwd() + "/.git"
6326aa58 1798 if not P4Sync.run(self, depotPaths):
f9a3a4f7 1799 return False
f9a3a4f7 1800 if self.branch != "master":
e9905013
TAL
1801 if self.importIntoRemotes:
1802 masterbranch = "refs/remotes/p4/master"
1803 else:
1804 masterbranch = "refs/heads/p4/master"
1805 if gitBranchExists(masterbranch):
1806 system("git branch master %s" % masterbranch)
8f9b2e08
SH
1807 system("git checkout -f")
1808 else:
1809 print "Could not detect main branch. No checkout/master branch created."
86dff6b6 1810
f9a3a4f7
SH
1811 return True
1812
09d89de2
SH
1813class P4Branches(Command):
1814 def __init__(self):
1815 Command.__init__(self)
1816 self.options = [ ]
1817 self.description = ("Shows the git branches that hold imports and their "
1818 + "corresponding perforce depot paths")
1819 self.verbose = False
1820
1821 def run(self, args):
5ca44617
SH
1822 if originP4BranchesExist():
1823 createOrUpdateBranchesFromOrigin()
1824
09d89de2
SH
1825 cmdline = "git rev-parse --symbolic "
1826 cmdline += " --remotes"
1827
1828 for line in read_pipe_lines(cmdline):
1829 line = line.strip()
1830
1831 if not line.startswith('p4/') or line == "p4/HEAD":
1832 continue
1833 branch = line
1834
1835 log = extractLogMessageFromGitCommit("refs/remotes/%s" % branch)
1836 settings = extractSettingsGitLog(log)
1837
1838 print "%s <= %s (%s)" % (branch, ",".join(settings["depot-paths"]), settings["change"])
1839 return True
1840
b984733c
SH
1841class HelpFormatter(optparse.IndentedHelpFormatter):
1842 def __init__(self):
1843 optparse.IndentedHelpFormatter.__init__(self)
1844
1845 def format_description(self, description):
1846 if description:
1847 return description + "\n"
1848 else:
1849 return ""
4f5cf76a 1850
86949eef
SH
1851def printUsage(commands):
1852 print "usage: %s <command> [options]" % sys.argv[0]
1853 print ""
1854 print "valid commands: %s" % ", ".join(commands)
1855 print ""
1856 print "Try %s <command> --help for command specific help." % sys.argv[0]
1857 print ""
1858
1859commands = {
b86f7378
HWN
1860 "debug" : P4Debug,
1861 "submit" : P4Submit,
a9834f58 1862 "commit" : P4Submit,
b86f7378
HWN
1863 "sync" : P4Sync,
1864 "rebase" : P4Rebase,
1865 "clone" : P4Clone,
09d89de2
SH
1866 "rollback" : P4RollBack,
1867 "branches" : P4Branches
86949eef
SH
1868}
1869
86949eef 1870
bb6e09b2
HWN
1871def main():
1872 if len(sys.argv[1:]) == 0:
1873 printUsage(commands.keys())
1874 sys.exit(2)
4f5cf76a 1875
bb6e09b2
HWN
1876 cmd = ""
1877 cmdName = sys.argv[1]
1878 try:
b86f7378
HWN
1879 klass = commands[cmdName]
1880 cmd = klass()
bb6e09b2
HWN
1881 except KeyError:
1882 print "unknown command %s" % cmdName
1883 print ""
1884 printUsage(commands.keys())
1885 sys.exit(2)
1886
1887 options = cmd.options
b86f7378 1888 cmd.gitdir = os.environ.get("GIT_DIR", None)
bb6e09b2
HWN
1889
1890 args = sys.argv[2:]
1891
1892 if len(options) > 0:
1893 options.append(optparse.make_option("--git-dir", dest="gitdir"))
1894
1895 parser = optparse.OptionParser(cmd.usage.replace("%prog", "%prog " + cmdName),
1896 options,
1897 description = cmd.description,
1898 formatter = HelpFormatter())
1899
1900 (cmd, args) = parser.parse_args(sys.argv[2:], cmd);
1901 global verbose
1902 verbose = cmd.verbose
1903 if cmd.needsGit:
b86f7378
HWN
1904 if cmd.gitdir == None:
1905 cmd.gitdir = os.path.abspath(".git")
1906 if not isValidGitDir(cmd.gitdir):
1907 cmd.gitdir = read_pipe("git rev-parse --git-dir").strip()
1908 if os.path.exists(cmd.gitdir):
bb6e09b2
HWN
1909 cdup = read_pipe("git rev-parse --show-cdup").strip()
1910 if len(cdup) > 0:
053fd0c1 1911 chdir(cdup);
e20a9e53 1912
b86f7378
HWN
1913 if not isValidGitDir(cmd.gitdir):
1914 if isValidGitDir(cmd.gitdir + "/.git"):
1915 cmd.gitdir += "/.git"
bb6e09b2 1916 else:
b86f7378 1917 die("fatal: cannot locate git repository at %s" % cmd.gitdir)
e20a9e53 1918
b86f7378 1919 os.environ["GIT_DIR"] = cmd.gitdir
86949eef 1920
bb6e09b2
HWN
1921 if not cmd.run(args):
1922 parser.print_help()
4f5cf76a 1923
4f5cf76a 1924
bb6e09b2
HWN
1925if __name__ == '__main__':
1926 main()