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.
27 user
= gitConfig("git-p4.user")
29 real_cmd
+= ["-u",user
]
31 password
= gitConfig("git-p4.password")
33 real_cmd
+= ["-P", password
]
35 port
= gitConfig("git-p4.port")
37 real_cmd
+= ["-p", port
]
39 host
= gitConfig("git-p4.host")
41 real_cmd
+= ["-h", host
]
43 client
= gitConfig("git-p4.client")
45 real_cmd
+= ["-c", client
]
48 if isinstance(cmd
,basestring
):
49 real_cmd
= ' '.join(real_cmd
) + ' ' + cmd
55 # P4 uses the PWD environment variable rather than getcwd(). Since we're
56 # not using the shell, we have to set it ourselves. This path could
57 # be relative, so go there first, then figure out where we ended up.
59 os
.environ
['PWD'] = os
.getcwd()
65 sys
.stderr
.write(msg
+ "\n")
68 def write_pipe(c
, stdin
):
70 sys
.stderr
.write('Writing pipe: %s\n' % str(c
))
72 expand
= isinstance(c
,basestring
)
73 p
= subprocess
.Popen(c
, stdin
=subprocess
.PIPE
, shell
=expand
)
75 val
= pipe
.write(stdin
)
78 die('Command failed: %s' % str(c
))
82 def p4_write_pipe(c
, stdin
):
83 real_cmd
= p4_build_cmd(c
)
84 return write_pipe(real_cmd
, stdin
)
86 def read_pipe(c
, ignore_error
=False):
88 sys
.stderr
.write('Reading pipe: %s\n' % str(c
))
90 expand
= isinstance(c
,basestring
)
91 p
= subprocess
.Popen(c
, stdout
=subprocess
.PIPE
, shell
=expand
)
94 if p
.wait() and not ignore_error
:
95 die('Command failed: %s' % str(c
))
99 def p4_read_pipe(c
, ignore_error
=False):
100 real_cmd
= p4_build_cmd(c
)
101 return read_pipe(real_cmd
, ignore_error
)
103 def read_pipe_lines(c
):
105 sys
.stderr
.write('Reading pipe: %s\n' % str(c
))
107 expand
= isinstance(c
, basestring
)
108 p
= subprocess
.Popen(c
, stdout
=subprocess
.PIPE
, shell
=expand
)
110 val
= pipe
.readlines()
111 if pipe
.close() or p
.wait():
112 die('Command failed: %s' % str(c
))
116 def p4_read_pipe_lines(c
):
117 """Specifically invoke p4 on the command supplied. """
118 real_cmd
= p4_build_cmd(c
)
119 return read_pipe_lines(real_cmd
)
122 expand
= isinstance(cmd
,basestring
)
124 sys
.stderr
.write("executing %s\n" % str(cmd
))
125 subprocess
.check_call(cmd
, shell
=expand
)
128 """Specifically invoke p4 as the system command. """
129 real_cmd
= p4_build_cmd(cmd
)
130 expand
= isinstance(real_cmd
, basestring
)
131 subprocess
.check_call(real_cmd
, shell
=expand
)
133 def p4_integrate(src
, dest
):
134 p4_system(["integrate", "-Dt", src
, dest
])
137 p4_system(["sync", path
])
140 p4_system(["add", f
])
143 p4_system(["delete", f
])
146 p4_system(["edit", f
])
149 p4_system(["revert", f
])
151 def p4_reopen(type, file):
152 p4_system(["reopen", "-t", type, file])
155 # Canonicalize the p4 type and return a tuple of the
156 # base type, plus any modifiers. See "p4 help filetypes"
157 # for a list and explanation.
159 def split_p4_type(p4type
):
161 p4_filetypes_historical
= {
162 "ctempobj": "binary+Sw",
168 "tempobj": "binary+FSw",
169 "ubinary": "binary+F",
170 "uresource": "resource+F",
171 "uxbinary": "binary+Fx",
172 "xbinary": "binary+x",
174 "xtempobj": "binary+Swx",
176 "xunicode": "unicode+x",
179 if p4type
in p4_filetypes_historical
:
180 p4type
= p4_filetypes_historical
[p4type
]
182 s
= p4type
.split("+")
190 def setP4ExecBit(file, mode
):
191 # Reopens an already open file and changes the execute bit to match
192 # the execute bit setting in the passed in mode.
196 if not isModeExec(mode
):
197 p4Type
= getP4OpenedType(file)
198 p4Type
= re
.sub('^([cku]?)x(.*)', '\\1\\2', p4Type
)
199 p4Type
= re
.sub('(.*?\+.*?)x(.*?)', '\\1\\2', p4Type
)
200 if p4Type
[-1] == "+":
201 p4Type
= p4Type
[0:-1]
203 p4_reopen(p4Type
, file)
205 def getP4OpenedType(file):
206 # Returns the perforce file type for the given file.
208 result
= p4_read_pipe(["opened", file])
209 match
= re
.match(".*\((.+)\)\r?$", result
)
211 return match
.group(1)
213 die("Could not determine file type for %s (result: '%s')" % (file, result
))
215 def diffTreePattern():
216 # This is a simple generator for the diff tree regex pattern. This could be
217 # a class variable if this and parseDiffTreeEntry were a part of a class.
218 pattern
= re
.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)')
222 def parseDiffTreeEntry(entry
):
223 """Parses a single diff tree entry into its component elements.
225 See git-diff-tree(1) manpage for details about the format of the diff
226 output. This method returns a dictionary with the following elements:
228 src_mode - The mode of the source file
229 dst_mode - The mode of the destination file
230 src_sha1 - The sha1 for the source file
231 dst_sha1 - The sha1 fr the destination file
232 status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc)
233 status_score - The score for the status (applicable for 'C' and 'R'
234 statuses). This is None if there is no score.
235 src - The path for the source file.
236 dst - The path for the destination file. This is only present for
237 copy or renames. If it is not present, this is None.
239 If the pattern is not matched, None is returned."""
241 match
= diffTreePattern().next().match(entry
)
244 'src_mode': match
.group(1),
245 'dst_mode': match
.group(2),
246 'src_sha1': match
.group(3),
247 'dst_sha1': match
.group(4),
248 'status': match
.group(5),
249 'status_score': match
.group(6),
250 'src': match
.group(7),
251 'dst': match
.group(10)
255 def isModeExec(mode
):
256 # Returns True if the given git mode represents an executable file,
258 return mode
[-3:] == "755"
260 def isModeExecChanged(src_mode
, dst_mode
):
261 return isModeExec(src_mode
) != isModeExec(dst_mode
)
263 def p4CmdList(cmd
, stdin
=None, stdin_mode
='w+b', cb
=None):
265 if isinstance(cmd
,basestring
):
272 cmd
= p4_build_cmd(cmd
)
274 sys
.stderr
.write("Opening pipe: %s\n" % str(cmd
))
276 # Use a temporary file to avoid deadlocks without
277 # subprocess.communicate(), which would put another copy
278 # of stdout into memory.
280 if stdin
is not None:
281 stdin_file
= tempfile
.TemporaryFile(prefix
='p4-stdin', mode
=stdin_mode
)
282 if isinstance(stdin
,basestring
):
283 stdin_file
.write(stdin
)
286 stdin_file
.write(i
+ '\n')
290 p4
= subprocess
.Popen(cmd
,
293 stdout
=subprocess
.PIPE
)
298 entry
= marshal
.load(p4
.stdout
)
308 entry
["p4ExitCode"] = exitCode
314 list = p4CmdList(cmd
)
320 def p4Where(depotPath
):
321 if not depotPath
.endswith("/"):
323 depotPath
= depotPath
+ "..."
324 outputList
= p4CmdList(["where", depotPath
])
326 for entry
in outputList
:
327 if "depotFile" in entry
:
328 if entry
["depotFile"] == depotPath
:
331 elif "data" in entry
:
332 data
= entry
.get("data")
333 space
= data
.find(" ")
334 if data
[:space
] == depotPath
:
339 if output
["code"] == "error":
343 clientPath
= output
.get("path")
344 elif "data" in output
:
345 data
= output
.get("data")
346 lastSpace
= data
.rfind(" ")
347 clientPath
= data
[lastSpace
+ 1:]
349 if clientPath
.endswith("..."):
350 clientPath
= clientPath
[:-3]
353 def currentGitBranch():
354 return read_pipe("git name-rev HEAD").split(" ")[1].strip()
356 def isValidGitDir(path
):
357 if (os
.path
.exists(path
+ "/HEAD")
358 and os
.path
.exists(path
+ "/refs") and os
.path
.exists(path
+ "/objects")):
362 def parseRevision(ref
):
363 return read_pipe("git rev-parse %s" % ref
).strip()
365 def branchExists(ref
):
366 rev
= read_pipe(["git", "rev-parse", "-q", "--verify", ref
],
370 def extractLogMessageFromGitCommit(commit
):
373 ## fixme: title is first line of commit, not 1st paragraph.
375 for log
in read_pipe_lines("git cat-file commit %s" % commit
):
384 def extractSettingsGitLog(log
):
386 for line
in log
.split("\n"):
388 m
= re
.search (r
"^ *\[git-p4: (.*)\]$", line
)
392 assignments
= m
.group(1).split (':')
393 for a
in assignments
:
395 key
= vals
[0].strip()
396 val
= ('='.join (vals
[1:])).strip()
397 if val
.endswith ('\"') and val
.startswith('"'):
402 paths
= values
.get("depot-paths")
404 paths
= values
.get("depot-path")
406 values
['depot-paths'] = paths
.split(',')
409 def gitBranchExists(branch
):
410 proc
= subprocess
.Popen(["git", "rev-parse", branch
],
411 stderr
=subprocess
.PIPE
, stdout
=subprocess
.PIPE
);
412 return proc
.wait() == 0;
415 def gitConfig(key
, args
= None): # set args to "--bool", for instance
416 if not _gitConfig
.has_key(key
):
419 argsFilter
= "%s " % args
420 cmd
= "git config %s%s" % (argsFilter
, key
)
421 _gitConfig
[key
] = read_pipe(cmd
, ignore_error
=True).strip()
422 return _gitConfig
[key
]
424 def gitConfigList(key
):
425 if not _gitConfig
.has_key(key
):
426 _gitConfig
[key
] = read_pipe("git config --get-all %s" % key
, ignore_error
=True).strip().split(os
.linesep
)
427 return _gitConfig
[key
]
429 def p4BranchesInGit(branchesAreInRemotes
= True):
432 cmdline
= "git rev-parse --symbolic "
433 if branchesAreInRemotes
:
434 cmdline
+= " --remotes"
436 cmdline
+= " --branches"
438 for line
in read_pipe_lines(cmdline
):
441 ## only import to p4/
442 if not line
.startswith('p4/') or line
== "p4/HEAD":
447 branch
= re
.sub ("^p4/", "", line
)
449 branches
[branch
] = parseRevision(line
)
452 def findUpstreamBranchPoint(head
= "HEAD"):
453 branches
= p4BranchesInGit()
454 # map from depot-path to branch name
455 branchByDepotPath
= {}
456 for branch
in branches
.keys():
457 tip
= branches
[branch
]
458 log
= extractLogMessageFromGitCommit(tip
)
459 settings
= extractSettingsGitLog(log
)
460 if settings
.has_key("depot-paths"):
461 paths
= ",".join(settings
["depot-paths"])
462 branchByDepotPath
[paths
] = "remotes/p4/" + branch
466 while parent
< 65535:
467 commit
= head
+ "~%s" % parent
468 log
= extractLogMessageFromGitCommit(commit
)
469 settings
= extractSettingsGitLog(log
)
470 if settings
.has_key("depot-paths"):
471 paths
= ",".join(settings
["depot-paths"])
472 if branchByDepotPath
.has_key(paths
):
473 return [branchByDepotPath
[paths
], settings
]
477 return ["", settings
]
479 def createOrUpdateBranchesFromOrigin(localRefPrefix
= "refs/remotes/p4/", silent
=True):
481 print ("Creating/updating branch(es) in %s based on origin branch(es)"
484 originPrefix
= "origin/p4/"
486 for line
in read_pipe_lines("git rev-parse --symbolic --remotes"):
488 if (not line
.startswith(originPrefix
)) or line
.endswith("HEAD"):
491 headName
= line
[len(originPrefix
):]
492 remoteHead
= localRefPrefix
+ headName
495 original
= extractSettingsGitLog(extractLogMessageFromGitCommit(originHead
))
496 if (not original
.has_key('depot-paths')
497 or not original
.has_key('change')):
501 if not gitBranchExists(remoteHead
):
503 print "creating %s" % remoteHead
506 settings
= extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead
))
507 if settings
.has_key('change') > 0:
508 if settings
['depot-paths'] == original
['depot-paths']:
509 originP4Change
= int(original
['change'])
510 p4Change
= int(settings
['change'])
511 if originP4Change
> p4Change
:
512 print ("%s (%s) is newer than %s (%s). "
513 "Updating p4 branch from origin."
514 % (originHead
, originP4Change
,
515 remoteHead
, p4Change
))
518 print ("Ignoring: %s was imported from %s while "
519 "%s was imported from %s"
520 % (originHead
, ','.join(original
['depot-paths']),
521 remoteHead
, ','.join(settings
['depot-paths'])))
524 system("git update-ref %s %s" % (remoteHead
, originHead
))
526 def originP4BranchesExist():
527 return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
529 def p4ChangesForPaths(depotPaths
, changeRange
):
533 cmd
+= ["%s...%s" % (p
, changeRange
)]
534 output
= p4_read_pipe_lines(cmd
)
538 changeNum
= int(line
.split(" ")[1])
539 changes
[changeNum
] = True
541 changelist
= changes
.keys()
545 def p4PathStartsWith(path
, prefix
):
546 # This method tries to remedy a potential mixed-case issue:
548 # If UserA adds //depot/DirA/file1
549 # and UserB adds //depot/dira/file2
551 # we may or may not have a problem. If you have core.ignorecase=true,
552 # we treat DirA and dira as the same directory
553 ignorecase
= gitConfig("core.ignorecase", "--bool") == "true"
555 return path
.lower().startswith(prefix
.lower())
556 return path
.startswith(prefix
)
560 self
.usage
= "usage: %prog [options]"
565 self
.userMapFromPerforceServer
= False
566 self
.myP4UserId
= None
570 return self
.myP4UserId
572 results
= p4CmdList("user -o")
574 if r
.has_key('User'):
575 self
.myP4UserId
= r
['User']
577 die("Could not find your p4 user id")
579 def p4UserIsMe(self
, p4User
):
580 # return True if the given p4 user is actually me
582 if not p4User
or p4User
!= me
:
587 def getUserCacheFilename(self
):
588 home
= os
.environ
.get("HOME", os
.environ
.get("USERPROFILE"))
589 return home
+ "/.gitp4-usercache.txt"
591 def getUserMapFromPerforceServer(self
):
592 if self
.userMapFromPerforceServer
:
597 for output
in p4CmdList("users"):
598 if not output
.has_key("User"):
600 self
.users
[output
["User"]] = output
["FullName"] + " <" + output
["Email"] + ">"
601 self
.emails
[output
["Email"]] = output
["User"]
605 for (key
, val
) in self
.users
.items():
606 s
+= "%s\t%s\n" % (key
.expandtabs(1), val
.expandtabs(1))
608 open(self
.getUserCacheFilename(), "wb").write(s
)
609 self
.userMapFromPerforceServer
= True
611 def loadUserMapFromCache(self
):
613 self
.userMapFromPerforceServer
= False
615 cache
= open(self
.getUserCacheFilename(), "rb")
616 lines
= cache
.readlines()
619 entry
= line
.strip().split("\t")
620 self
.users
[entry
[0]] = entry
[1]
622 self
.getUserMapFromPerforceServer()
624 class P4Debug(Command
):
626 Command
.__init
__(self
)
628 optparse
.make_option("--verbose", dest
="verbose", action
="store_true",
631 self
.description
= "A tool to debug the output of p4 -G."
632 self
.needsGit
= False
637 for output
in p4CmdList(args
):
638 print 'Element: %d' % j
643 class P4RollBack(Command
):
645 Command
.__init
__(self
)
647 optparse
.make_option("--verbose", dest
="verbose", action
="store_true"),
648 optparse
.make_option("--local", dest
="rollbackLocalBranches", action
="store_true")
650 self
.description
= "A tool to debug the multi-branch import. Don't use :)"
652 self
.rollbackLocalBranches
= False
657 maxChange
= int(args
[0])
659 if "p4ExitCode" in p4Cmd("changes -m 1"):
660 die("Problems executing p4");
662 if self
.rollbackLocalBranches
:
663 refPrefix
= "refs/heads/"
664 lines
= read_pipe_lines("git rev-parse --symbolic --branches")
666 refPrefix
= "refs/remotes/"
667 lines
= read_pipe_lines("git rev-parse --symbolic --remotes")
670 if self
.rollbackLocalBranches
or (line
.startswith("p4/") and line
!= "p4/HEAD\n"):
672 ref
= refPrefix
+ line
673 log
= extractLogMessageFromGitCommit(ref
)
674 settings
= extractSettingsGitLog(log
)
676 depotPaths
= settings
['depot-paths']
677 change
= settings
['change']
681 if len(p4Cmd("changes -m 1 " + ' '.join (['%s...@%s' % (p
, maxChange
)
682 for p
in depotPaths
]))) == 0:
683 print "Branch %s did not exist at change %s, deleting." % (ref
, maxChange
)
684 system("git update-ref -d %s `git rev-parse %s`" % (ref
, ref
))
687 while change
and int(change
) > maxChange
:
690 print "%s is at %s ; rewinding towards %s" % (ref
, change
, maxChange
)
691 system("git update-ref %s \"%s^\"" % (ref
, ref
))
692 log
= extractLogMessageFromGitCommit(ref
)
693 settings
= extractSettingsGitLog(log
)
696 depotPaths
= settings
['depot-paths']
697 change
= settings
['change']
700 print "%s rewound to %s" % (ref
, change
)
704 class P4Submit(Command
, P4UserMap
):
706 Command
.__init
__(self
)
707 P4UserMap
.__init
__(self
)
709 optparse
.make_option("--verbose", dest
="verbose", action
="store_true"),
710 optparse
.make_option("--origin", dest
="origin"),
711 optparse
.make_option("-M", dest
="detectRenames", action
="store_true"),
712 # preserve the user, requires relevant p4 permissions
713 optparse
.make_option("--preserve-user", dest
="preserveUser", action
="store_true"),
715 self
.description
= "Submit changes from git to the perforce depot."
716 self
.usage
+= " [name of git branch to submit into perforce depot]"
717 self
.interactive
= True
719 self
.detectRenames
= False
721 self
.preserveUser
= gitConfig("git-p4.preserveUser").lower() == "true"
722 self
.isWindows
= (platform
.system() == "Windows")
725 if len(p4CmdList("opened ...")) > 0:
726 die("You have files opened with perforce! Close them before starting the sync.")
728 # replaces everything between 'Description:' and the next P4 submit template field with the
730 def prepareLogMessage(self
, template
, message
):
733 inDescriptionSection
= False
735 for line
in template
.split("\n"):
736 if line
.startswith("#"):
737 result
+= line
+ "\n"
740 if inDescriptionSection
:
741 if line
.startswith("Files:") or line
.startswith("Jobs:"):
742 inDescriptionSection
= False
746 if line
.startswith("Description:"):
747 inDescriptionSection
= True
749 for messageLine
in message
.split("\n"):
750 line
+= "\t" + messageLine
+ "\n"
752 result
+= line
+ "\n"
756 def p4UserForCommit(self
,id):
757 # Return the tuple (perforce user,git email) for a given git commit id
758 self
.getUserMapFromPerforceServer()
759 gitEmail
= read_pipe("git log --max-count=1 --format='%%ae' %s" % id)
760 gitEmail
= gitEmail
.strip()
761 if not self
.emails
.has_key(gitEmail
):
762 return (None,gitEmail
)
764 return (self
.emails
[gitEmail
],gitEmail
)
766 def checkValidP4Users(self
,commits
):
767 # check if any git authors cannot be mapped to p4 users
769 (user
,email
) = self
.p4UserForCommit(id)
771 msg
= "Cannot find p4 user for email %s in commit %s." % (email
, id)
772 if gitConfig('git-p4.allowMissingP4Users').lower() == "true":
775 die("Error: %s\nSet git-p4.allowMissingP4Users to true to allow this." % msg
)
777 def lastP4Changelist(self
):
778 # Get back the last changelist number submitted in this client spec. This
779 # then gets used to patch up the username in the change. If the same
780 # client spec is being used by multiple processes then this might go
782 results
= p4CmdList("client -o") # find the current client
785 if r
.has_key('Client'):
789 die("could not get client spec")
790 results
= p4CmdList(["changes", "-c", client
, "-m", "1"])
792 if r
.has_key('change'):
794 die("Could not get changelist number for last submit - cannot patch up user details")
796 def modifyChangelistUser(self
, changelist
, newUser
):
797 # fixup the user field of a changelist after it has been submitted.
798 changes
= p4CmdList("change -o %s" % changelist
)
799 if len(changes
) != 1:
800 die("Bad output from p4 change modifying %s to user %s" %
801 (changelist
, newUser
))
804 if c
['User'] == newUser
: return # nothing to do
806 input = marshal
.dumps(c
)
808 result
= p4CmdList("change -f -i", stdin
=input)
810 if r
.has_key('code'):
811 if r
['code'] == 'error':
812 die("Could not modify user field of changelist %s to %s:%s" % (changelist
, newUser
, r
['data']))
813 if r
.has_key('data'):
814 print("Updated user field for changelist %s to %s" % (changelist
, newUser
))
816 die("Could not modify user field of changelist %s to %s" % (changelist
, newUser
))
818 def canChangeChangelists(self
):
819 # check to see if we have p4 admin or super-user permissions, either of
820 # which are required to modify changelists.
821 results
= p4CmdList(["protects", self
.depotPath
])
823 if r
.has_key('perm'):
824 if r
['perm'] == 'admin':
826 if r
['perm'] == 'super':
830 def prepareSubmitTemplate(self
):
831 # remove lines in the Files section that show changes to files outside the depot path we're committing into
833 inFilesSection
= False
834 for line
in p4_read_pipe_lines(['change', '-o']):
835 if line
.endswith("\r\n"):
836 line
= line
[:-2] + "\n"
838 if line
.startswith("\t"):
839 # path starts and ends with a tab
841 lastTab
= path
.rfind("\t")
843 path
= path
[:lastTab
]
844 if not p4PathStartsWith(path
, self
.depotPath
):
847 inFilesSection
= False
849 if line
.startswith("Files:"):
850 inFilesSection
= True
856 def edit_template(self
, template_file
):
857 """Invoke the editor to let the user change the submission
858 message. Return true if okay to continue with the submit."""
860 # if configured to skip the editing part, just submit
861 if gitConfig("git-p4.skipSubmitEdit") == "true":
864 # look at the modification time, to check later if the user saved
866 mtime
= os
.stat(template_file
).st_mtime
869 if os
.environ
.has_key("P4EDITOR"):
870 editor
= os
.environ
.get("P4EDITOR")
872 editor
= read_pipe("git var GIT_EDITOR").strip()
873 system(editor
+ " " + template_file
)
875 # If the file was not saved, prompt to see if this patch should
876 # be skipped. But skip this verification step if configured so.
877 if gitConfig("git-p4.skipSubmitEditCheck") == "true":
880 # modification time updated means user saved the file
881 if os
.stat(template_file
).st_mtime
> mtime
:
885 response
= raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")
891 def applyCommit(self
, id):
892 print "Applying %s" % (read_pipe("git log --max-count=1 --pretty=oneline %s" % id))
894 (p4User
, gitEmail
) = self
.p4UserForCommit(id)
896 if not self
.detectRenames
:
897 # If not explicitly set check the config variable
898 self
.detectRenames
= gitConfig("git-p4.detectRenames")
900 if self
.detectRenames
.lower() == "false" or self
.detectRenames
== "":
902 elif self
.detectRenames
.lower() == "true":
905 diffOpts
= "-M%s" % self
.detectRenames
907 detectCopies
= gitConfig("git-p4.detectCopies")
908 if detectCopies
.lower() == "true":
910 elif detectCopies
!= "" and detectCopies
.lower() != "false":
911 diffOpts
+= " -C%s" % detectCopies
913 if gitConfig("git-p4.detectCopiesHarder", "--bool") == "true":
914 diffOpts
+= " --find-copies-harder"
916 diff
= read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (diffOpts
, id, id))
918 filesToDelete
= set()
920 filesToChangeExecBit
= {}
922 diff
= parseDiffTreeEntry(line
)
923 modifier
= diff
['status']
927 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
928 filesToChangeExecBit
[path
] = diff
['dst_mode']
929 editedFiles
.add(path
)
930 elif modifier
== "A":
932 filesToChangeExecBit
[path
] = diff
['dst_mode']
933 if path
in filesToDelete
:
934 filesToDelete
.remove(path
)
935 elif modifier
== "D":
936 filesToDelete
.add(path
)
937 if path
in filesToAdd
:
938 filesToAdd
.remove(path
)
939 elif modifier
== "C":
940 src
, dest
= diff
['src'], diff
['dst']
941 p4_integrate(src
, dest
)
942 if diff
['src_sha1'] != diff
['dst_sha1']:
944 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
946 filesToChangeExecBit
[dest
] = diff
['dst_mode']
948 editedFiles
.add(dest
)
949 elif modifier
== "R":
950 src
, dest
= diff
['src'], diff
['dst']
951 p4_integrate(src
, dest
)
952 if diff
['src_sha1'] != diff
['dst_sha1']:
954 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
956 filesToChangeExecBit
[dest
] = diff
['dst_mode']
958 editedFiles
.add(dest
)
959 filesToDelete
.add(src
)
961 die("unknown modifier %s for %s" % (modifier
, path
))
963 diffcmd
= "git format-patch -k --stdout \"%s^\"..\"%s\"" % (id, id)
964 patchcmd
= diffcmd
+ " | git apply "
965 tryPatchCmd
= patchcmd
+ "--check -"
966 applyPatchCmd
= patchcmd
+ "--check --apply -"
968 if os
.system(tryPatchCmd
) != 0:
969 print "Unfortunately applying the change failed!"
970 print "What do you want to do?"
972 while response
!= "s" and response
!= "a" and response
!= "w":
973 response
= raw_input("[s]kip this patch / [a]pply the patch forcibly "
974 "and with .rej files / [w]rite the patch to a file (patch.txt) ")
976 print "Skipping! Good luck with the next patches..."
977 for f
in editedFiles
:
982 elif response
== "a":
983 os
.system(applyPatchCmd
)
984 if len(filesToAdd
) > 0:
985 print "You may also want to call p4 add on the following files:"
986 print " ".join(filesToAdd
)
987 if len(filesToDelete
):
988 print "The following files should be scheduled for deletion with p4 delete:"
989 print " ".join(filesToDelete
)
990 die("Please resolve and submit the conflict manually and "
991 + "continue afterwards with git-p4 submit --continue")
992 elif response
== "w":
993 system(diffcmd
+ " > patch.txt")
994 print "Patch saved to patch.txt in %s !" % self
.clientPath
995 die("Please resolve and submit the conflict manually and "
996 "continue afterwards with git-p4 submit --continue")
998 system(applyPatchCmd
)
1000 for f
in filesToAdd
:
1002 for f
in filesToDelete
:
1006 # Set/clear executable bits
1007 for f
in filesToChangeExecBit
.keys():
1008 mode
= filesToChangeExecBit
[f
]
1009 setP4ExecBit(f
, mode
)
1011 logMessage
= extractLogMessageFromGitCommit(id)
1012 logMessage
= logMessage
.strip()
1014 template
= self
.prepareSubmitTemplate()
1016 if self
.interactive
:
1017 submitTemplate
= self
.prepareLogMessage(template
, logMessage
)
1019 if self
.preserveUser
:
1020 submitTemplate
= submitTemplate
+ ("\n######## Actual user %s, modified after commit\n" % p4User
)
1022 if os
.environ
.has_key("P4DIFF"):
1023 del(os
.environ
["P4DIFF"])
1025 for editedFile
in editedFiles
:
1026 diff
+= p4_read_pipe(['diff', '-du', editedFile
])
1029 for newFile
in filesToAdd
:
1030 newdiff
+= "==== new file ====\n"
1031 newdiff
+= "--- /dev/null\n"
1032 newdiff
+= "+++ %s\n" % newFile
1033 f
= open(newFile
, "r")
1034 for line
in f
.readlines():
1035 newdiff
+= "+" + line
1038 if self
.checkAuthorship
and not self
.p4UserIsMe(p4User
):
1039 submitTemplate
+= "######## git author %s does not match your p4 account.\n" % gitEmail
1040 submitTemplate
+= "######## Use git-p4 option --preserve-user to modify authorship\n"
1041 submitTemplate
+= "######## Use git-p4 config git-p4.skipUserNameCheck hides this message.\n"
1043 separatorLine
= "######## everything below this line is just the diff #######\n"
1045 (handle
, fileName
) = tempfile
.mkstemp()
1046 tmpFile
= os
.fdopen(handle
, "w+")
1048 submitTemplate
= submitTemplate
.replace("\n", "\r\n")
1049 separatorLine
= separatorLine
.replace("\n", "\r\n")
1050 newdiff
= newdiff
.replace("\n", "\r\n")
1051 tmpFile
.write(submitTemplate
+ separatorLine
+ diff
+ newdiff
)
1054 if self
.edit_template(fileName
):
1055 # read the edited message and submit
1056 tmpFile
= open(fileName
, "rb")
1057 message
= tmpFile
.read()
1059 submitTemplate
= message
[:message
.index(separatorLine
)]
1061 submitTemplate
= submitTemplate
.replace("\r\n", "\n")
1062 p4_write_pipe(['submit', '-i'], submitTemplate
)
1064 if self
.preserveUser
:
1066 # Get last changelist number. Cannot easily get it from
1067 # the submit command output as the output is
1069 changelist
= self
.lastP4Changelist()
1070 self
.modifyChangelistUser(changelist
, p4User
)
1073 print "Submission cancelled, undoing p4 changes."
1074 for f
in editedFiles
:
1076 for f
in filesToAdd
:
1082 fileName
= "submit.txt"
1083 file = open(fileName
, "w+")
1084 file.write(self
.prepareLogMessage(template
, logMessage
))
1086 print ("Perforce submit template written as %s. "
1087 + "Please review/edit and then use p4 submit -i < %s to submit directly!"
1088 % (fileName
, fileName
))
1090 def run(self
, args
):
1092 self
.master
= currentGitBranch()
1093 if len(self
.master
) == 0 or not gitBranchExists("refs/heads/%s" % self
.master
):
1094 die("Detecting current git branch failed!")
1095 elif len(args
) == 1:
1096 self
.master
= args
[0]
1097 if not branchExists(self
.master
):
1098 die("Branch %s does not exist" % self
.master
)
1102 allowSubmit
= gitConfig("git-p4.allowSubmit")
1103 if len(allowSubmit
) > 0 and not self
.master
in allowSubmit
.split(","):
1104 die("%s is not in git-p4.allowSubmit" % self
.master
)
1106 [upstream
, settings
] = findUpstreamBranchPoint()
1107 self
.depotPath
= settings
['depot-paths'][0]
1108 if len(self
.origin
) == 0:
1109 self
.origin
= upstream
1111 if self
.preserveUser
:
1112 if not self
.canChangeChangelists():
1113 die("Cannot preserve user names without p4 super-user or admin permissions")
1116 print "Origin branch is " + self
.origin
1118 if len(self
.depotPath
) == 0:
1119 print "Internal error: cannot locate perforce depot path from existing branches"
1122 self
.clientPath
= p4Where(self
.depotPath
)
1124 if len(self
.clientPath
) == 0:
1125 print "Error: Cannot locate perforce checkout of %s in client view" % self
.depotPath
1128 print "Perforce checkout for depot path %s located at %s" % (self
.depotPath
, self
.clientPath
)
1129 self
.oldWorkingDirectory
= os
.getcwd()
1131 # ensure the clientPath exists
1132 if not os
.path
.exists(self
.clientPath
):
1133 os
.makedirs(self
.clientPath
)
1135 chdir(self
.clientPath
)
1136 print "Synchronizing p4 checkout..."
1141 for line
in read_pipe_lines("git rev-list --no-merges %s..%s" % (self
.origin
, self
.master
)):
1142 commits
.append(line
.strip())
1145 if self
.preserveUser
or (gitConfig("git-p4.skipUserNameCheck") == "true"):
1146 self
.checkAuthorship
= False
1148 self
.checkAuthorship
= True
1150 if self
.preserveUser
:
1151 self
.checkValidP4Users(commits
)
1153 while len(commits
) > 0:
1155 commits
= commits
[1:]
1156 self
.applyCommit(commit
)
1157 if not self
.interactive
:
1160 if len(commits
) == 0:
1161 print "All changes applied!"
1162 chdir(self
.oldWorkingDirectory
)
1173 """Represent a p4 view ("p4 help views"), and map files in a
1174 repo according to the view."""
1177 """A depot or client path, possibly containing wildcards.
1178 The only one supported is ... at the end, currently.
1179 Initialize with the full path, with //depot or //client."""
1181 def __init__(self
, path
, is_depot
):
1183 self
.is_depot
= is_depot
1184 self
.find_wildcards()
1185 # remember the prefix bit, useful for relative mappings
1186 m
= re
.match("(//[^/]+/)", self
.path
)
1188 die("Path %s does not start with //prefix/" % self
.path
)
1190 if not self
.is_depot
:
1191 # strip //client/ on client paths
1192 self
.path
= self
.path
[len(prefix
):]
1194 def find_wildcards(self
):
1195 """Make sure wildcards are valid, and set up internal
1198 self
.ends_triple_dot
= False
1199 # There are three wildcards allowed in p4 views
1200 # (see "p4 help views"). This code knows how to
1201 # handle "..." (only at the end), but cannot deal with
1202 # "%%n" or "*". Only check the depot_side, as p4 should
1203 # validate that the client_side matches too.
1204 if re
.search(r
'%%[1-9]', self
.path
):
1205 die("Can't handle %%n wildcards in view: %s" % self
.path
)
1206 if self
.path
.find("*") >= 0:
1207 die("Can't handle * wildcards in view: %s" % self
.path
)
1208 triple_dot_index
= self
.path
.find("...")
1209 if triple_dot_index
>= 0:
1210 if not self
.path
.endswith("..."):
1211 die("Can handle ... wildcard only at end of path: %s" %
1213 self
.ends_triple_dot
= True
1215 def ensure_compatible(self
, other_path
):
1216 """Make sure the wildcards agree."""
1217 if self
.ends_triple_dot
!= other_path
.ends_triple_dot
:
1218 die("Both paths must end with ... if either does;\n" +
1219 "paths: %s %s" % (self
.path
, other_path
.path
))
1221 def match_wildcards(self
, test_path
):
1222 """See if this test_path matches us, and fill in the value
1223 of the wildcards if so. Returns a tuple of
1224 (True|False, wildcards[]). For now, only the ... at end
1225 is supported, so at most one wildcard."""
1226 if self
.ends_triple_dot
:
1227 dotless
= self
.path
[:-3]
1228 if test_path
.startswith(dotless
):
1229 wildcard
= test_path
[len(dotless
):]
1230 return (True, [ wildcard
])
1232 if test_path
== self
.path
:
1236 def match(self
, test_path
):
1237 """Just return if it matches; don't bother with the wildcards."""
1238 b
, _
= self
.match_wildcards(test_path
)
1241 def fill_in_wildcards(self
, wildcards
):
1242 """Return the relative path, with the wildcards filled in
1243 if there are any."""
1244 if self
.ends_triple_dot
:
1245 return self
.path
[:-3] + wildcards
[0]
1249 class Mapping(object):
1250 def __init__(self
, depot_side
, client_side
, overlay
, exclude
):
1251 # depot_side is without the trailing /... if it had one
1252 self
.depot_side
= View
.Path(depot_side
, is_depot
=True)
1253 self
.client_side
= View
.Path(client_side
, is_depot
=False)
1254 self
.overlay
= overlay
# started with "+"
1255 self
.exclude
= exclude
# started with "-"
1256 assert not (self
.overlay
and self
.exclude
)
1257 self
.depot_side
.ensure_compatible(self
.client_side
)
1265 return "View.Mapping: %s%s -> %s" % \
1266 (c
, self
.depot_side
, self
.client_side
)
1268 def map_depot_to_client(self
, depot_path
):
1269 """Calculate the client path if using this mapping on the
1270 given depot path; does not consider the effect of other
1271 mappings in a view. Even excluded mappings are returned."""
1272 matches
, wildcards
= self
.depot_side
.match_wildcards(depot_path
)
1275 client_path
= self
.client_side
.fill_in_wildcards(wildcards
)
1284 def append(self
, view_line
):
1285 """Parse a view line, splitting it into depot and client
1286 sides. Append to self.mappings, preserving order."""
1288 # Split the view line into exactly two words. P4 enforces
1289 # structure on these lines that simplifies this quite a bit.
1291 # Either or both words may be double-quoted.
1292 # Single quotes do not matter.
1293 # Double-quote marks cannot occur inside the words.
1294 # A + or - prefix is also inside the quotes.
1295 # There are no quotes unless they contain a space.
1296 # The line is already white-space stripped.
1297 # The two words are separated by a single space.
1299 if view_line
[0] == '"':
1300 # First word is double quoted. Find its end.
1301 close_quote_index
= view_line
.find('"', 1)
1302 if close_quote_index
<= 0:
1303 die("No first-word closing quote found: %s" % view_line
)
1304 depot_side
= view_line
[1:close_quote_index
]
1305 # skip closing quote and space
1306 rhs_index
= close_quote_index
+ 1 + 1
1308 space_index
= view_line
.find(" ")
1309 if space_index
<= 0:
1310 die("No word-splitting space found: %s" % view_line
)
1311 depot_side
= view_line
[0:space_index
]
1312 rhs_index
= space_index
+ 1
1314 if view_line
[rhs_index
] == '"':
1315 # Second word is double quoted. Make sure there is a
1316 # double quote at the end too.
1317 if not view_line
.endswith('"'):
1318 die("View line with rhs quote should end with one: %s" %
1321 client_side
= view_line
[rhs_index
+1:-1]
1323 client_side
= view_line
[rhs_index
:]
1325 # prefix + means overlay on previous mapping
1327 if depot_side
.startswith("+"):
1329 depot_side
= depot_side
[1:]
1331 # prefix - means exclude this path
1333 if depot_side
.startswith("-"):
1335 depot_side
= depot_side
[1:]
1337 m
= View
.Mapping(depot_side
, client_side
, overlay
, exclude
)
1338 self
.mappings
.append(m
)
1340 def map_in_client(self
, depot_path
):
1341 """Return the relative location in the client where this
1342 depot file should live. Returns "" if the file should
1343 not be mapped in the client."""
1348 # look at later entries first
1349 for m
in self
.mappings
[::-1]:
1351 # see where will this path end up in the client
1352 p
= m
.map_depot_to_client(depot_path
)
1355 # Depot path does not belong in client. Must remember
1356 # this, as previous items should not cause files to
1357 # exist in this path either. Remember that the list is
1358 # being walked from the end, which has higher precedence.
1359 # Overlap mappings do not exclude previous mappings.
1361 paths_filled
.append(m
.client_side
)
1364 # This mapping matched; no need to search any further.
1365 # But, the mapping could be rejected if the client path
1366 # has already been claimed by an earlier mapping.
1367 already_mapped_in_client
= False
1368 for f
in paths_filled
:
1369 # this is View.Path.match
1371 already_mapped_in_client
= True
1373 if not already_mapped_in_client
:
1374 # Include this file, unless it is from a line that
1375 # explicitly said to exclude it.
1379 # a match, even if rejected, always stops the search
1384 class P4Sync(Command
, P4UserMap
):
1385 delete_actions
= ( "delete", "move/delete", "purge" )
1388 Command
.__init
__(self
)
1389 P4UserMap
.__init
__(self
)
1391 optparse
.make_option("--branch", dest
="branch"),
1392 optparse
.make_option("--detect-branches", dest
="detectBranches", action
="store_true"),
1393 optparse
.make_option("--changesfile", dest
="changesFile"),
1394 optparse
.make_option("--silent", dest
="silent", action
="store_true"),
1395 optparse
.make_option("--detect-labels", dest
="detectLabels", action
="store_true"),
1396 optparse
.make_option("--verbose", dest
="verbose", action
="store_true"),
1397 optparse
.make_option("--import-local", dest
="importIntoRemotes", action
="store_false",
1398 help="Import into refs/heads/ , not refs/remotes"),
1399 optparse
.make_option("--max-changes", dest
="maxChanges"),
1400 optparse
.make_option("--keep-path", dest
="keepRepoPath", action
='store_true',
1401 help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),
1402 optparse
.make_option("--use-client-spec", dest
="useClientSpec", action
='store_true',
1403 help="Only sync files that are included in the Perforce Client Spec")
1405 self
.description
= """Imports from Perforce into a git repository.\n
1407 //depot/my/project/ -- to import the current head
1408 //depot/my/project/@all -- to import everything
1409 //depot/my/project/@1,6 -- to import only from revision 1 to 6
1411 (a ... is not needed in the path p4 specification, it's added implicitly)"""
1413 self
.usage
+= " //depot/path[@revRange]"
1415 self
.createdBranches
= set()
1416 self
.committedChanges
= set()
1418 self
.detectBranches
= False
1419 self
.detectLabels
= False
1420 self
.changesFile
= ""
1421 self
.syncWithOrigin
= True
1422 self
.verbose
= False
1423 self
.importIntoRemotes
= True
1424 self
.maxChanges
= ""
1425 self
.isWindows
= (platform
.system() == "Windows")
1426 self
.keepRepoPath
= False
1427 self
.depotPaths
= None
1428 self
.p4BranchesInGit
= []
1429 self
.cloneExclude
= []
1430 self
.useClientSpec
= False
1431 self
.clientSpecDirs
= None
1432 self
.tempBranches
= []
1433 self
.tempBranchLocation
= "git-p4-tmp"
1435 if gitConfig("git-p4.syncFromOrigin") == "false":
1436 self
.syncWithOrigin
= False
1439 # P4 wildcards are not allowed in filenames. P4 complains
1440 # if you simply add them, but you can force it with "-f", in
1441 # which case it translates them into %xx encoding internally.
1442 # Search for and fix just these four characters. Do % last so
1443 # that fixing it does not inadvertently create new %-escapes.
1445 def wildcard_decode(self
, path
):
1446 # Cannot have * in a filename in windows; untested as to
1447 # what p4 would do in such a case.
1448 if not self
.isWindows
:
1449 path
= path
.replace("%2A", "*")
1450 path
= path
.replace("%23", "#") \
1451 .replace("%40", "@") \
1452 .replace("%25", "%")
1455 # Force a checkpoint in fast-import and wait for it to finish
1456 def checkpoint(self
):
1457 self
.gitStream
.write("checkpoint\n\n")
1458 self
.gitStream
.write("progress checkpoint\n\n")
1459 out
= self
.gitOutput
.readline()
1461 print "checkpoint finished: " + out
1463 def extractFilesFromCommit(self
, commit
):
1464 self
.cloneExclude
= [re
.sub(r
"\.\.\.$", "", path
)
1465 for path
in self
.cloneExclude
]
1468 while commit
.has_key("depotFile%s" % fnum
):
1469 path
= commit
["depotFile%s" % fnum
]
1471 if [p
for p
in self
.cloneExclude
1472 if p4PathStartsWith(path
, p
)]:
1475 found
= [p
for p
in self
.depotPaths
1476 if p4PathStartsWith(path
, p
)]
1483 file["rev"] = commit
["rev%s" % fnum
]
1484 file["action"] = commit
["action%s" % fnum
]
1485 file["type"] = commit
["type%s" % fnum
]
1490 def stripRepoPath(self
, path
, prefixes
):
1491 if self
.useClientSpec
:
1492 return self
.clientSpecDirs
.map_in_client(path
)
1494 if self
.keepRepoPath
:
1495 prefixes
= [re
.sub("^(//[^/]+/).*", r
'\1', prefixes
[0])]
1498 if p4PathStartsWith(path
, p
):
1499 path
= path
[len(p
):]
1503 def splitFilesIntoBranches(self
, commit
):
1506 while commit
.has_key("depotFile%s" % fnum
):
1507 path
= commit
["depotFile%s" % fnum
]
1508 found
= [p
for p
in self
.depotPaths
1509 if p4PathStartsWith(path
, p
)]
1516 file["rev"] = commit
["rev%s" % fnum
]
1517 file["action"] = commit
["action%s" % fnum
]
1518 file["type"] = commit
["type%s" % fnum
]
1521 relPath
= self
.stripRepoPath(path
, self
.depotPaths
)
1523 for branch
in self
.knownBranches
.keys():
1525 # add a trailing slash so that a commit into qt/4.2foo doesn't end up in qt/4.2
1526 if relPath
.startswith(branch
+ "/"):
1527 if branch
not in branches
:
1528 branches
[branch
] = []
1529 branches
[branch
].append(file)
1534 # output one file from the P4 stream
1535 # - helper for streamP4Files
1537 def streamOneP4File(self
, file, contents
):
1538 relPath
= self
.stripRepoPath(file['depotFile'], self
.branchPrefixes
)
1539 relPath
= self
.wildcard_decode(relPath
)
1541 sys
.stderr
.write("%s\n" % relPath
)
1543 (type_base
, type_mods
) = split_p4_type(file["type"])
1546 if "x" in type_mods
:
1548 if type_base
== "symlink":
1550 # p4 print on a symlink contains "target\n"; remove the newline
1551 data
= ''.join(contents
)
1552 contents
= [data
[:-1]]
1554 if type_base
== "utf16":
1555 # p4 delivers different text in the python output to -G
1556 # than it does when using "print -o", or normal p4 client
1557 # operations. utf16 is converted to ascii or utf8, perhaps.
1558 # But ascii text saved as -t utf16 is completely mangled.
1559 # Invoke print -o to get the real contents.
1560 text
= p4_read_pipe(['print', '-q', '-o', '-', file['depotFile']])
1563 if type_base
== "apple":
1564 # Apple filetype files will be streamed as a concatenation of
1565 # its appledouble header and the contents. This is useless
1566 # on both macs and non-macs. If using "print -q -o xx", it
1567 # will create "xx" with the data, and "%xx" with the header.
1568 # This is also not very useful.
1570 # Ideally, someday, this script can learn how to generate
1571 # appledouble files directly and import those to git, but
1572 # non-mac machines can never find a use for apple filetype.
1573 print "\nIgnoring apple filetype file %s" % file['depotFile']
1576 # Perhaps windows wants unicode, utf16 newlines translated too;
1577 # but this is not doing it.
1578 if self
.isWindows
and type_base
== "text":
1580 for data
in contents
:
1581 data
= data
.replace("\r\n", "\n")
1582 mangled
.append(data
)
1585 # Note that we do not try to de-mangle keywords on utf16 files,
1586 # even though in theory somebody may want that.
1587 if type_base
in ("text", "unicode", "binary"):
1588 if "ko" in type_mods
:
1589 text
= ''.join(contents
)
1590 text
= re
.sub(r
'\$(Id|Header):[^$]*\$', r
'$\1$', text
)
1592 elif "k" in type_mods
:
1593 text
= ''.join(contents
)
1594 text
= re
.sub(r
'\$(Id|Header|Author|Date|DateTime|Change|File|Revision):[^$]*\$', r
'$\1$', text
)
1597 self
.gitStream
.write("M %s inline %s\n" % (git_mode
, relPath
))
1602 length
= length
+ len(d
)
1604 self
.gitStream
.write("data %d\n" % length
)
1606 self
.gitStream
.write(d
)
1607 self
.gitStream
.write("\n")
1609 def streamOneP4Deletion(self
, file):
1610 relPath
= self
.stripRepoPath(file['path'], self
.branchPrefixes
)
1612 sys
.stderr
.write("delete %s\n" % relPath
)
1613 self
.gitStream
.write("D %s\n" % relPath
)
1615 # handle another chunk of streaming data
1616 def streamP4FilesCb(self
, marshalled
):
1618 if marshalled
.has_key('depotFile') and self
.stream_have_file_info
:
1619 # start of a new file - output the old one first
1620 self
.streamOneP4File(self
.stream_file
, self
.stream_contents
)
1621 self
.stream_file
= {}
1622 self
.stream_contents
= []
1623 self
.stream_have_file_info
= False
1625 # pick up the new file information... for the
1626 # 'data' field we need to append to our array
1627 for k
in marshalled
.keys():
1629 self
.stream_contents
.append(marshalled
['data'])
1631 self
.stream_file
[k
] = marshalled
[k
]
1633 self
.stream_have_file_info
= True
1635 # Stream directly from "p4 files" into "git fast-import"
1636 def streamP4Files(self
, files
):
1642 # if using a client spec, only add the files that have
1643 # a path in the client
1644 if self
.clientSpecDirs
:
1645 if self
.clientSpecDirs
.map_in_client(f
['path']) == "":
1648 filesForCommit
.append(f
)
1649 if f
['action'] in self
.delete_actions
:
1650 filesToDelete
.append(f
)
1652 filesToRead
.append(f
)
1655 for f
in filesToDelete
:
1656 self
.streamOneP4Deletion(f
)
1658 if len(filesToRead
) > 0:
1659 self
.stream_file
= {}
1660 self
.stream_contents
= []
1661 self
.stream_have_file_info
= False
1663 # curry self argument
1664 def streamP4FilesCbSelf(entry
):
1665 self
.streamP4FilesCb(entry
)
1667 fileArgs
= ['%s#%s' % (f
['path'], f
['rev']) for f
in filesToRead
]
1669 p4CmdList(["-x", "-", "print"],
1671 cb
=streamP4FilesCbSelf
)
1674 if self
.stream_file
.has_key('depotFile'):
1675 self
.streamOneP4File(self
.stream_file
, self
.stream_contents
)
1677 def make_email(self
, userid
):
1678 if userid
in self
.users
:
1679 return self
.users
[userid
]
1681 return "%s <a@b>" % userid
1683 def commit(self
, details
, files
, branch
, branchPrefixes
, parent
= ""):
1684 epoch
= details
["time"]
1685 author
= details
["user"]
1686 self
.branchPrefixes
= branchPrefixes
1689 print "commit into %s" % branch
1691 # start with reading files; if that fails, we should not
1695 if [p
for p
in branchPrefixes
if p4PathStartsWith(f
['path'], p
)]:
1696 new_files
.append (f
)
1698 sys
.stderr
.write("Ignoring file outside of prefix: %s\n" % f
['path'])
1700 self
.gitStream
.write("commit %s\n" % branch
)
1701 # gitStream.write("mark :%s\n" % details["change"])
1702 self
.committedChanges
.add(int(details
["change"]))
1704 if author
not in self
.users
:
1705 self
.getUserMapFromPerforceServer()
1706 committer
= "%s %s %s" % (self
.make_email(author
), epoch
, self
.tz
)
1708 self
.gitStream
.write("committer %s\n" % committer
)
1710 self
.gitStream
.write("data <<EOT\n")
1711 self
.gitStream
.write(details
["desc"])
1712 self
.gitStream
.write("\n[git-p4: depot-paths = \"%s\": change = %s"
1713 % (','.join (branchPrefixes
), details
["change"]))
1714 if len(details
['options']) > 0:
1715 self
.gitStream
.write(": options = %s" % details
['options'])
1716 self
.gitStream
.write("]\nEOT\n\n")
1720 print "parent %s" % parent
1721 self
.gitStream
.write("from %s\n" % parent
)
1723 self
.streamP4Files(new_files
)
1724 self
.gitStream
.write("\n")
1726 change
= int(details
["change"])
1728 if self
.labels
.has_key(change
):
1729 label
= self
.labels
[change
]
1730 labelDetails
= label
[0]
1731 labelRevisions
= label
[1]
1733 print "Change %s is labelled %s" % (change
, labelDetails
)
1735 files
= p4CmdList(["files"] + ["%s...@%s" % (p
, change
)
1736 for p
in branchPrefixes
])
1738 if len(files
) == len(labelRevisions
):
1742 if info
["action"] in self
.delete_actions
:
1744 cleanedFiles
[info
["depotFile"]] = info
["rev"]
1746 if cleanedFiles
== labelRevisions
:
1747 self
.gitStream
.write("tag tag_%s\n" % labelDetails
["label"])
1748 self
.gitStream
.write("from %s\n" % branch
)
1750 owner
= labelDetails
["Owner"]
1752 # Try to use the owner of the p4 label, or failing that,
1753 # the current p4 user id.
1755 email
= self
.make_email(owner
)
1757 email
= self
.make_email(self
.p4UserId())
1758 tagger
= "%s %s %s" % (email
, epoch
, self
.tz
)
1760 self
.gitStream
.write("tagger %s\n" % tagger
)
1762 description
= labelDetails
["Description"]
1763 self
.gitStream
.write("data %d\n" % len(description
))
1764 self
.gitStream
.write(description
)
1765 self
.gitStream
.write("\n")
1769 print ("Tag %s does not match with change %s: files do not match."
1770 % (labelDetails
["label"], change
))
1774 print ("Tag %s does not match with change %s: file count is different."
1775 % (labelDetails
["label"], change
))
1777 def getLabels(self
):
1780 l
= p4CmdList(["labels"] + ["%s..." % p
for p
in self
.depotPaths
])
1781 if len(l
) > 0 and not self
.silent
:
1782 print "Finding files belonging to labels in %s" % `self
.depotPaths`
1785 label
= output
["label"]
1789 print "Querying files for label %s" % label
1790 for file in p4CmdList(["files"] +
1791 ["%s...@%s" % (p
, label
)
1792 for p
in self
.depotPaths
]):
1793 revisions
[file["depotFile"]] = file["rev"]
1794 change
= int(file["change"])
1795 if change
> newestChange
:
1796 newestChange
= change
1798 self
.labels
[newestChange
] = [output
, revisions
]
1801 print "Label changes: %s" % self
.labels
.keys()
1803 def guessProjectName(self
):
1804 for p
in self
.depotPaths
:
1807 p
= p
[p
.strip().rfind("/") + 1:]
1808 if not p
.endswith("/"):
1812 def getBranchMapping(self
):
1813 lostAndFoundBranches
= set()
1815 user
= gitConfig("git-p4.branchUser")
1817 command
= "branches -u %s" % user
1819 command
= "branches"
1821 for info
in p4CmdList(command
):
1822 details
= p4Cmd(["branch", "-o", info
["branch"]])
1824 while details
.has_key("View%s" % viewIdx
):
1825 paths
= details
["View%s" % viewIdx
].split(" ")
1826 viewIdx
= viewIdx
+ 1
1827 # require standard //depot/foo/... //depot/bar/... mapping
1828 if len(paths
) != 2 or not paths
[0].endswith("/...") or not paths
[1].endswith("/..."):
1831 destination
= paths
[1]
1833 if p4PathStartsWith(source
, self
.depotPaths
[0]) and p4PathStartsWith(destination
, self
.depotPaths
[0]):
1834 source
= source
[len(self
.depotPaths
[0]):-4]
1835 destination
= destination
[len(self
.depotPaths
[0]):-4]
1837 if destination
in self
.knownBranches
:
1839 print "p4 branch %s defines a mapping from %s to %s" % (info
["branch"], source
, destination
)
1840 print "but there exists another mapping from %s to %s already!" % (self
.knownBranches
[destination
], destination
)
1843 self
.knownBranches
[destination
] = source
1845 lostAndFoundBranches
.discard(destination
)
1847 if source
not in self
.knownBranches
:
1848 lostAndFoundBranches
.add(source
)
1850 # Perforce does not strictly require branches to be defined, so we also
1851 # check git config for a branch list.
1853 # Example of branch definition in git config file:
1855 # branchList=main:branchA
1856 # branchList=main:branchB
1857 # branchList=branchA:branchC
1858 configBranches
= gitConfigList("git-p4.branchList")
1859 for branch
in configBranches
:
1861 (source
, destination
) = branch
.split(":")
1862 self
.knownBranches
[destination
] = source
1864 lostAndFoundBranches
.discard(destination
)
1866 if source
not in self
.knownBranches
:
1867 lostAndFoundBranches
.add(source
)
1870 for branch
in lostAndFoundBranches
:
1871 self
.knownBranches
[branch
] = branch
1873 def getBranchMappingFromGitBranches(self
):
1874 branches
= p4BranchesInGit(self
.importIntoRemotes
)
1875 for branch
in branches
.keys():
1876 if branch
== "master":
1879 branch
= branch
[len(self
.projectName
):]
1880 self
.knownBranches
[branch
] = branch
1882 def listExistingP4GitBranches(self
):
1883 # branches holds mapping from name to commit
1884 branches
= p4BranchesInGit(self
.importIntoRemotes
)
1885 self
.p4BranchesInGit
= branches
.keys()
1886 for branch
in branches
.keys():
1887 self
.initialParents
[self
.refPrefix
+ branch
] = branches
[branch
]
1889 def updateOptionDict(self
, d
):
1891 if self
.keepRepoPath
:
1892 option_keys
['keepRepoPath'] = 1
1894 d
["options"] = ' '.join(sorted(option_keys
.keys()))
1896 def readOptions(self
, d
):
1897 self
.keepRepoPath
= (d
.has_key('options')
1898 and ('keepRepoPath' in d
['options']))
1900 def gitRefForBranch(self
, branch
):
1901 if branch
== "main":
1902 return self
.refPrefix
+ "master"
1904 if len(branch
) <= 0:
1907 return self
.refPrefix
+ self
.projectName
+ branch
1909 def gitCommitByP4Change(self
, ref
, change
):
1911 print "looking in ref " + ref
+ " for change %s using bisect..." % change
1914 latestCommit
= parseRevision(ref
)
1918 print "trying: earliest %s latest %s" % (earliestCommit
, latestCommit
)
1919 next
= read_pipe("git rev-list --bisect %s %s" % (latestCommit
, earliestCommit
)).strip()
1924 log
= extractLogMessageFromGitCommit(next
)
1925 settings
= extractSettingsGitLog(log
)
1926 currentChange
= int(settings
['change'])
1928 print "current change %s" % currentChange
1930 if currentChange
== change
:
1932 print "found %s" % next
1935 if currentChange
< change
:
1936 earliestCommit
= "^%s" % next
1938 latestCommit
= "%s" % next
1942 def importNewBranch(self
, branch
, maxChange
):
1943 # make fast-import flush all changes to disk and update the refs using the checkpoint
1944 # command so that we can try to find the branch parent in the git history
1945 self
.gitStream
.write("checkpoint\n\n");
1946 self
.gitStream
.flush();
1947 branchPrefix
= self
.depotPaths
[0] + branch
+ "/"
1948 range = "@1,%s" % maxChange
1949 #print "prefix" + branchPrefix
1950 changes
= p4ChangesForPaths([branchPrefix
], range)
1951 if len(changes
) <= 0:
1953 firstChange
= changes
[0]
1954 #print "first change in branch: %s" % firstChange
1955 sourceBranch
= self
.knownBranches
[branch
]
1956 sourceDepotPath
= self
.depotPaths
[0] + sourceBranch
1957 sourceRef
= self
.gitRefForBranch(sourceBranch
)
1958 #print "source " + sourceBranch
1960 branchParentChange
= int(p4Cmd(["changes", "-m", "1", "%s...@1,%s" % (sourceDepotPath
, firstChange
)])["change"])
1961 #print "branch parent: %s" % branchParentChange
1962 gitParent
= self
.gitCommitByP4Change(sourceRef
, branchParentChange
)
1963 if len(gitParent
) > 0:
1964 self
.initialParents
[self
.gitRefForBranch(branch
)] = gitParent
1965 #print "parent git commit: %s" % gitParent
1967 self
.importChanges(changes
)
1970 def searchParent(self
, parent
, branch
, target
):
1972 for blob
in read_pipe_lines(["git", "rev-list", "--reverse", "--no-merges", parent
]):
1974 if len(read_pipe(["git", "diff-tree", blob
, target
])) == 0:
1977 print "Found parent of %s in commit %s" % (branch
, blob
)
1984 def importChanges(self
, changes
):
1986 for change
in changes
:
1987 description
= p4Cmd(["describe", str(change
)])
1988 self
.updateOptionDict(description
)
1991 sys
.stdout
.write("\rImporting revision %s (%s%%)" % (change
, cnt
* 100 / len(changes
)))
1996 if self
.detectBranches
:
1997 branches
= self
.splitFilesIntoBranches(description
)
1998 for branch
in branches
.keys():
2000 branchPrefix
= self
.depotPaths
[0] + branch
+ "/"
2004 filesForCommit
= branches
[branch
]
2007 print "branch is %s" % branch
2009 self
.updatedBranches
.add(branch
)
2011 if branch
not in self
.createdBranches
:
2012 self
.createdBranches
.add(branch
)
2013 parent
= self
.knownBranches
[branch
]
2014 if parent
== branch
:
2017 fullBranch
= self
.projectName
+ branch
2018 if fullBranch
not in self
.p4BranchesInGit
:
2020 print("\n Importing new branch %s" % fullBranch
);
2021 if self
.importNewBranch(branch
, change
- 1):
2023 self
.p4BranchesInGit
.append(fullBranch
)
2025 print("\n Resuming with change %s" % change
);
2028 print "parent determined through known branches: %s" % parent
2030 branch
= self
.gitRefForBranch(branch
)
2031 parent
= self
.gitRefForBranch(parent
)
2034 print "looking for initial parent for %s; current parent is %s" % (branch
, parent
)
2036 if len(parent
) == 0 and branch
in self
.initialParents
:
2037 parent
= self
.initialParents
[branch
]
2038 del self
.initialParents
[branch
]
2042 tempBranch
= os
.path
.join(self
.tempBranchLocation
, "%d" % (change
))
2044 print "Creating temporary branch: " + tempBranch
2045 self
.commit(description
, filesForCommit
, tempBranch
, [branchPrefix
])
2046 self
.tempBranches
.append(tempBranch
)
2048 blob
= self
.searchParent(parent
, branch
, tempBranch
)
2050 self
.commit(description
, filesForCommit
, branch
, [branchPrefix
], blob
)
2053 print "Parent of %s not found. Committing into head of %s" % (branch
, parent
)
2054 self
.commit(description
, filesForCommit
, branch
, [branchPrefix
], parent
)
2056 files
= self
.extractFilesFromCommit(description
)
2057 self
.commit(description
, files
, self
.branch
, self
.depotPaths
,
2059 self
.initialParent
= ""
2061 print self
.gitError
.read()
2064 def importHeadRevision(self
, revision
):
2065 print "Doing initial import of %s from revision %s into %s" % (' '.join(self
.depotPaths
), revision
, self
.branch
)
2068 details
["user"] = "git perforce import user"
2069 details
["desc"] = ("Initial import of %s from the state at revision %s\n"
2070 % (' '.join(self
.depotPaths
), revision
))
2071 details
["change"] = revision
2075 fileArgs
= ["%s...%s" % (p
,revision
) for p
in self
.depotPaths
]
2077 for info
in p4CmdList(["files"] + fileArgs
):
2079 if 'code' in info
and info
['code'] == 'error':
2080 sys
.stderr
.write("p4 returned an error: %s\n"
2082 if info
['data'].find("must refer to client") >= 0:
2083 sys
.stderr
.write("This particular p4 error is misleading.\n")
2084 sys
.stderr
.write("Perhaps the depot path was misspelled.\n");
2085 sys
.stderr
.write("Depot path: %s\n" % " ".join(self
.depotPaths
))
2087 if 'p4ExitCode' in info
:
2088 sys
.stderr
.write("p4 exitcode: %s\n" % info
['p4ExitCode'])
2092 change
= int(info
["change"])
2093 if change
> newestRevision
:
2094 newestRevision
= change
2096 if info
["action"] in self
.delete_actions
:
2097 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
2098 #fileCnt = fileCnt + 1
2101 for prop
in ["depotFile", "rev", "action", "type" ]:
2102 details
["%s%s" % (prop
, fileCnt
)] = info
[prop
]
2104 fileCnt
= fileCnt
+ 1
2106 details
["change"] = newestRevision
2108 # Use time from top-most change so that all git-p4 clones of
2109 # the same p4 repo have the same commit SHA1s.
2110 res
= p4CmdList("describe -s %d" % newestRevision
)
2113 if r
.has_key('time'):
2114 newestTime
= int(r
['time'])
2115 if newestTime
is None:
2116 die("\"describe -s\" on newest change %d did not give a time")
2117 details
["time"] = newestTime
2119 self
.updateOptionDict(details
)
2121 self
.commit(details
, self
.extractFilesFromCommit(details
), self
.branch
, self
.depotPaths
)
2123 print "IO error with git fast-import. Is your git version recent enough?"
2124 print self
.gitError
.read()
2127 def getClientSpec(self
):
2128 specList
= p4CmdList("client -o")
2129 if len(specList
) != 1:
2130 die('Output from "client -o" is %d lines, expecting 1' %
2133 # dictionary of all client parameters
2136 # just the keys that start with "View"
2137 view_keys
= [ k
for k
in entry
.keys() if k
.startswith("View") ]
2139 # hold this new View
2142 # append the lines, in order, to the view
2143 for view_num
in range(len(view_keys
)):
2144 k
= "View%d" % view_num
2145 if k
not in view_keys
:
2146 die("Expected view key %s missing" % k
)
2147 view
.append(entry
[k
])
2149 self
.clientSpecDirs
= view
2151 for i
, m
in enumerate(self
.clientSpecDirs
.mappings
):
2152 print "clientSpecDirs %d: %s" % (i
, str(m
))
2154 def run(self
, args
):
2155 self
.depotPaths
= []
2156 self
.changeRange
= ""
2157 self
.initialParent
= ""
2158 self
.previousDepotPaths
= []
2160 # map from branch depot path to parent branch
2161 self
.knownBranches
= {}
2162 self
.initialParents
= {}
2163 self
.hasOrigin
= originP4BranchesExist()
2164 if not self
.syncWithOrigin
:
2165 self
.hasOrigin
= False
2167 if self
.importIntoRemotes
:
2168 self
.refPrefix
= "refs/remotes/p4/"
2170 self
.refPrefix
= "refs/heads/p4/"
2172 if self
.syncWithOrigin
and self
.hasOrigin
:
2174 print "Syncing with origin first by calling git fetch origin"
2175 system("git fetch origin")
2177 if len(self
.branch
) == 0:
2178 self
.branch
= self
.refPrefix
+ "master"
2179 if gitBranchExists("refs/heads/p4") and self
.importIntoRemotes
:
2180 system("git update-ref %s refs/heads/p4" % self
.branch
)
2181 system("git branch -D p4");
2182 # create it /after/ importing, when master exists
2183 if not gitBranchExists(self
.refPrefix
+ "HEAD") and self
.importIntoRemotes
and gitBranchExists(self
.branch
):
2184 system("git symbolic-ref %sHEAD %s" % (self
.refPrefix
, self
.branch
))
2186 if not self
.useClientSpec
:
2187 if gitConfig("git-p4.useclientspec", "--bool") == "true":
2188 self
.useClientSpec
= True
2189 if self
.useClientSpec
:
2190 self
.getClientSpec()
2192 # TODO: should always look at previous commits,
2193 # merge with previous imports, if possible.
2196 createOrUpdateBranchesFromOrigin(self
.refPrefix
, self
.silent
)
2197 self
.listExistingP4GitBranches()
2199 if len(self
.p4BranchesInGit
) > 1:
2201 print "Importing from/into multiple branches"
2202 self
.detectBranches
= True
2205 print "branches: %s" % self
.p4BranchesInGit
2208 for branch
in self
.p4BranchesInGit
:
2209 logMsg
= extractLogMessageFromGitCommit(self
.refPrefix
+ branch
)
2211 settings
= extractSettingsGitLog(logMsg
)
2213 self
.readOptions(settings
)
2214 if (settings
.has_key('depot-paths')
2215 and settings
.has_key ('change')):
2216 change
= int(settings
['change']) + 1
2217 p4Change
= max(p4Change
, change
)
2219 depotPaths
= sorted(settings
['depot-paths'])
2220 if self
.previousDepotPaths
== []:
2221 self
.previousDepotPaths
= depotPaths
2224 for (prev
, cur
) in zip(self
.previousDepotPaths
, depotPaths
):
2225 prev_list
= prev
.split("/")
2226 cur_list
= cur
.split("/")
2227 for i
in range(0, min(len(cur_list
), len(prev_list
))):
2228 if cur_list
[i
] <> prev_list
[i
]:
2232 paths
.append ("/".join(cur_list
[:i
+ 1]))
2234 self
.previousDepotPaths
= paths
2237 self
.depotPaths
= sorted(self
.previousDepotPaths
)
2238 self
.changeRange
= "@%s,#head" % p4Change
2239 if not self
.detectBranches
:
2240 self
.initialParent
= parseRevision(self
.branch
)
2241 if not self
.silent
and not self
.detectBranches
:
2242 print "Performing incremental import into %s git branch" % self
.branch
2244 if not self
.branch
.startswith("refs/"):
2245 self
.branch
= "refs/heads/" + self
.branch
2247 if len(args
) == 0 and self
.depotPaths
:
2249 print "Depot paths: %s" % ' '.join(self
.depotPaths
)
2251 if self
.depotPaths
and self
.depotPaths
!= args
:
2252 print ("previous import used depot path %s and now %s was specified. "
2253 "This doesn't work!" % (' '.join (self
.depotPaths
),
2257 self
.depotPaths
= sorted(args
)
2262 # Make sure no revision specifiers are used when --changesfile
2264 bad_changesfile
= False
2265 if len(self
.changesFile
) > 0:
2266 for p
in self
.depotPaths
:
2267 if p
.find("@") >= 0 or p
.find("#") >= 0:
2268 bad_changesfile
= True
2271 die("Option --changesfile is incompatible with revision specifiers")
2274 for p
in self
.depotPaths
:
2275 if p
.find("@") != -1:
2276 atIdx
= p
.index("@")
2277 self
.changeRange
= p
[atIdx
:]
2278 if self
.changeRange
== "@all":
2279 self
.changeRange
= ""
2280 elif ',' not in self
.changeRange
:
2281 revision
= self
.changeRange
2282 self
.changeRange
= ""
2284 elif p
.find("#") != -1:
2285 hashIdx
= p
.index("#")
2286 revision
= p
[hashIdx
:]
2288 elif self
.previousDepotPaths
== []:
2289 # pay attention to changesfile, if given, else import
2290 # the entire p4 tree at the head revision
2291 if len(self
.changesFile
) == 0:
2294 p
= re
.sub ("\.\.\.$", "", p
)
2295 if not p
.endswith("/"):
2300 self
.depotPaths
= newPaths
2303 self
.loadUserMapFromCache()
2305 if self
.detectLabels
:
2308 if self
.detectBranches
:
2309 ## FIXME - what's a P4 projectName ?
2310 self
.projectName
= self
.guessProjectName()
2313 self
.getBranchMappingFromGitBranches()
2315 self
.getBranchMapping()
2317 print "p4-git branches: %s" % self
.p4BranchesInGit
2318 print "initial parents: %s" % self
.initialParents
2319 for b
in self
.p4BranchesInGit
:
2323 b
= b
[len(self
.projectName
):]
2324 self
.createdBranches
.add(b
)
2326 self
.tz
= "%+03d%02d" % (- time
.timezone
/ 3600, ((- time
.timezone
% 3600) / 60))
2328 importProcess
= subprocess
.Popen(["git", "fast-import"],
2329 stdin
=subprocess
.PIPE
, stdout
=subprocess
.PIPE
,
2330 stderr
=subprocess
.PIPE
);
2331 self
.gitOutput
= importProcess
.stdout
2332 self
.gitStream
= importProcess
.stdin
2333 self
.gitError
= importProcess
.stderr
2336 self
.importHeadRevision(revision
)
2340 if len(self
.changesFile
) > 0:
2341 output
= open(self
.changesFile
).readlines()
2344 changeSet
.add(int(line
))
2346 for change
in changeSet
:
2347 changes
.append(change
)
2351 # catch "git-p4 sync" with no new branches, in a repo that
2352 # does not have any existing git-p4 branches
2353 if len(args
) == 0 and not self
.p4BranchesInGit
:
2354 die("No remote p4 branches. Perhaps you never did \"git p4 clone\" in here.");
2356 print "Getting p4 changes for %s...%s" % (', '.join(self
.depotPaths
),
2358 changes
= p4ChangesForPaths(self
.depotPaths
, self
.changeRange
)
2360 if len(self
.maxChanges
) > 0:
2361 changes
= changes
[:min(int(self
.maxChanges
), len(changes
))]
2363 if len(changes
) == 0:
2365 print "No changes to import!"
2368 if not self
.silent
and not self
.detectBranches
:
2369 print "Import destination: %s" % self
.branch
2371 self
.updatedBranches
= set()
2373 self
.importChanges(changes
)
2377 if len(self
.updatedBranches
) > 0:
2378 sys
.stdout
.write("Updated branches: ")
2379 for b
in self
.updatedBranches
:
2380 sys
.stdout
.write("%s " % b
)
2381 sys
.stdout
.write("\n")
2383 self
.gitStream
.close()
2384 if importProcess
.wait() != 0:
2385 die("fast-import failed: %s" % self
.gitError
.read())
2386 self
.gitOutput
.close()
2387 self
.gitError
.close()
2389 # Cleanup temporary branches created during import
2390 if self
.tempBranches
!= []:
2391 for branch
in self
.tempBranches
:
2392 read_pipe("git update-ref -d %s" % branch
)
2393 os
.rmdir(os
.path
.join(os
.environ
.get("GIT_DIR", ".git"), self
.tempBranchLocation
))
2397 class P4Rebase(Command
):
2399 Command
.__init
__(self
)
2401 self
.description
= ("Fetches the latest revision from perforce and "
2402 + "rebases the current work (branch) against it")
2403 self
.verbose
= False
2405 def run(self
, args
):
2409 return self
.rebase()
2412 if os
.system("git update-index --refresh") != 0:
2413 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.");
2414 if len(read_pipe("git diff-index HEAD --")) > 0:
2415 die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
2417 [upstream
, settings
] = findUpstreamBranchPoint()
2418 if len(upstream
) == 0:
2419 die("Cannot find upstream branchpoint for rebase")
2421 # the branchpoint may be p4/foo~3, so strip off the parent
2422 upstream
= re
.sub("~[0-9]+$", "", upstream
)
2424 print "Rebasing the current branch onto %s" % upstream
2425 oldHead
= read_pipe("git rev-parse HEAD").strip()
2426 system("git rebase %s" % upstream
)
2427 system("git diff-tree --stat --summary -M %s HEAD" % oldHead
)
2430 class P4Clone(P4Sync
):
2432 P4Sync
.__init
__(self
)
2433 self
.description
= "Creates a new git repository and imports from Perforce into it"
2434 self
.usage
= "usage: %prog [options] //depot/path[@revRange]"
2436 optparse
.make_option("--destination", dest
="cloneDestination",
2437 action
='store', default
=None,
2438 help="where to leave result of the clone"),
2439 optparse
.make_option("-/", dest
="cloneExclude",
2440 action
="append", type="string",
2441 help="exclude depot path"),
2442 optparse
.make_option("--bare", dest
="cloneBare",
2443 action
="store_true", default
=False),
2445 self
.cloneDestination
= None
2446 self
.needsGit
= False
2447 self
.cloneBare
= False
2449 # This is required for the "append" cloneExclude action
2450 def ensure_value(self
, attr
, value
):
2451 if not hasattr(self
, attr
) or getattr(self
, attr
) is None:
2452 setattr(self
, attr
, value
)
2453 return getattr(self
, attr
)
2455 def defaultDestination(self
, args
):
2456 ## TODO: use common prefix of args?
2458 depotDir
= re
.sub("(@[^@]*)$", "", depotPath
)
2459 depotDir
= re
.sub("(#[^#]*)$", "", depotDir
)
2460 depotDir
= re
.sub(r
"\.\.\.$", "", depotDir
)
2461 depotDir
= re
.sub(r
"/$", "", depotDir
)
2462 return os
.path
.split(depotDir
)[1]
2464 def run(self
, args
):
2468 if self
.keepRepoPath
and not self
.cloneDestination
:
2469 sys
.stderr
.write("Must specify destination for --keep-path\n")
2474 if not self
.cloneDestination
and len(depotPaths
) > 1:
2475 self
.cloneDestination
= depotPaths
[-1]
2476 depotPaths
= depotPaths
[:-1]
2478 self
.cloneExclude
= ["/"+p
for p
in self
.cloneExclude
]
2479 for p
in depotPaths
:
2480 if not p
.startswith("//"):
2483 if not self
.cloneDestination
:
2484 self
.cloneDestination
= self
.defaultDestination(args
)
2486 print "Importing from %s into %s" % (', '.join(depotPaths
), self
.cloneDestination
)
2488 if not os
.path
.exists(self
.cloneDestination
):
2489 os
.makedirs(self
.cloneDestination
)
2490 chdir(self
.cloneDestination
)
2492 init_cmd
= [ "git", "init" ]
2494 init_cmd
.append("--bare")
2495 subprocess
.check_call(init_cmd
)
2497 if not P4Sync
.run(self
, depotPaths
):
2499 if self
.branch
!= "master":
2500 if self
.importIntoRemotes
:
2501 masterbranch
= "refs/remotes/p4/master"
2503 masterbranch
= "refs/heads/p4/master"
2504 if gitBranchExists(masterbranch
):
2505 system("git branch master %s" % masterbranch
)
2506 if not self
.cloneBare
:
2507 system("git checkout -f")
2509 print "Could not detect main branch. No checkout/master branch created."
2513 class P4Branches(Command
):
2515 Command
.__init
__(self
)
2517 self
.description
= ("Shows the git branches that hold imports and their "
2518 + "corresponding perforce depot paths")
2519 self
.verbose
= False
2521 def run(self
, args
):
2522 if originP4BranchesExist():
2523 createOrUpdateBranchesFromOrigin()
2525 cmdline
= "git rev-parse --symbolic "
2526 cmdline
+= " --remotes"
2528 for line
in read_pipe_lines(cmdline
):
2531 if not line
.startswith('p4/') or line
== "p4/HEAD":
2535 log
= extractLogMessageFromGitCommit("refs/remotes/%s" % branch
)
2536 settings
= extractSettingsGitLog(log
)
2538 print "%s <= %s (%s)" % (branch
, ",".join(settings
["depot-paths"]), settings
["change"])
2541 class HelpFormatter(optparse
.IndentedHelpFormatter
):
2543 optparse
.IndentedHelpFormatter
.__init
__(self
)
2545 def format_description(self
, description
):
2547 return description
+ "\n"
2551 def printUsage(commands
):
2552 print "usage: %s <command> [options]" % sys
.argv
[0]
2554 print "valid commands: %s" % ", ".join(commands
)
2556 print "Try %s <command> --help for command specific help." % sys
.argv
[0]
2561 "submit" : P4Submit
,
2562 "commit" : P4Submit
,
2564 "rebase" : P4Rebase
,
2566 "rollback" : P4RollBack
,
2567 "branches" : P4Branches
2572 if len(sys
.argv
[1:]) == 0:
2573 printUsage(commands
.keys())
2577 cmdName
= sys
.argv
[1]
2579 klass
= commands
[cmdName
]
2582 print "unknown command %s" % cmdName
2584 printUsage(commands
.keys())
2587 options
= cmd
.options
2588 cmd
.gitdir
= os
.environ
.get("GIT_DIR", None)
2592 if len(options
) > 0:
2594 options
.append(optparse
.make_option("--git-dir", dest
="gitdir"))
2596 parser
= optparse
.OptionParser(cmd
.usage
.replace("%prog", "%prog " + cmdName
),
2598 description
= cmd
.description
,
2599 formatter
= HelpFormatter())
2601 (cmd
, args
) = parser
.parse_args(sys
.argv
[2:], cmd
);
2603 verbose
= cmd
.verbose
2605 if cmd
.gitdir
== None:
2606 cmd
.gitdir
= os
.path
.abspath(".git")
2607 if not isValidGitDir(cmd
.gitdir
):
2608 cmd
.gitdir
= read_pipe("git rev-parse --git-dir").strip()
2609 if os
.path
.exists(cmd
.gitdir
):
2610 cdup
= read_pipe("git rev-parse --show-cdup").strip()
2614 if not isValidGitDir(cmd
.gitdir
):
2615 if isValidGitDir(cmd
.gitdir
+ "/.git"):
2616 cmd
.gitdir
+= "/.git"
2618 die("fatal: cannot locate git repository at %s" % cmd
.gitdir
)
2620 os
.environ
["GIT_DIR"] = cmd
.gitdir
2622 if not cmd
.run(args
):
2627 if __name__
== '__main__':