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