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