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