3 # git-p4.py -- A tool for bidirectional operation between a Perforce depot and git.
5 # Author: Simon Hausmann <simon@lst.de>
6 # Copyright: 2007 Simon Hausmann <simon@lst.de>
8 # License: MIT <http://www.opensource.org/licenses/mit-license.php>
11 import optparse
, sys
, os
, marshal
, subprocess
, shelve
12 import tempfile
, getopt
, os
.path
, time
, platform
18 def p4_build_cmd(cmd
):
19 """Build a suitable p4 command line.
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.
25 real_cmd
= "%s " % "p4"
27 user
= gitConfig("git-p4.user")
29 real_cmd
+= "-u %s " % user
31 password
= gitConfig("git-p4.password")
33 real_cmd
+= "-P %s " % password
35 port
= gitConfig("git-p4.port")
37 real_cmd
+= "-p %s " % port
39 host
= gitConfig("git-p4.host")
41 real_cmd
+= "-h %s " % host
43 client
= gitConfig("git-p4.client")
45 real_cmd
+= "-c %s " % client
47 real_cmd
+= "%s" % (cmd
)
61 sys
.stderr
.write(msg
+ "\n")
64 def write_pipe(c
, str):
66 sys
.stderr
.write('Writing pipe: %s\n' % c
)
68 pipe
= os
.popen(c
, 'w')
71 die('Command failed: %s' % c
)
75 def p4_write_pipe(c
, str):
76 real_cmd
= p4_build_cmd(c
)
77 return write_pipe(real_cmd
, str)
79 def read_pipe(c
, ignore_error
=False):
81 sys
.stderr
.write('Reading pipe: %s\n' % c
)
83 pipe
= os
.popen(c
, 'rb')
85 if pipe
.close() and not ignore_error
:
86 die('Command failed: %s' % c
)
90 def p4_read_pipe(c
, ignore_error
=False):
91 real_cmd
= p4_build_cmd(c
)
92 return read_pipe(real_cmd
, ignore_error
)
94 def read_pipe_lines(c
):
96 sys
.stderr
.write('Reading pipe: %s\n' % c
)
97 ## todo: check return status
98 pipe
= os
.popen(c
, 'rb')
99 val
= pipe
.readlines()
101 die('Command failed: %s' % c
)
105 def p4_read_pipe_lines(c
):
106 """Specifically invoke p4 on the command supplied. """
107 real_cmd
= p4_build_cmd(c
)
108 return read_pipe_lines(real_cmd
)
112 sys
.stderr
.write("executing %s\n" % cmd
)
113 if os
.system(cmd
) != 0:
114 die("command failed: %s" % cmd
)
117 """Specifically invoke p4 as the system command. """
118 real_cmd
= p4_build_cmd(cmd
)
119 return system(real_cmd
)
122 """Determine if a Perforce 'kind' should have execute permission
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)
129 def 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.
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]
142 p4_system("reopen -t %s %s" % (p4Type
, file))
144 def getP4OpenedType(file):
145 # Returns the perforce file type for the given file.
147 result
= p4_read_pipe("opened %s" % file)
148 match
= re
.match(".*\((.+)\)\r?$", result
)
150 return match
.group(1)
152 die("Could not determine file type for %s (result: '%s')" % (file, result
))
154 def 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(.*))|$)')
161 def parseDiffTreeEntry(entry
):
162 """Parses a single diff tree entry into its component elements.
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:
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.
178 If the pattern is not matched, None is returned."""
180 match
= diffTreePattern().next().match(entry
)
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)
194 def isModeExec(mode
):
195 # Returns True if the given git mode represents an executable file,
197 return mode
[-3:] == "755"
199 def isModeExecChanged(src_mode
, dst_mode
):
200 return isModeExec(src_mode
) != isModeExec(dst_mode
)
202 def p4CmdList(cmd
, stdin
=None, stdin_mode
='w+b', cb
=None):
203 cmd
= p4_build_cmd("-G %s" % (cmd
))
205 sys
.stderr
.write("Opening pipe: %s\n" % cmd
)
207 # Use a temporary file to avoid deadlocks without
208 # subprocess.communicate(), which would put another copy
209 # of stdout into memory.
211 if stdin
is not None:
212 stdin_file
= tempfile
.TemporaryFile(prefix
='p4-stdin', mode
=stdin_mode
)
213 stdin_file
.write(stdin
)
217 p4
= subprocess
.Popen(cmd
, shell
=True,
219 stdout
=subprocess
.PIPE
)
224 entry
= marshal
.load(p4
.stdout
)
234 entry
["p4ExitCode"] = exitCode
240 list = p4CmdList(cmd
)
246 def p4Where(depotPath
):
247 if not depotPath
.endswith("/"):
249 depotPath
= depotPath
+ "..."
250 outputList
= p4CmdList("where %s" % depotPath
)
252 for entry
in outputList
:
253 if "depotFile" in entry
:
254 if entry
["depotFile"] == depotPath
:
257 elif "data" in entry
:
258 data
= entry
.get("data")
259 space
= data
.find(" ")
260 if data
[:space
] == depotPath
:
265 if output
["code"] == "error":
269 clientPath
= output
.get("path")
270 elif "data" in output
:
271 data
= output
.get("data")
272 lastSpace
= data
.rfind(" ")
273 clientPath
= data
[lastSpace
+ 1:]
275 if clientPath
.endswith("..."):
276 clientPath
= clientPath
[:-3]
279 def currentGitBranch():
280 return read_pipe("git name-rev HEAD").split(" ")[1].strip()
282 def isValidGitDir(path
):
283 if (os
.path
.exists(path
+ "/HEAD")
284 and os
.path
.exists(path
+ "/refs") and os
.path
.exists(path
+ "/objects")):
288 def parseRevision(ref
):
289 return read_pipe("git rev-parse %s" % ref
).strip()
291 def extractLogMessageFromGitCommit(commit
):
294 ## fixme: title is first line of commit, not 1st paragraph.
296 for log
in read_pipe_lines("git cat-file commit %s" % commit
):
305 def extractSettingsGitLog(log
):
307 for line
in log
.split("\n"):
309 m
= re
.search (r
"^ *\[git-p4: (.*)\]$", line
)
313 assignments
= m
.group(1).split (':')
314 for a
in assignments
:
316 key
= vals
[0].strip()
317 val
= ('='.join (vals
[1:])).strip()
318 if val
.endswith ('\"') and val
.startswith('"'):
323 paths
= values
.get("depot-paths")
325 paths
= values
.get("depot-path")
327 values
['depot-paths'] = paths
.split(',')
330 def gitBranchExists(branch
):
331 proc
= subprocess
.Popen(["git", "rev-parse", branch
],
332 stderr
=subprocess
.PIPE
, stdout
=subprocess
.PIPE
);
333 return proc
.wait() == 0;
337 if not _gitConfig
.has_key(key
):
338 _gitConfig
[key
] = read_pipe("git config %s" % key
, ignore_error
=True).strip()
339 return _gitConfig
[key
]
341 def p4BranchesInGit(branchesAreInRemotes
= True):
344 cmdline
= "git rev-parse --symbolic "
345 if branchesAreInRemotes
:
346 cmdline
+= " --remotes"
348 cmdline
+= " --branches"
350 for line
in read_pipe_lines(cmdline
):
353 ## only import to p4/
354 if not line
.startswith('p4/') or line
== "p4/HEAD":
359 branch
= re
.sub ("^p4/", "", line
)
361 branches
[branch
] = parseRevision(line
)
364 def findUpstreamBranchPoint(head
= "HEAD"):
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
378 while parent
< 65535:
379 commit
= head
+ "~%s" % parent
380 log
= extractLogMessageFromGitCommit(commit
)
381 settings
= extractSettingsGitLog(log
)
382 if settings
.has_key("depot-paths"):
383 paths
= ",".join(settings
["depot-paths"])
384 if branchByDepotPath
.has_key(paths
):
385 return [branchByDepotPath
[paths
], settings
]
389 return ["", settings
]
391 def createOrUpdateBranchesFromOrigin(localRefPrefix
= "refs/remotes/p4/", silent
=True):
393 print ("Creating/updating branch(es) in %s based on origin branch(es)"
396 originPrefix
= "origin/p4/"
398 for line
in read_pipe_lines("git rev-parse --symbolic --remotes"):
400 if (not line
.startswith(originPrefix
)) or line
.endswith("HEAD"):
403 headName
= line
[len(originPrefix
):]
404 remoteHead
= localRefPrefix
+ headName
407 original
= extractSettingsGitLog(extractLogMessageFromGitCommit(originHead
))
408 if (not original
.has_key('depot-paths')
409 or not original
.has_key('change')):
413 if not gitBranchExists(remoteHead
):
415 print "creating %s" % remoteHead
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
))
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'])))
436 system("git update-ref %s %s" % (remoteHead
, originHead
))
438 def originP4BranchesExist():
439 return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
441 def p4ChangesForPaths(depotPaths
, changeRange
):
443 output
= p4_read_pipe_lines("changes " + ' '.join (["%s...%s" % (p
, changeRange
)
444 for p
in depotPaths
]))
448 changeNum
= int(line
.split(" ")[1])
449 changes
[changeNum
] = True
451 changelist
= changes
.keys()
457 self
.usage
= "usage: %prog [options]"
460 class P4Debug(Command
):
462 Command
.__init
__(self
)
464 optparse
.make_option("--verbose", dest
="verbose", action
="store_true",
467 self
.description
= "A tool to debug the output of p4 -G."
468 self
.needsGit
= False
473 for output
in p4CmdList(" ".join(args
)):
474 print 'Element: %d' % j
479 class P4RollBack(Command
):
481 Command
.__init
__(self
)
483 optparse
.make_option("--verbose", dest
="verbose", action
="store_true"),
484 optparse
.make_option("--local", dest
="rollbackLocalBranches", action
="store_true")
486 self
.description
= "A tool to debug the multi-branch import. Don't use :)"
488 self
.rollbackLocalBranches
= False
493 maxChange
= int(args
[0])
495 if "p4ExitCode" in p4Cmd("changes -m 1"):
496 die("Problems executing p4");
498 if self
.rollbackLocalBranches
:
499 refPrefix
= "refs/heads/"
500 lines
= read_pipe_lines("git rev-parse --symbolic --branches")
502 refPrefix
= "refs/remotes/"
503 lines
= read_pipe_lines("git rev-parse --symbolic --remotes")
506 if self
.rollbackLocalBranches
or (line
.startswith("p4/") and line
!= "p4/HEAD\n"):
508 ref
= refPrefix
+ line
509 log
= extractLogMessageFromGitCommit(ref
)
510 settings
= extractSettingsGitLog(log
)
512 depotPaths
= settings
['depot-paths']
513 change
= settings
['change']
517 if len(p4Cmd("changes -m 1 " + ' '.join (['%s...@%s' % (p
, maxChange
)
518 for p
in depotPaths
]))) == 0:
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
))
523 while change
and int(change
) > maxChange
:
526 print "%s is at %s ; rewinding towards %s" % (ref
, change
, maxChange
)
527 system("git update-ref %s \"%s^\"" % (ref
, ref
))
528 log
= extractLogMessageFromGitCommit(ref
)
529 settings
= extractSettingsGitLog(log
)
532 depotPaths
= settings
['depot-paths']
533 change
= settings
['change']
536 print "%s rewound to %s" % (ref
, change
)
540 class P4Submit(Command
):
542 Command
.__init
__(self
)
544 optparse
.make_option("--verbose", dest
="verbose", action
="store_true"),
545 optparse
.make_option("--origin", dest
="origin"),
546 optparse
.make_option("-M", dest
="detectRename", action
="store_true"),
548 self
.description
= "Submit changes from git to the perforce depot."
549 self
.usage
+= " [name of git branch to submit into perforce depot]"
550 self
.interactive
= True
552 self
.detectRename
= False
554 self
.isWindows
= (platform
.system() == "Windows")
557 if len(p4CmdList("opened ...")) > 0:
558 die("You have files opened with perforce! Close them before starting the sync.")
560 # replaces everything between 'Description:' and the next P4 submit template field with the
562 def prepareLogMessage(self
, template
, message
):
565 inDescriptionSection
= False
567 for line
in template
.split("\n"):
568 if line
.startswith("#"):
569 result
+= line
+ "\n"
572 if inDescriptionSection
:
573 if line
.startswith("Files:"):
574 inDescriptionSection
= False
578 if line
.startswith("Description:"):
579 inDescriptionSection
= True
581 for messageLine
in message
.split("\n"):
582 line
+= "\t" + messageLine
+ "\n"
584 result
+= line
+ "\n"
588 def prepareSubmitTemplate(self
):
589 # remove lines in the Files section that show changes to files outside the depot path we're committing into
591 inFilesSection
= False
592 for line
in p4_read_pipe_lines("change -o"):
593 if line
.endswith("\r\n"):
594 line
= line
[:-2] + "\n"
596 if line
.startswith("\t"):
597 # path starts and ends with a tab
599 lastTab
= path
.rfind("\t")
601 path
= path
[:lastTab
]
602 if not path
.startswith(self
.depotPath
):
605 inFilesSection
= False
607 if line
.startswith("Files:"):
608 inFilesSection
= True
614 def applyCommit(self
, id):
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))
619 filesToDelete
= set()
621 filesToChangeExecBit
= {}
623 diff
= parseDiffTreeEntry(line
)
624 modifier
= diff
['status']
627 p4_system("edit \"%s\"" % path
)
628 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
629 filesToChangeExecBit
[path
] = diff
['dst_mode']
630 editedFiles
.add(path
)
631 elif modifier
== "A":
633 filesToChangeExecBit
[path
] = diff
['dst_mode']
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
)
640 elif modifier
== "R":
641 src
, dest
= diff
['src'], diff
['dst']
642 p4_system("integrate -Dt \"%s\" \"%s\"" % (src
, dest
))
643 p4_system("edit \"%s\"" % (dest
))
644 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
645 filesToChangeExecBit
[dest
] = diff
['dst_mode']
647 editedFiles
.add(dest
)
648 filesToDelete
.add(src
)
650 die("unknown modifier %s for %s" % (modifier
, path
))
652 diffcmd
= "git format-patch -k --stdout \"%s^\"..\"%s\"" % (id, id)
653 patchcmd
= diffcmd
+ " | git apply "
654 tryPatchCmd
= patchcmd
+ "--check -"
655 applyPatchCmd
= patchcmd
+ "--check --apply -"
657 if os
.system(tryPatchCmd
) != 0:
658 print "Unfortunately applying the change failed!"
659 print "What do you want to do?"
661 while response
!= "s" and response
!= "a" and response
!= "w":
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) ")
665 print "Skipping! Good luck with the next patches..."
666 for f
in editedFiles
:
667 p4_system("revert \"%s\"" % f
);
671 elif response
== "a":
672 os
.system(applyPatchCmd
)
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
)
679 die("Please resolve and submit the conflict manually and "
680 + "continue afterwards with git-p4 submit --continue")
681 elif response
== "w":
682 system(diffcmd
+ " > patch.txt")
683 print "Patch saved to patch.txt in %s !" % self
.clientPath
684 die("Please resolve and submit the conflict manually and "
685 "continue afterwards with git-p4 submit --continue")
687 system(applyPatchCmd
)
690 p4_system("add \"%s\"" % f
)
691 for f
in filesToDelete
:
692 p4_system("revert \"%s\"" % f
)
693 p4_system("delete \"%s\"" % f
)
695 # Set/clear executable bits
696 for f
in filesToChangeExecBit
.keys():
697 mode
= filesToChangeExecBit
[f
]
698 setP4ExecBit(f
, mode
)
700 logMessage
= extractLogMessageFromGitCommit(id)
701 logMessage
= logMessage
.strip()
703 template
= self
.prepareSubmitTemplate()
706 submitTemplate
= self
.prepareLogMessage(template
, logMessage
)
707 if os
.environ
.has_key("P4DIFF"):
708 del(os
.environ
["P4DIFF"])
710 for editedFile
in editedFiles
:
711 diff
+= p4_read_pipe("diff -du %r" % editedFile
)
714 for newFile
in filesToAdd
:
715 newdiff
+= "==== new file ====\n"
716 newdiff
+= "--- /dev/null\n"
717 newdiff
+= "+++ %s\n" % newFile
718 f
= open(newFile
, "r")
719 for line
in f
.readlines():
720 newdiff
+= "+" + line
723 separatorLine
= "######## everything below this line is just the diff #######\n"
725 [handle
, fileName
] = tempfile
.mkstemp()
726 tmpFile
= os
.fdopen(handle
, "w+")
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
)
733 mtime
= os
.stat(fileName
).st_mtime
734 if os
.environ
.has_key("P4EDITOR"):
735 editor
= os
.environ
.get("P4EDITOR")
737 editor
= read_pipe("git var GIT_EDITOR").strip()
738 system(editor
+ " " + fileName
)
741 if os
.stat(fileName
).st_mtime
<= mtime
:
743 while response
!= "y" and response
!= "n":
744 response
= raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")
747 tmpFile
= open(fileName
, "rb")
748 message
= tmpFile
.read()
750 submitTemplate
= message
[:message
.index(separatorLine
)]
752 submitTemplate
= submitTemplate
.replace("\r\n", "\n")
753 p4_write_pipe("submit -i", submitTemplate
)
755 for f
in editedFiles
:
756 p4_system("revert \"%s\"" % f
);
758 p4_system("revert \"%s\"" % f
);
763 fileName
= "submit.txt"
764 file = open(fileName
, "w+")
765 file.write(self
.prepareLogMessage(template
, logMessage
))
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
))
773 self
.master
= currentGitBranch()
774 if len(self
.master
) == 0 or not gitBranchExists("refs/heads/%s" % self
.master
):
775 die("Detecting current git branch failed!")
777 self
.master
= args
[0]
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
)
785 [upstream
, settings
] = findUpstreamBranchPoint()
786 self
.depotPath
= settings
['depot-paths'][0]
787 if len(self
.origin
) == 0:
788 self
.origin
= upstream
791 print "Origin branch is " + self
.origin
793 if len(self
.depotPath
) == 0:
794 print "Internal error: cannot locate perforce depot path from existing branches"
797 self
.clientPath
= p4Where(self
.depotPath
)
799 if len(self
.clientPath
) == 0:
800 print "Error: Cannot locate perforce checkout of %s in client view" % self
.depotPath
803 print "Perforce checkout for depot path %s located at %s" % (self
.depotPath
, self
.clientPath
)
804 self
.oldWorkingDirectory
= os
.getcwd()
806 chdir(self
.clientPath
)
807 print "Synchronizing p4 checkout..."
808 p4_system("sync ...")
813 for line
in read_pipe_lines("git rev-list --no-merges %s..%s" % (self
.origin
, self
.master
)):
814 commits
.append(line
.strip())
817 while len(commits
) > 0:
819 commits
= commits
[1:]
820 self
.applyCommit(commit
)
821 if not self
.interactive
:
824 if len(commits
) == 0:
825 print "All changes applied!"
826 chdir(self
.oldWorkingDirectory
)
836 class P4Sync(Command
):
837 delete_actions
= ( "delete", "move/delete", "purge" )
840 Command
.__init
__(self
)
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"),
846 optparse
.make_option("--detect-labels", dest
="detectLabels", action
="store_true"),
847 optparse
.make_option("--verbose", dest
="verbose", action
="store_true"),
848 optparse
.make_option("--import-local", dest
="importIntoRemotes", action
="store_false",
849 help="Import into refs/heads/ , not refs/remotes"),
850 optparse
.make_option("--max-changes", dest
="maxChanges"),
851 optparse
.make_option("--keep-path", dest
="keepRepoPath", action
='store_true',
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")
856 self
.description
= """Imports from Perforce into a git repository.\n
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
862 (a ... is not needed in the path p4 specification, it's added implicitly)"""
864 self
.usage
+= " //depot/path[@revRange]"
866 self
.createdBranches
= set()
867 self
.committedChanges
= set()
869 self
.detectBranches
= False
870 self
.detectLabels
= False
871 self
.changesFile
= ""
872 self
.syncWithOrigin
= True
874 self
.importIntoRemotes
= True
876 self
.isWindows
= (platform
.system() == "Windows")
877 self
.keepRepoPath
= False
878 self
.depotPaths
= None
879 self
.p4BranchesInGit
= []
880 self
.cloneExclude
= []
881 self
.useClientSpec
= False
882 self
.clientSpecDirs
= []
884 if gitConfig("git-p4.syncFromOrigin") == "false":
885 self
.syncWithOrigin
= False
887 def extractFilesFromCommit(self
, commit
):
888 self
.cloneExclude
= [re
.sub(r
"\.\.\.$", "", path
)
889 for path
in self
.cloneExclude
]
892 while commit
.has_key("depotFile%s" % fnum
):
893 path
= commit
["depotFile%s" % fnum
]
895 if [p
for p
in self
.cloneExclude
896 if path
.startswith (p
)]:
899 found
= [p
for p
in self
.depotPaths
900 if path
.startswith (p
)]
907 file["rev"] = commit
["rev%s" % fnum
]
908 file["action"] = commit
["action%s" % fnum
]
909 file["type"] = commit
["type%s" % fnum
]
914 def stripRepoPath(self
, path
, prefixes
):
915 if self
.keepRepoPath
:
916 prefixes
= [re
.sub("^(//[^/]+/).*", r
'\1', prefixes
[0])]
919 if path
.startswith(p
):
924 def splitFilesIntoBranches(self
, commit
):
927 while commit
.has_key("depotFile%s" % fnum
):
928 path
= commit
["depotFile%s" % fnum
]
929 found
= [p
for p
in self
.depotPaths
930 if path
.startswith (p
)]
937 file["rev"] = commit
["rev%s" % fnum
]
938 file["action"] = commit
["action%s" % fnum
]
939 file["type"] = commit
["type%s" % fnum
]
942 relPath
= self
.stripRepoPath(path
, self
.depotPaths
)
944 for branch
in self
.knownBranches
.keys():
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
+ "/"):
948 if branch
not in branches
:
949 branches
[branch
] = []
950 branches
[branch
].append(file)
955 # output one file from the P4 stream
956 # - helper for streamP4Files
958 def streamOneP4File(self
, file, contents
):
959 if file["type"] == "apple":
960 print "\nfile %s is a strange apple file that forks. Ignoring" % \
964 relPath
= self
.stripRepoPath(file['depotFile'], self
.branchPrefixes
)
966 sys
.stderr
.write("%s\n" % relPath
)
969 if isP4Exec(file["type"]):
971 elif file["type"] == "symlink":
973 # p4 print on a symlink contains "target\n", so strip it off
974 data
= ''.join(contents
)
975 contents
= [data
[:-1]]
977 if self
.isWindows
and file["type"].endswith("text"):
979 for data
in contents
:
980 data
= data
.replace("\r\n", "\n")
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
)
989 self
.gitStream
.write("M %s inline %s\n" % (mode
, relPath
))
994 length
= length
+ len(d
)
996 self
.gitStream
.write("data %d\n" % length
)
998 self
.gitStream
.write(d
)
999 self
.gitStream
.write("\n")
1001 def streamOneP4Deletion(self
, file):
1002 relPath
= self
.stripRepoPath(file['path'], self
.branchPrefixes
)
1004 sys
.stderr
.write("delete %s\n" % relPath
)
1005 self
.gitStream
.write("D %s\n" % relPath
)
1007 # handle another chunk of streaming data
1008 def streamP4FilesCb(self
, marshalled
):
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
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():
1021 self
.stream_contents
.append(marshalled
['data'])
1023 self
.stream_file
[k
] = marshalled
[k
]
1025 self
.stream_have_file_info
= True
1027 # Stream directly from "p4 files" into "git fast-import"
1028 def streamP4Files(self
, files
):
1035 for val
in self
.clientSpecDirs
:
1036 if f
['path'].startswith(val
[0]):
1042 filesForCommit
.append(f
)
1043 if f
['action'] in self
.delete_actions
:
1044 filesToDelete
.append(f
)
1046 filesToRead
.append(f
)
1049 for f
in filesToDelete
:
1050 self
.streamOneP4Deletion(f
)
1052 if len(filesToRead
) > 0:
1053 self
.stream_file
= {}
1054 self
.stream_contents
= []
1055 self
.stream_have_file_info
= False
1057 # curry self argument
1058 def streamP4FilesCbSelf(entry
):
1059 self
.streamP4FilesCb(entry
)
1061 p4CmdList("-x - print",
1062 '\n'.join(['%s#%s' % (f
['path'], f
['rev'])
1063 for f
in filesToRead
]),
1064 cb
=streamP4FilesCbSelf
)
1067 if self
.stream_file
.has_key('depotFile'):
1068 self
.streamOneP4File(self
.stream_file
, self
.stream_contents
)
1070 def commit(self
, details
, files
, branch
, branchPrefixes
, parent
= ""):
1071 epoch
= details
["time"]
1072 author
= details
["user"]
1073 self
.branchPrefixes
= branchPrefixes
1076 print "commit into %s" % branch
1078 # start with reading files; if that fails, we should not
1082 if [p
for p
in branchPrefixes
if f
['path'].startswith(p
)]:
1083 new_files
.append (f
)
1085 sys
.stderr
.write("Ignoring file outside of prefix: %s\n" % path
)
1087 self
.gitStream
.write("commit %s\n" % branch
)
1088 # gitStream.write("mark :%s\n" % details["change"])
1089 self
.committedChanges
.add(int(details
["change"]))
1091 if author
not in self
.users
:
1092 self
.getUserMapFromPerforceServer()
1093 if author
in self
.users
:
1094 committer
= "%s %s %s" % (self
.users
[author
], epoch
, self
.tz
)
1096 committer
= "%s <a@b> %s %s" % (author
, epoch
, self
.tz
)
1098 self
.gitStream
.write("committer %s\n" % committer
)
1100 self
.gitStream
.write("data <<EOT\n")
1101 self
.gitStream
.write(details
["desc"])
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")
1110 print "parent %s" % parent
1111 self
.gitStream
.write("from %s\n" % parent
)
1113 self
.streamP4Files(new_files
)
1114 self
.gitStream
.write("\n")
1116 change
= int(details
["change"])
1118 if self
.labels
.has_key(change
):
1119 label
= self
.labels
[change
]
1120 labelDetails
= label
[0]
1121 labelRevisions
= label
[1]
1123 print "Change %s is labelled %s" % (change
, labelDetails
)
1125 files
= p4CmdList("files " + ' '.join (["%s...@%s" % (p
, change
)
1126 for p
in branchPrefixes
]))
1128 if len(files
) == len(labelRevisions
):
1132 if info
["action"] in self
.delete_actions
:
1134 cleanedFiles
[info
["depotFile"]] = info
["rev"]
1136 if cleanedFiles
== labelRevisions
:
1137 self
.gitStream
.write("tag tag_%s\n" % labelDetails
["label"])
1138 self
.gitStream
.write("from %s\n" % branch
)
1140 owner
= labelDetails
["Owner"]
1142 if author
in self
.users
:
1143 tagger
= "%s %s %s" % (self
.users
[owner
], epoch
, self
.tz
)
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")
1153 print ("Tag %s does not match with change %s: files do not match."
1154 % (labelDetails
["label"], change
))
1158 print ("Tag %s does not match with change %s: file count is different."
1159 % (labelDetails
["label"], change
))
1161 def getUserCacheFilename(self
):
1162 home
= os
.environ
.get("HOME", os
.environ
.get("USERPROFILE"))
1163 return home
+ "/.gitp4-usercache.txt"
1165 def getUserMapFromPerforceServer(self
):
1166 if self
.userMapFromPerforceServer
:
1170 for output
in p4CmdList("users"):
1171 if not output
.has_key("User"):
1173 self
.users
[output
["User"]] = output
["FullName"] + " <" + output
["Email"] + ">"
1177 for (key
, val
) in self
.users
.items():
1178 s
+= "%s\t%s\n" % (key
.expandtabs(1), val
.expandtabs(1))
1180 open(self
.getUserCacheFilename(), "wb").write(s
)
1181 self
.userMapFromPerforceServer
= True
1183 def loadUserMapFromCache(self
):
1185 self
.userMapFromPerforceServer
= False
1187 cache
= open(self
.getUserCacheFilename(), "rb")
1188 lines
= cache
.readlines()
1191 entry
= line
.strip().split("\t")
1192 self
.users
[entry
[0]] = entry
[1]
1194 self
.getUserMapFromPerforceServer()
1196 def getLabels(self
):
1199 l
= p4CmdList("labels %s..." % ' '.join (self
.depotPaths
))
1200 if len(l
) > 0 and not self
.silent
:
1201 print "Finding files belonging to labels in %s" % `self
.depotPaths`
1204 label
= output
["label"]
1208 print "Querying files for label %s" % label
1209 for file in p4CmdList("files "
1210 + ' '.join (["%s...@%s" % (p
, label
)
1211 for p
in self
.depotPaths
])):
1212 revisions
[file["depotFile"]] = file["rev"]
1213 change
= int(file["change"])
1214 if change
> newestChange
:
1215 newestChange
= change
1217 self
.labels
[newestChange
] = [output
, revisions
]
1220 print "Label changes: %s" % self
.labels
.keys()
1222 def guessProjectName(self
):
1223 for p
in self
.depotPaths
:
1226 p
= p
[p
.strip().rfind("/") + 1:]
1227 if not p
.endswith("/"):
1231 def getBranchMapping(self
):
1232 lostAndFoundBranches
= set()
1234 for info
in p4CmdList("branches"):
1235 details
= p4Cmd("branch -o %s" % info
["branch"])
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("/..."):
1244 destination
= paths
[1]
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]
1250 if destination
in self
.knownBranches
:
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
)
1256 self
.knownBranches
[destination
] = source
1258 lostAndFoundBranches
.discard(destination
)
1260 if source
not in self
.knownBranches
:
1261 lostAndFoundBranches
.add(source
)
1264 for branch
in lostAndFoundBranches
:
1265 self
.knownBranches
[branch
] = branch
1267 def getBranchMappingFromGitBranches(self
):
1268 branches
= p4BranchesInGit(self
.importIntoRemotes
)
1269 for branch
in branches
.keys():
1270 if branch
== "master":
1273 branch
= branch
[len(self
.projectName
):]
1274 self
.knownBranches
[branch
] = branch
1276 def listExistingP4GitBranches(self
):
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
]
1283 def updateOptionDict(self
, d
):
1285 if self
.keepRepoPath
:
1286 option_keys
['keepRepoPath'] = 1
1288 d
["options"] = ' '.join(sorted(option_keys
.keys()))
1290 def readOptions(self
, d
):
1291 self
.keepRepoPath
= (d
.has_key('options')
1292 and ('keepRepoPath' in d
['options']))
1294 def gitRefForBranch(self
, branch
):
1295 if branch
== "main":
1296 return self
.refPrefix
+ "master"
1298 if len(branch
) <= 0:
1301 return self
.refPrefix
+ self
.projectName
+ branch
1303 def gitCommitByP4Change(self
, ref
, change
):
1305 print "looking in ref " + ref
+ " for change %s using bisect..." % change
1308 latestCommit
= parseRevision(ref
)
1312 print "trying: earliest %s latest %s" % (earliestCommit
, latestCommit
)
1313 next
= read_pipe("git rev-list --bisect %s %s" % (latestCommit
, earliestCommit
)).strip()
1318 log
= extractLogMessageFromGitCommit(next
)
1319 settings
= extractSettingsGitLog(log
)
1320 currentChange
= int(settings
['change'])
1322 print "current change %s" % currentChange
1324 if currentChange
== change
:
1326 print "found %s" % next
1329 if currentChange
< change
:
1330 earliestCommit
= "^%s" % next
1332 latestCommit
= "%s" % next
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:
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
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
1361 self
.importChanges(changes
)
1364 def importChanges(self
, changes
):
1366 for change
in changes
:
1367 description
= p4Cmd("describe %s" % change
)
1368 self
.updateOptionDict(description
)
1371 sys
.stdout
.write("\rImporting revision %s (%s%%)" % (change
, cnt
* 100 / len(changes
)))
1376 if self
.detectBranches
:
1377 branches
= self
.splitFilesIntoBranches(description
)
1378 for branch
in branches
.keys():
1380 branchPrefix
= self
.depotPaths
[0] + branch
+ "/"
1384 filesForCommit
= branches
[branch
]
1387 print "branch is %s" % branch
1389 self
.updatedBranches
.add(branch
)
1391 if branch
not in self
.createdBranches
:
1392 self
.createdBranches
.add(branch
)
1393 parent
= self
.knownBranches
[branch
]
1394 if parent
== branch
:
1397 fullBranch
= self
.projectName
+ branch
1398 if fullBranch
not in self
.p4BranchesInGit
:
1400 print("\n Importing new branch %s" % fullBranch
);
1401 if self
.importNewBranch(branch
, change
- 1):
1403 self
.p4BranchesInGit
.append(fullBranch
)
1405 print("\n Resuming with change %s" % change
);
1408 print "parent determined through known branches: %s" % parent
1410 branch
= self
.gitRefForBranch(branch
)
1411 parent
= self
.gitRefForBranch(parent
)
1414 print "looking for initial parent for %s; current parent is %s" % (branch
, parent
)
1416 if len(parent
) == 0 and branch
in self
.initialParents
:
1417 parent
= self
.initialParents
[branch
]
1418 del self
.initialParents
[branch
]
1420 self
.commit(description
, filesForCommit
, branch
, [branchPrefix
], parent
)
1422 files
= self
.extractFilesFromCommit(description
)
1423 self
.commit(description
, files
, self
.branch
, self
.depotPaths
,
1425 self
.initialParent
= ""
1427 print self
.gitError
.read()
1430 def importHeadRevision(self
, revision
):
1431 print "Doing initial import of %s from revision %s into %s" % (' '.join(self
.depotPaths
), revision
, self
.branch
)
1433 details
= { "user" : "git perforce import user", "time" : int(time
.time()) }
1434 details
["desc"] = ("Initial import of %s from the state at revision %s\n"
1435 % (' '.join(self
.depotPaths
), revision
))
1436 details
["change"] = revision
1440 for info
in p4CmdList("files "
1441 + ' '.join(["%s...%s"
1443 for p
in self
.depotPaths
])):
1445 if 'code' in info
and info
['code'] == 'error':
1446 sys
.stderr
.write("p4 returned an error: %s\n"
1448 if info
['data'].find("must refer to client") >= 0:
1449 sys
.stderr
.write("This particular p4 error is misleading.\n")
1450 sys
.stderr
.write("Perhaps the depot path was misspelled.\n");
1451 sys
.stderr
.write("Depot path: %s\n" % " ".join(self
.depotPaths
))
1453 if 'p4ExitCode' in info
:
1454 sys
.stderr
.write("p4 exitcode: %s\n" % info
['p4ExitCode'])
1458 change
= int(info
["change"])
1459 if change
> newestRevision
:
1460 newestRevision
= change
1462 if info
["action"] in self
.delete_actions
:
1463 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
1464 #fileCnt = fileCnt + 1
1467 for prop
in ["depotFile", "rev", "action", "type" ]:
1468 details
["%s%s" % (prop
, fileCnt
)] = info
[prop
]
1470 fileCnt
= fileCnt
+ 1
1472 details
["change"] = newestRevision
1473 self
.updateOptionDict(details
)
1475 self
.commit(details
, self
.extractFilesFromCommit(details
), self
.branch
, self
.depotPaths
)
1477 print "IO error with git fast-import. Is your git version recent enough?"
1478 print self
.gitError
.read()
1481 def getClientSpec(self
):
1482 specList
= p4CmdList( "client -o" )
1484 for entry
in specList
:
1485 for k
,v
in entry
.iteritems():
1486 if k
.startswith("View"):
1487 if v
.startswith('"'):
1491 index
= v
.find("...")
1493 if v
.startswith("-"):
1498 self
.clientSpecDirs
= temp
.items()
1499 self
.clientSpecDirs
.sort( lambda x
, y
: abs( y
[1] ) - abs( x
[1] ) )
1501 def run(self
, args
):
1502 self
.depotPaths
= []
1503 self
.changeRange
= ""
1504 self
.initialParent
= ""
1505 self
.previousDepotPaths
= []
1507 # map from branch depot path to parent branch
1508 self
.knownBranches
= {}
1509 self
.initialParents
= {}
1510 self
.hasOrigin
= originP4BranchesExist()
1511 if not self
.syncWithOrigin
:
1512 self
.hasOrigin
= False
1514 if self
.importIntoRemotes
:
1515 self
.refPrefix
= "refs/remotes/p4/"
1517 self
.refPrefix
= "refs/heads/p4/"
1519 if self
.syncWithOrigin
and self
.hasOrigin
:
1521 print "Syncing with origin first by calling git fetch origin"
1522 system("git fetch origin")
1524 if len(self
.branch
) == 0:
1525 self
.branch
= self
.refPrefix
+ "master"
1526 if gitBranchExists("refs/heads/p4") and self
.importIntoRemotes
:
1527 system("git update-ref %s refs/heads/p4" % self
.branch
)
1528 system("git branch -D p4");
1529 # create it /after/ importing, when master exists
1530 if not gitBranchExists(self
.refPrefix
+ "HEAD") and self
.importIntoRemotes
and gitBranchExists(self
.branch
):
1531 system("git symbolic-ref %sHEAD %s" % (self
.refPrefix
, self
.branch
))
1533 if self
.useClientSpec
or gitConfig("git-p4.useclientspec") == "true":
1534 self
.getClientSpec()
1536 # TODO: should always look at previous commits,
1537 # merge with previous imports, if possible.
1540 createOrUpdateBranchesFromOrigin(self
.refPrefix
, self
.silent
)
1541 self
.listExistingP4GitBranches()
1543 if len(self
.p4BranchesInGit
) > 1:
1545 print "Importing from/into multiple branches"
1546 self
.detectBranches
= True
1549 print "branches: %s" % self
.p4BranchesInGit
1552 for branch
in self
.p4BranchesInGit
:
1553 logMsg
= extractLogMessageFromGitCommit(self
.refPrefix
+ branch
)
1555 settings
= extractSettingsGitLog(logMsg
)
1557 self
.readOptions(settings
)
1558 if (settings
.has_key('depot-paths')
1559 and settings
.has_key ('change')):
1560 change
= int(settings
['change']) + 1
1561 p4Change
= max(p4Change
, change
)
1563 depotPaths
= sorted(settings
['depot-paths'])
1564 if self
.previousDepotPaths
== []:
1565 self
.previousDepotPaths
= depotPaths
1568 for (prev
, cur
) in zip(self
.previousDepotPaths
, depotPaths
):
1569 for i
in range(0, min(len(cur
), len(prev
))):
1570 if cur
[i
] <> prev
[i
]:
1574 paths
.append (cur
[:i
+ 1])
1576 self
.previousDepotPaths
= paths
1579 self
.depotPaths
= sorted(self
.previousDepotPaths
)
1580 self
.changeRange
= "@%s,#head" % p4Change
1581 if not self
.detectBranches
:
1582 self
.initialParent
= parseRevision(self
.branch
)
1583 if not self
.silent
and not self
.detectBranches
:
1584 print "Performing incremental import into %s git branch" % self
.branch
1586 if not self
.branch
.startswith("refs/"):
1587 self
.branch
= "refs/heads/" + self
.branch
1589 if len(args
) == 0 and self
.depotPaths
:
1591 print "Depot paths: %s" % ' '.join(self
.depotPaths
)
1593 if self
.depotPaths
and self
.depotPaths
!= args
:
1594 print ("previous import used depot path %s and now %s was specified. "
1595 "This doesn't work!" % (' '.join (self
.depotPaths
),
1599 self
.depotPaths
= sorted(args
)
1605 for p
in self
.depotPaths
:
1606 if p
.find("@") != -1:
1607 atIdx
= p
.index("@")
1608 self
.changeRange
= p
[atIdx
:]
1609 if self
.changeRange
== "@all":
1610 self
.changeRange
= ""
1611 elif ',' not in self
.changeRange
:
1612 revision
= self
.changeRange
1613 self
.changeRange
= ""
1615 elif p
.find("#") != -1:
1616 hashIdx
= p
.index("#")
1617 revision
= p
[hashIdx
:]
1619 elif self
.previousDepotPaths
== []:
1622 p
= re
.sub ("\.\.\.$", "", p
)
1623 if not p
.endswith("/"):
1628 self
.depotPaths
= newPaths
1631 self
.loadUserMapFromCache()
1633 if self
.detectLabels
:
1636 if self
.detectBranches
:
1637 ## FIXME - what's a P4 projectName ?
1638 self
.projectName
= self
.guessProjectName()
1641 self
.getBranchMappingFromGitBranches()
1643 self
.getBranchMapping()
1645 print "p4-git branches: %s" % self
.p4BranchesInGit
1646 print "initial parents: %s" % self
.initialParents
1647 for b
in self
.p4BranchesInGit
:
1651 b
= b
[len(self
.projectName
):]
1652 self
.createdBranches
.add(b
)
1654 self
.tz
= "%+03d%02d" % (- time
.timezone
/ 3600, ((- time
.timezone
% 3600) / 60))
1656 importProcess
= subprocess
.Popen(["git", "fast-import"],
1657 stdin
=subprocess
.PIPE
, stdout
=subprocess
.PIPE
,
1658 stderr
=subprocess
.PIPE
);
1659 self
.gitOutput
= importProcess
.stdout
1660 self
.gitStream
= importProcess
.stdin
1661 self
.gitError
= importProcess
.stderr
1664 self
.importHeadRevision(revision
)
1668 if len(self
.changesFile
) > 0:
1669 output
= open(self
.changesFile
).readlines()
1672 changeSet
.add(int(line
))
1674 for change
in changeSet
:
1675 changes
.append(change
)
1680 print "Getting p4 changes for %s...%s" % (', '.join(self
.depotPaths
),
1682 changes
= p4ChangesForPaths(self
.depotPaths
, self
.changeRange
)
1684 if len(self
.maxChanges
) > 0:
1685 changes
= changes
[:min(int(self
.maxChanges
), len(changes
))]
1687 if len(changes
) == 0:
1689 print "No changes to import!"
1692 if not self
.silent
and not self
.detectBranches
:
1693 print "Import destination: %s" % self
.branch
1695 self
.updatedBranches
= set()
1697 self
.importChanges(changes
)
1701 if len(self
.updatedBranches
) > 0:
1702 sys
.stdout
.write("Updated branches: ")
1703 for b
in self
.updatedBranches
:
1704 sys
.stdout
.write("%s " % b
)
1705 sys
.stdout
.write("\n")
1707 self
.gitStream
.close()
1708 if importProcess
.wait() != 0:
1709 die("fast-import failed: %s" % self
.gitError
.read())
1710 self
.gitOutput
.close()
1711 self
.gitError
.close()
1715 class P4Rebase(Command
):
1717 Command
.__init
__(self
)
1719 self
.description
= ("Fetches the latest revision from perforce and "
1720 + "rebases the current work (branch) against it")
1721 self
.verbose
= False
1723 def run(self
, args
):
1727 return self
.rebase()
1730 if os
.system("git update-index --refresh") != 0:
1731 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.");
1732 if len(read_pipe("git diff-index HEAD --")) > 0:
1733 die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
1735 [upstream
, settings
] = findUpstreamBranchPoint()
1736 if len(upstream
) == 0:
1737 die("Cannot find upstream branchpoint for rebase")
1739 # the branchpoint may be p4/foo~3, so strip off the parent
1740 upstream
= re
.sub("~[0-9]+$", "", upstream
)
1742 print "Rebasing the current branch onto %s" % upstream
1743 oldHead
= read_pipe("git rev-parse HEAD").strip()
1744 system("git rebase %s" % upstream
)
1745 system("git diff-tree --stat --summary -M %s HEAD" % oldHead
)
1748 class P4Clone(P4Sync
):
1750 P4Sync
.__init
__(self
)
1751 self
.description
= "Creates a new git repository and imports from Perforce into it"
1752 self
.usage
= "usage: %prog [options] //depot/path[@revRange]"
1754 optparse
.make_option("--destination", dest
="cloneDestination",
1755 action
='store', default
=None,
1756 help="where to leave result of the clone"),
1757 optparse
.make_option("-/", dest
="cloneExclude",
1758 action
="append", type="string",
1759 help="exclude depot path")
1761 self
.cloneDestination
= None
1762 self
.needsGit
= False
1764 # This is required for the "append" cloneExclude action
1765 def ensure_value(self
, attr
, value
):
1766 if not hasattr(self
, attr
) or getattr(self
, attr
) is None:
1767 setattr(self
, attr
, value
)
1768 return getattr(self
, attr
)
1770 def defaultDestination(self
, args
):
1771 ## TODO: use common prefix of args?
1773 depotDir
= re
.sub("(@[^@]*)$", "", depotPath
)
1774 depotDir
= re
.sub("(#[^#]*)$", "", depotDir
)
1775 depotDir
= re
.sub(r
"\.\.\.$", "", depotDir
)
1776 depotDir
= re
.sub(r
"/$", "", depotDir
)
1777 return os
.path
.split(depotDir
)[1]
1779 def run(self
, args
):
1783 if self
.keepRepoPath
and not self
.cloneDestination
:
1784 sys
.stderr
.write("Must specify destination for --keep-path\n")
1789 if not self
.cloneDestination
and len(depotPaths
) > 1:
1790 self
.cloneDestination
= depotPaths
[-1]
1791 depotPaths
= depotPaths
[:-1]
1793 self
.cloneExclude
= ["/"+p
for p
in self
.cloneExclude
]
1794 for p
in depotPaths
:
1795 if not p
.startswith("//"):
1798 if not self
.cloneDestination
:
1799 self
.cloneDestination
= self
.defaultDestination(args
)
1801 print "Importing from %s into %s" % (', '.join(depotPaths
), self
.cloneDestination
)
1802 if not os
.path
.exists(self
.cloneDestination
):
1803 os
.makedirs(self
.cloneDestination
)
1804 chdir(self
.cloneDestination
)
1806 self
.gitdir
= os
.getcwd() + "/.git"
1807 if not P4Sync
.run(self
, depotPaths
):
1809 if self
.branch
!= "master":
1810 if self
.importIntoRemotes
:
1811 masterbranch
= "refs/remotes/p4/master"
1813 masterbranch
= "refs/heads/p4/master"
1814 if gitBranchExists(masterbranch
):
1815 system("git branch master %s" % masterbranch
)
1816 system("git checkout -f")
1818 print "Could not detect main branch. No checkout/master branch created."
1822 class P4Branches(Command
):
1824 Command
.__init
__(self
)
1826 self
.description
= ("Shows the git branches that hold imports and their "
1827 + "corresponding perforce depot paths")
1828 self
.verbose
= False
1830 def run(self
, args
):
1831 if originP4BranchesExist():
1832 createOrUpdateBranchesFromOrigin()
1834 cmdline
= "git rev-parse --symbolic "
1835 cmdline
+= " --remotes"
1837 for line
in read_pipe_lines(cmdline
):
1840 if not line
.startswith('p4/') or line
== "p4/HEAD":
1844 log
= extractLogMessageFromGitCommit("refs/remotes/%s" % branch
)
1845 settings
= extractSettingsGitLog(log
)
1847 print "%s <= %s (%s)" % (branch
, ",".join(settings
["depot-paths"]), settings
["change"])
1850 class HelpFormatter(optparse
.IndentedHelpFormatter
):
1852 optparse
.IndentedHelpFormatter
.__init
__(self
)
1854 def format_description(self
, description
):
1856 return description
+ "\n"
1860 def printUsage(commands
):
1861 print "usage: %s <command> [options]" % sys
.argv
[0]
1863 print "valid commands: %s" % ", ".join(commands
)
1865 print "Try %s <command> --help for command specific help." % sys
.argv
[0]
1870 "submit" : P4Submit
,
1871 "commit" : P4Submit
,
1873 "rebase" : P4Rebase
,
1875 "rollback" : P4RollBack
,
1876 "branches" : P4Branches
1881 if len(sys
.argv
[1:]) == 0:
1882 printUsage(commands
.keys())
1886 cmdName
= sys
.argv
[1]
1888 klass
= commands
[cmdName
]
1891 print "unknown command %s" % cmdName
1893 printUsage(commands
.keys())
1896 options
= cmd
.options
1897 cmd
.gitdir
= os
.environ
.get("GIT_DIR", None)
1901 if len(options
) > 0:
1902 options
.append(optparse
.make_option("--git-dir", dest
="gitdir"))
1904 parser
= optparse
.OptionParser(cmd
.usage
.replace("%prog", "%prog " + cmdName
),
1906 description
= cmd
.description
,
1907 formatter
= HelpFormatter())
1909 (cmd
, args
) = parser
.parse_args(sys
.argv
[2:], cmd
);
1911 verbose
= cmd
.verbose
1913 if cmd
.gitdir
== None:
1914 cmd
.gitdir
= os
.path
.abspath(".git")
1915 if not isValidGitDir(cmd
.gitdir
):
1916 cmd
.gitdir
= read_pipe("git rev-parse --git-dir").strip()
1917 if os
.path
.exists(cmd
.gitdir
):
1918 cdup
= read_pipe("git rev-parse --show-cdup").strip()
1922 if not isValidGitDir(cmd
.gitdir
):
1923 if isValidGitDir(cmd
.gitdir
+ "/.git"):
1924 cmd
.gitdir
+= "/.git"
1926 die("fatal: cannot locate git repository at %s" % cmd
.gitdir
)
1928 os
.environ
["GIT_DIR"] = cmd
.gitdir
1930 if not cmd
.run(args
):
1934 if __name__
== '__main__':