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 if sys
.hexversion
< 0x02040000:
12 # The limiter is the subprocess module
13 sys
.stderr
.write("git-p4: requires Python 2.4 or later.\n")
28 # Only labels/tags matching this will be imported/exported
29 defaultLabelRegexp
= r
'[a-zA-Z0-9_\-.]+$'
31 def p4_build_cmd(cmd
):
32 """Build a suitable p4 command line.
34 This consolidates building and returning a p4 command line into one
35 location. It means that hooking into the environment, or other configuration
36 can be done more easily.
40 user
= gitConfig("git-p4.user")
42 real_cmd
+= ["-u",user
]
44 password
= gitConfig("git-p4.password")
46 real_cmd
+= ["-P", password
]
48 port
= gitConfig("git-p4.port")
50 real_cmd
+= ["-p", port
]
52 host
= gitConfig("git-p4.host")
54 real_cmd
+= ["-H", host
]
56 client
= gitConfig("git-p4.client")
58 real_cmd
+= ["-c", client
]
61 if isinstance(cmd
,basestring
):
62 real_cmd
= ' '.join(real_cmd
) + ' ' + cmd
68 # P4 uses the PWD environment variable rather than getcwd(). Since we're
69 # not using the shell, we have to set it ourselves. This path could
70 # be relative, so go there first, then figure out where we ended up.
72 os
.environ
['PWD'] = os
.getcwd()
78 sys
.stderr
.write(msg
+ "\n")
81 def write_pipe(c
, stdin
):
83 sys
.stderr
.write('Writing pipe: %s\n' % str(c
))
85 expand
= isinstance(c
,basestring
)
86 p
= subprocess
.Popen(c
, stdin
=subprocess
.PIPE
, shell
=expand
)
88 val
= pipe
.write(stdin
)
91 die('Command failed: %s' % str(c
))
95 def p4_write_pipe(c
, stdin
):
96 real_cmd
= p4_build_cmd(c
)
97 return write_pipe(real_cmd
, stdin
)
99 def read_pipe(c
, ignore_error
=False):
101 sys
.stderr
.write('Reading pipe: %s\n' % str(c
))
103 expand
= isinstance(c
,basestring
)
104 p
= subprocess
.Popen(c
, stdout
=subprocess
.PIPE
, shell
=expand
)
107 if p
.wait() and not ignore_error
:
108 die('Command failed: %s' % str(c
))
112 def p4_read_pipe(c
, ignore_error
=False):
113 real_cmd
= p4_build_cmd(c
)
114 return read_pipe(real_cmd
, ignore_error
)
116 def read_pipe_lines(c
):
118 sys
.stderr
.write('Reading pipe: %s\n' % str(c
))
120 expand
= isinstance(c
, basestring
)
121 p
= subprocess
.Popen(c
, stdout
=subprocess
.PIPE
, shell
=expand
)
123 val
= pipe
.readlines()
124 if pipe
.close() or p
.wait():
125 die('Command failed: %s' % str(c
))
129 def p4_read_pipe_lines(c
):
130 """Specifically invoke p4 on the command supplied. """
131 real_cmd
= p4_build_cmd(c
)
132 return read_pipe_lines(real_cmd
)
134 def p4_has_command(cmd
):
135 """Ask p4 for help on this command. If it returns an error, the
136 command does not exist in this version of p4."""
137 real_cmd
= p4_build_cmd(["help", cmd
])
138 p
= subprocess
.Popen(real_cmd
, stdout
=subprocess
.PIPE
,
139 stderr
=subprocess
.PIPE
)
141 return p
.returncode
== 0
143 def p4_has_move_command():
144 """See if the move command exists, that it supports -k, and that
145 it has not been administratively disabled. The arguments
146 must be correct, but the filenames do not have to exist. Use
147 ones with wildcards so even if they exist, it will fail."""
149 if not p4_has_command("move"):
151 cmd
= p4_build_cmd(["move", "-k", "@from", "@to"])
152 p
= subprocess
.Popen(cmd
, stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
)
153 (out
, err
) = p
.communicate()
154 # return code will be 1 in either case
155 if err
.find("Invalid option") >= 0:
157 if err
.find("disabled") >= 0:
159 # assume it failed because @... was invalid changelist
163 expand
= isinstance(cmd
,basestring
)
165 sys
.stderr
.write("executing %s\n" % str(cmd
))
166 subprocess
.check_call(cmd
, shell
=expand
)
169 """Specifically invoke p4 as the system command. """
170 real_cmd
= p4_build_cmd(cmd
)
171 expand
= isinstance(real_cmd
, basestring
)
172 subprocess
.check_call(real_cmd
, shell
=expand
)
174 _p4_version_string
= None
175 def p4_version_string():
176 """Read the version string, showing just the last line, which
177 hopefully is the interesting version bit.
180 Perforce - The Fast Software Configuration Management System.
181 Copyright 1995-2011 Perforce Software. All rights reserved.
182 Rev. P4/NTX86/2011.1/393975 (2011/12/16).
184 global _p4_version_string
185 if not _p4_version_string
:
186 a
= p4_read_pipe_lines(["-V"])
187 _p4_version_string
= a
[-1].rstrip()
188 return _p4_version_string
190 def p4_integrate(src
, dest
):
191 p4_system(["integrate", "-Dt", wildcard_encode(src
), wildcard_encode(dest
)])
193 def p4_sync(f
, *options
):
194 p4_system(["sync"] + list(options
) + [wildcard_encode(f
)])
197 # forcibly add file names with wildcards
198 if wildcard_present(f
):
199 p4_system(["add", "-f", f
])
201 p4_system(["add", f
])
204 p4_system(["delete", wildcard_encode(f
)])
207 p4_system(["edit", wildcard_encode(f
)])
210 p4_system(["revert", wildcard_encode(f
)])
212 def p4_reopen(type, f
):
213 p4_system(["reopen", "-t", type, wildcard_encode(f
)])
215 def p4_move(src
, dest
):
216 p4_system(["move", "-k", wildcard_encode(src
), wildcard_encode(dest
)])
218 def p4_describe(change
):
219 """Make sure it returns a valid result by checking for
220 the presence of field "time". Return a dict of the
223 ds
= p4CmdList(["describe", "-s", str(change
)])
225 die("p4 describe -s %d did not return 1 result: %s" % (change
, str(ds
)))
229 if "p4ExitCode" in d
:
230 die("p4 describe -s %d exited with %d: %s" % (change
, d
["p4ExitCode"],
233 if d
["code"] == "error":
234 die("p4 describe -s %d returned error code: %s" % (change
, str(d
)))
237 die("p4 describe -s %d returned no \"time\": %s" % (change
, str(d
)))
242 # Canonicalize the p4 type and return a tuple of the
243 # base type, plus any modifiers. See "p4 help filetypes"
244 # for a list and explanation.
246 def split_p4_type(p4type
):
248 p4_filetypes_historical
= {
249 "ctempobj": "binary+Sw",
255 "tempobj": "binary+FSw",
256 "ubinary": "binary+F",
257 "uresource": "resource+F",
258 "uxbinary": "binary+Fx",
259 "xbinary": "binary+x",
261 "xtempobj": "binary+Swx",
263 "xunicode": "unicode+x",
266 if p4type
in p4_filetypes_historical
:
267 p4type
= p4_filetypes_historical
[p4type
]
269 s
= p4type
.split("+")
277 # return the raw p4 type of a file (text, text+ko, etc)
280 results
= p4CmdList(["fstat", "-T", "headType", file])
281 return results
[0]['headType']
284 # Given a type base and modifier, return a regexp matching
285 # the keywords that can be expanded in the file
287 def p4_keywords_regexp_for_type(base
, type_mods
):
288 if base
in ("text", "unicode", "binary"):
290 if "ko" in type_mods
:
292 elif "k" in type_mods
:
293 kwords
= 'Id|Header|Author|Date|DateTime|Change|File|Revision'
297 \$ # Starts with a dollar, followed by...
298 (%s) # one of the keywords, followed by...
299 (:[^$\n]+)? # possibly an old expansion, followed by...
307 # Given a file, return a regexp matching the possible
308 # RCS keywords that will be expanded, or None for files
309 # with kw expansion turned off.
311 def p4_keywords_regexp_for_file(file):
312 if not os
.path
.exists(file):
315 (type_base
, type_mods
) = split_p4_type(p4_type(file))
316 return p4_keywords_regexp_for_type(type_base
, type_mods
)
318 def setP4ExecBit(file, mode
):
319 # Reopens an already open file and changes the execute bit to match
320 # the execute bit setting in the passed in mode.
324 if not isModeExec(mode
):
325 p4Type
= getP4OpenedType(file)
326 p4Type
= re
.sub('^([cku]?)x(.*)', '\\1\\2', p4Type
)
327 p4Type
= re
.sub('(.*?\+.*?)x(.*?)', '\\1\\2', p4Type
)
328 if p4Type
[-1] == "+":
329 p4Type
= p4Type
[0:-1]
331 p4_reopen(p4Type
, file)
333 def getP4OpenedType(file):
334 # Returns the perforce file type for the given file.
336 result
= p4_read_pipe(["opened", wildcard_encode(file)])
337 match
= re
.match(".*\((.+)\)\r?$", result
)
339 return match
.group(1)
341 die("Could not determine file type for %s (result: '%s')" % (file, result
))
343 # Return the set of all p4 labels
344 def getP4Labels(depotPaths
):
346 if isinstance(depotPaths
,basestring
):
347 depotPaths
= [depotPaths
]
349 for l
in p4CmdList(["labels"] + ["%s..." % p
for p
in depotPaths
]):
355 # Return the set of all git tags
358 for line
in read_pipe_lines(["git", "tag"]):
363 def diffTreePattern():
364 # This is a simple generator for the diff tree regex pattern. This could be
365 # a class variable if this and parseDiffTreeEntry were a part of a class.
366 pattern
= re
.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)')
370 def parseDiffTreeEntry(entry
):
371 """Parses a single diff tree entry into its component elements.
373 See git-diff-tree(1) manpage for details about the format of the diff
374 output. This method returns a dictionary with the following elements:
376 src_mode - The mode of the source file
377 dst_mode - The mode of the destination file
378 src_sha1 - The sha1 for the source file
379 dst_sha1 - The sha1 fr the destination file
380 status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc)
381 status_score - The score for the status (applicable for 'C' and 'R'
382 statuses). This is None if there is no score.
383 src - The path for the source file.
384 dst - The path for the destination file. This is only present for
385 copy or renames. If it is not present, this is None.
387 If the pattern is not matched, None is returned."""
389 match
= diffTreePattern().next().match(entry
)
392 'src_mode': match
.group(1),
393 'dst_mode': match
.group(2),
394 'src_sha1': match
.group(3),
395 'dst_sha1': match
.group(4),
396 'status': match
.group(5),
397 'status_score': match
.group(6),
398 'src': match
.group(7),
399 'dst': match
.group(10)
403 def isModeExec(mode
):
404 # Returns True if the given git mode represents an executable file,
406 return mode
[-3:] == "755"
408 def isModeExecChanged(src_mode
, dst_mode
):
409 return isModeExec(src_mode
) != isModeExec(dst_mode
)
411 def p4CmdList(cmd
, stdin
=None, stdin_mode
='w+b', cb
=None):
413 if isinstance(cmd
,basestring
):
420 cmd
= p4_build_cmd(cmd
)
422 sys
.stderr
.write("Opening pipe: %s\n" % str(cmd
))
424 # Use a temporary file to avoid deadlocks without
425 # subprocess.communicate(), which would put another copy
426 # of stdout into memory.
428 if stdin
is not None:
429 stdin_file
= tempfile
.TemporaryFile(prefix
='p4-stdin', mode
=stdin_mode
)
430 if isinstance(stdin
,basestring
):
431 stdin_file
.write(stdin
)
434 stdin_file
.write(i
+ '\n')
438 p4
= subprocess
.Popen(cmd
,
441 stdout
=subprocess
.PIPE
)
446 entry
= marshal
.load(p4
.stdout
)
456 entry
["p4ExitCode"] = exitCode
462 list = p4CmdList(cmd
)
468 def p4Where(depotPath
):
469 if not depotPath
.endswith("/"):
471 depotPath
= depotPath
+ "..."
472 outputList
= p4CmdList(["where", depotPath
])
474 for entry
in outputList
:
475 if "depotFile" in entry
:
476 if entry
["depotFile"] == depotPath
:
479 elif "data" in entry
:
480 data
= entry
.get("data")
481 space
= data
.find(" ")
482 if data
[:space
] == depotPath
:
487 if output
["code"] == "error":
491 clientPath
= output
.get("path")
492 elif "data" in output
:
493 data
= output
.get("data")
494 lastSpace
= data
.rfind(" ")
495 clientPath
= data
[lastSpace
+ 1:]
497 if clientPath
.endswith("..."):
498 clientPath
= clientPath
[:-3]
501 def currentGitBranch():
502 return read_pipe("git name-rev HEAD").split(" ")[1].strip()
504 def isValidGitDir(path
):
505 if (os
.path
.exists(path
+ "/HEAD")
506 and os
.path
.exists(path
+ "/refs") and os
.path
.exists(path
+ "/objects")):
510 def parseRevision(ref
):
511 return read_pipe("git rev-parse %s" % ref
).strip()
513 def branchExists(ref
):
514 rev
= read_pipe(["git", "rev-parse", "-q", "--verify", ref
],
518 def extractLogMessageFromGitCommit(commit
):
521 ## fixme: title is first line of commit, not 1st paragraph.
523 for log
in read_pipe_lines("git cat-file commit %s" % commit
):
532 def extractSettingsGitLog(log
):
534 for line
in log
.split("\n"):
536 m
= re
.search (r
"^ *\[git-p4: (.*)\]$", line
)
540 assignments
= m
.group(1).split (':')
541 for a
in assignments
:
543 key
= vals
[0].strip()
544 val
= ('='.join (vals
[1:])).strip()
545 if val
.endswith ('\"') and val
.startswith('"'):
550 paths
= values
.get("depot-paths")
552 paths
= values
.get("depot-path")
554 values
['depot-paths'] = paths
.split(',')
557 def gitBranchExists(branch
):
558 proc
= subprocess
.Popen(["git", "rev-parse", branch
],
559 stderr
=subprocess
.PIPE
, stdout
=subprocess
.PIPE
);
560 return proc
.wait() == 0;
565 if not _gitConfig
.has_key(key
):
566 cmd
= [ "git", "config", key
]
567 s
= read_pipe(cmd
, ignore_error
=True)
568 _gitConfig
[key
] = s
.strip()
569 return _gitConfig
[key
]
571 def gitConfigBool(key
):
572 """Return a bool, using git config --bool. It is True only if the
573 variable is set to true, and False if set to false or not present
576 if not _gitConfig
.has_key(key
):
577 cmd
= [ "git", "config", "--bool", key
]
578 s
= read_pipe(cmd
, ignore_error
=True)
580 _gitConfig
[key
] = v
== "true"
581 return _gitConfig
[key
]
583 def gitConfigList(key
):
584 if not _gitConfig
.has_key(key
):
585 s
= read_pipe(["git", "config", "--get-all", key
], ignore_error
=True)
586 _gitConfig
[key
] = s
.strip().split(os
.linesep
)
587 return _gitConfig
[key
]
589 def p4BranchesInGit(branchesAreInRemotes
=True):
590 """Find all the branches whose names start with "p4/", looking
591 in remotes or heads as specified by the argument. Return
592 a dictionary of { branch: revision } for each one found.
593 The branch names are the short names, without any
598 cmdline
= "git rev-parse --symbolic "
599 if branchesAreInRemotes
:
600 cmdline
+= "--remotes"
602 cmdline
+= "--branches"
604 for line
in read_pipe_lines(cmdline
):
608 if not line
.startswith('p4/'):
610 # special symbolic ref to p4/master
611 if line
== "p4/HEAD":
614 # strip off p4/ prefix
615 branch
= line
[len("p4/"):]
617 branches
[branch
] = parseRevision(line
)
621 def branch_exists(branch
):
622 """Make sure that the given ref name really exists."""
624 cmd
= [ "git", "rev-parse", "--symbolic", "--verify", branch
]
625 p
= subprocess
.Popen(cmd
, stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
)
626 out
, _
= p
.communicate()
629 # expect exactly one line of output: the branch name
630 return out
.rstrip() == branch
632 def findUpstreamBranchPoint(head
= "HEAD"):
633 branches
= p4BranchesInGit()
634 # map from depot-path to branch name
635 branchByDepotPath
= {}
636 for branch
in branches
.keys():
637 tip
= branches
[branch
]
638 log
= extractLogMessageFromGitCommit(tip
)
639 settings
= extractSettingsGitLog(log
)
640 if settings
.has_key("depot-paths"):
641 paths
= ",".join(settings
["depot-paths"])
642 branchByDepotPath
[paths
] = "remotes/p4/" + branch
646 while parent
< 65535:
647 commit
= head
+ "~%s" % parent
648 log
= extractLogMessageFromGitCommit(commit
)
649 settings
= extractSettingsGitLog(log
)
650 if settings
.has_key("depot-paths"):
651 paths
= ",".join(settings
["depot-paths"])
652 if branchByDepotPath
.has_key(paths
):
653 return [branchByDepotPath
[paths
], settings
]
657 return ["", settings
]
659 def createOrUpdateBranchesFromOrigin(localRefPrefix
= "refs/remotes/p4/", silent
=True):
661 print ("Creating/updating branch(es) in %s based on origin branch(es)"
664 originPrefix
= "origin/p4/"
666 for line
in read_pipe_lines("git rev-parse --symbolic --remotes"):
668 if (not line
.startswith(originPrefix
)) or line
.endswith("HEAD"):
671 headName
= line
[len(originPrefix
):]
672 remoteHead
= localRefPrefix
+ headName
675 original
= extractSettingsGitLog(extractLogMessageFromGitCommit(originHead
))
676 if (not original
.has_key('depot-paths')
677 or not original
.has_key('change')):
681 if not gitBranchExists(remoteHead
):
683 print "creating %s" % remoteHead
686 settings
= extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead
))
687 if settings
.has_key('change') > 0:
688 if settings
['depot-paths'] == original
['depot-paths']:
689 originP4Change
= int(original
['change'])
690 p4Change
= int(settings
['change'])
691 if originP4Change
> p4Change
:
692 print ("%s (%s) is newer than %s (%s). "
693 "Updating p4 branch from origin."
694 % (originHead
, originP4Change
,
695 remoteHead
, p4Change
))
698 print ("Ignoring: %s was imported from %s while "
699 "%s was imported from %s"
700 % (originHead
, ','.join(original
['depot-paths']),
701 remoteHead
, ','.join(settings
['depot-paths'])))
704 system("git update-ref %s %s" % (remoteHead
, originHead
))
706 def originP4BranchesExist():
707 return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
709 def p4ChangesForPaths(depotPaths
, changeRange
):
713 cmd
+= ["%s...%s" % (p
, changeRange
)]
714 output
= p4_read_pipe_lines(cmd
)
718 changeNum
= int(line
.split(" ")[1])
719 changes
[changeNum
] = True
721 changelist
= changes
.keys()
725 def p4PathStartsWith(path
, prefix
):
726 # This method tries to remedy a potential mixed-case issue:
728 # If UserA adds //depot/DirA/file1
729 # and UserB adds //depot/dira/file2
731 # we may or may not have a problem. If you have core.ignorecase=true,
732 # we treat DirA and dira as the same directory
733 if gitConfigBool("core.ignorecase"):
734 return path
.lower().startswith(prefix
.lower())
735 return path
.startswith(prefix
)
738 """Look at the p4 client spec, create a View() object that contains
739 all the mappings, and return it."""
741 specList
= p4CmdList("client -o")
742 if len(specList
) != 1:
743 die('Output from "client -o" is %d lines, expecting 1' %
746 # dictionary of all client parameters
749 # just the keys that start with "View"
750 view_keys
= [ k
for k
in entry
.keys() if k
.startswith("View") ]
755 # append the lines, in order, to the view
756 for view_num
in range(len(view_keys
)):
757 k
= "View%d" % view_num
758 if k
not in view_keys
:
759 die("Expected view key %s missing" % k
)
760 view
.append(entry
[k
])
765 """Grab the client directory."""
767 output
= p4CmdList("client -o")
769 die('Output from "client -o" is %d lines, expecting 1' % len(output
))
772 if "Root" not in entry
:
773 die('Client has no "Root"')
778 # P4 wildcards are not allowed in filenames. P4 complains
779 # if you simply add them, but you can force it with "-f", in
780 # which case it translates them into %xx encoding internally.
782 def wildcard_decode(path
):
783 # Search for and fix just these four characters. Do % last so
784 # that fixing it does not inadvertently create new %-escapes.
785 # Cannot have * in a filename in windows; untested as to
786 # what p4 would do in such a case.
787 if not platform
.system() == "Windows":
788 path
= path
.replace("%2A", "*")
789 path
= path
.replace("%23", "#") \
790 .replace("%40", "@") \
794 def wildcard_encode(path
):
795 # do % first to avoid double-encoding the %s introduced here
796 path
= path
.replace("%", "%25") \
797 .replace("*", "%2A") \
798 .replace("#", "%23") \
802 def wildcard_present(path
):
803 return path
.translate(None, "*#@%") != path
807 self
.usage
= "usage: %prog [options]"
813 self
.userMapFromPerforceServer
= False
814 self
.myP4UserId
= None
818 return self
.myP4UserId
820 results
= p4CmdList("user -o")
822 if r
.has_key('User'):
823 self
.myP4UserId
= r
['User']
825 die("Could not find your p4 user id")
827 def p4UserIsMe(self
, p4User
):
828 # return True if the given p4 user is actually me
830 if not p4User
or p4User
!= me
:
835 def getUserCacheFilename(self
):
836 home
= os
.environ
.get("HOME", os
.environ
.get("USERPROFILE"))
837 return home
+ "/.gitp4-usercache.txt"
839 def getUserMapFromPerforceServer(self
):
840 if self
.userMapFromPerforceServer
:
845 for output
in p4CmdList("users"):
846 if not output
.has_key("User"):
848 self
.users
[output
["User"]] = output
["FullName"] + " <" + output
["Email"] + ">"
849 self
.emails
[output
["Email"]] = output
["User"]
853 for (key
, val
) in self
.users
.items():
854 s
+= "%s\t%s\n" % (key
.expandtabs(1), val
.expandtabs(1))
856 open(self
.getUserCacheFilename(), "wb").write(s
)
857 self
.userMapFromPerforceServer
= True
859 def loadUserMapFromCache(self
):
861 self
.userMapFromPerforceServer
= False
863 cache
= open(self
.getUserCacheFilename(), "rb")
864 lines
= cache
.readlines()
867 entry
= line
.strip().split("\t")
868 self
.users
[entry
[0]] = entry
[1]
870 self
.getUserMapFromPerforceServer()
872 class P4Debug(Command
):
874 Command
.__init
__(self
)
876 self
.description
= "A tool to debug the output of p4 -G."
877 self
.needsGit
= False
881 for output
in p4CmdList(args
):
882 print 'Element: %d' % j
887 class P4RollBack(Command
):
889 Command
.__init
__(self
)
891 optparse
.make_option("--local", dest
="rollbackLocalBranches", action
="store_true")
893 self
.description
= "A tool to debug the multi-branch import. Don't use :)"
894 self
.rollbackLocalBranches
= False
899 maxChange
= int(args
[0])
901 if "p4ExitCode" in p4Cmd("changes -m 1"):
902 die("Problems executing p4");
904 if self
.rollbackLocalBranches
:
905 refPrefix
= "refs/heads/"
906 lines
= read_pipe_lines("git rev-parse --symbolic --branches")
908 refPrefix
= "refs/remotes/"
909 lines
= read_pipe_lines("git rev-parse --symbolic --remotes")
912 if self
.rollbackLocalBranches
or (line
.startswith("p4/") and line
!= "p4/HEAD\n"):
914 ref
= refPrefix
+ line
915 log
= extractLogMessageFromGitCommit(ref
)
916 settings
= extractSettingsGitLog(log
)
918 depotPaths
= settings
['depot-paths']
919 change
= settings
['change']
923 if len(p4Cmd("changes -m 1 " + ' '.join (['%s...@%s' % (p
, maxChange
)
924 for p
in depotPaths
]))) == 0:
925 print "Branch %s did not exist at change %s, deleting." % (ref
, maxChange
)
926 system("git update-ref -d %s `git rev-parse %s`" % (ref
, ref
))
929 while change
and int(change
) > maxChange
:
932 print "%s is at %s ; rewinding towards %s" % (ref
, change
, maxChange
)
933 system("git update-ref %s \"%s^\"" % (ref
, ref
))
934 log
= extractLogMessageFromGitCommit(ref
)
935 settings
= extractSettingsGitLog(log
)
938 depotPaths
= settings
['depot-paths']
939 change
= settings
['change']
942 print "%s rewound to %s" % (ref
, change
)
946 class P4Submit(Command
, P4UserMap
):
948 conflict_behavior_choices
= ("ask", "skip", "quit")
951 Command
.__init
__(self
)
952 P4UserMap
.__init
__(self
)
954 optparse
.make_option("--origin", dest
="origin"),
955 optparse
.make_option("-M", dest
="detectRenames", action
="store_true"),
956 # preserve the user, requires relevant p4 permissions
957 optparse
.make_option("--preserve-user", dest
="preserveUser", action
="store_true"),
958 optparse
.make_option("--export-labels", dest
="exportLabels", action
="store_true"),
959 optparse
.make_option("--dry-run", "-n", dest
="dry_run", action
="store_true"),
960 optparse
.make_option("--prepare-p4-only", dest
="prepare_p4_only", action
="store_true"),
961 optparse
.make_option("--conflict", dest
="conflict_behavior",
962 choices
=self
.conflict_behavior_choices
),
963 optparse
.make_option("--branch", dest
="branch"),
965 self
.description
= "Submit changes from git to the perforce depot."
966 self
.usage
+= " [name of git branch to submit into perforce depot]"
968 self
.detectRenames
= False
969 self
.preserveUser
= gitConfigBool("git-p4.preserveUser")
971 self
.prepare_p4_only
= False
972 self
.conflict_behavior
= None
973 self
.isWindows
= (platform
.system() == "Windows")
974 self
.exportLabels
= False
975 self
.p4HasMoveCommand
= p4_has_move_command()
979 if len(p4CmdList("opened ...")) > 0:
980 die("You have files opened with perforce! Close them before starting the sync.")
982 def separate_jobs_from_description(self
, message
):
983 """Extract and return a possible Jobs field in the commit
984 message. It goes into a separate section in the p4 change
987 A jobs line starts with "Jobs:" and looks like a new field
988 in a form. Values are white-space separated on the same
989 line or on following lines that start with a tab.
991 This does not parse and extract the full git commit message
992 like a p4 form. It just sees the Jobs: line as a marker
993 to pass everything from then on directly into the p4 form,
994 but outside the description section.
996 Return a tuple (stripped log message, jobs string)."""
998 m
= re
.search(r
'^Jobs:', message
, re
.MULTILINE
)
1000 return (message
, None)
1002 jobtext
= message
[m
.start():]
1003 stripped_message
= message
[:m
.start()].rstrip()
1004 return (stripped_message
, jobtext
)
1006 def prepareLogMessage(self
, template
, message
, jobs
):
1007 """Edits the template returned from "p4 change -o" to insert
1008 the message in the Description field, and the jobs text in
1012 inDescriptionSection
= False
1014 for line
in template
.split("\n"):
1015 if line
.startswith("#"):
1016 result
+= line
+ "\n"
1019 if inDescriptionSection
:
1020 if line
.startswith("Files:") or line
.startswith("Jobs:"):
1021 inDescriptionSection
= False
1022 # insert Jobs section
1024 result
+= jobs
+ "\n"
1028 if line
.startswith("Description:"):
1029 inDescriptionSection
= True
1031 for messageLine
in message
.split("\n"):
1032 line
+= "\t" + messageLine
+ "\n"
1034 result
+= line
+ "\n"
1038 def patchRCSKeywords(self
, file, pattern
):
1039 # Attempt to zap the RCS keywords in a p4 controlled file matching the given pattern
1040 (handle
, outFileName
) = tempfile
.mkstemp(dir='.')
1042 outFile
= os
.fdopen(handle
, "w+")
1043 inFile
= open(file, "r")
1044 regexp
= re
.compile(pattern
, re
.VERBOSE
)
1045 for line
in inFile
.readlines():
1046 line
= regexp
.sub(r
'$\1$', line
)
1050 # Forcibly overwrite the original file
1052 shutil
.move(outFileName
, file)
1054 # cleanup our temporary file
1055 os
.unlink(outFileName
)
1056 print "Failed to strip RCS keywords in %s" % file
1059 print "Patched up RCS keywords in %s" % file
1061 def p4UserForCommit(self
,id):
1062 # Return the tuple (perforce user,git email) for a given git commit id
1063 self
.getUserMapFromPerforceServer()
1064 gitEmail
= read_pipe(["git", "log", "--max-count=1",
1065 "--format=%ae", id])
1066 gitEmail
= gitEmail
.strip()
1067 if not self
.emails
.has_key(gitEmail
):
1068 return (None,gitEmail
)
1070 return (self
.emails
[gitEmail
],gitEmail
)
1072 def checkValidP4Users(self
,commits
):
1073 # check if any git authors cannot be mapped to p4 users
1075 (user
,email
) = self
.p4UserForCommit(id)
1077 msg
= "Cannot find p4 user for email %s in commit %s." % (email
, id)
1078 if gitConfigBool("git-p4.allowMissingP4Users"):
1081 die("Error: %s\nSet git-p4.allowMissingP4Users to true to allow this." % msg
)
1083 def lastP4Changelist(self
):
1084 # Get back the last changelist number submitted in this client spec. This
1085 # then gets used to patch up the username in the change. If the same
1086 # client spec is being used by multiple processes then this might go
1088 results
= p4CmdList("client -o") # find the current client
1091 if r
.has_key('Client'):
1092 client
= r
['Client']
1095 die("could not get client spec")
1096 results
= p4CmdList(["changes", "-c", client
, "-m", "1"])
1098 if r
.has_key('change'):
1100 die("Could not get changelist number for last submit - cannot patch up user details")
1102 def modifyChangelistUser(self
, changelist
, newUser
):
1103 # fixup the user field of a changelist after it has been submitted.
1104 changes
= p4CmdList("change -o %s" % changelist
)
1105 if len(changes
) != 1:
1106 die("Bad output from p4 change modifying %s to user %s" %
1107 (changelist
, newUser
))
1110 if c
['User'] == newUser
: return # nothing to do
1112 input = marshal
.dumps(c
)
1114 result
= p4CmdList("change -f -i", stdin
=input)
1116 if r
.has_key('code'):
1117 if r
['code'] == 'error':
1118 die("Could not modify user field of changelist %s to %s:%s" % (changelist
, newUser
, r
['data']))
1119 if r
.has_key('data'):
1120 print("Updated user field for changelist %s to %s" % (changelist
, newUser
))
1122 die("Could not modify user field of changelist %s to %s" % (changelist
, newUser
))
1124 def canChangeChangelists(self
):
1125 # check to see if we have p4 admin or super-user permissions, either of
1126 # which are required to modify changelists.
1127 results
= p4CmdList(["protects", self
.depotPath
])
1129 if r
.has_key('perm'):
1130 if r
['perm'] == 'admin':
1132 if r
['perm'] == 'super':
1136 def prepareSubmitTemplate(self
):
1137 """Run "p4 change -o" to grab a change specification template.
1138 This does not use "p4 -G", as it is nice to keep the submission
1139 template in original order, since a human might edit it.
1141 Remove lines in the Files section that show changes to files
1142 outside the depot path we're committing into."""
1145 inFilesSection
= False
1146 for line
in p4_read_pipe_lines(['change', '-o']):
1147 if line
.endswith("\r\n"):
1148 line
= line
[:-2] + "\n"
1150 if line
.startswith("\t"):
1151 # path starts and ends with a tab
1153 lastTab
= path
.rfind("\t")
1155 path
= path
[:lastTab
]
1156 if not p4PathStartsWith(path
, self
.depotPath
):
1159 inFilesSection
= False
1161 if line
.startswith("Files:"):
1162 inFilesSection
= True
1168 def edit_template(self
, template_file
):
1169 """Invoke the editor to let the user change the submission
1170 message. Return true if okay to continue with the submit."""
1172 # if configured to skip the editing part, just submit
1173 if gitConfigBool("git-p4.skipSubmitEdit"):
1176 # look at the modification time, to check later if the user saved
1178 mtime
= os
.stat(template_file
).st_mtime
1181 if os
.environ
.has_key("P4EDITOR") and (os
.environ
.get("P4EDITOR") != ""):
1182 editor
= os
.environ
.get("P4EDITOR")
1184 editor
= read_pipe("git var GIT_EDITOR").strip()
1185 system(editor
+ " " + template_file
)
1187 # If the file was not saved, prompt to see if this patch should
1188 # be skipped. But skip this verification step if configured so.
1189 if gitConfigBool("git-p4.skipSubmitEditCheck"):
1192 # modification time updated means user saved the file
1193 if os
.stat(template_file
).st_mtime
> mtime
:
1197 response
= raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")
1203 def applyCommit(self
, id):
1204 """Apply one commit, return True if it succeeded."""
1206 print "Applying", read_pipe(["git", "show", "-s",
1207 "--format=format:%h %s", id])
1209 (p4User
, gitEmail
) = self
.p4UserForCommit(id)
1211 diff
= read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (self
.diffOpts
, id, id))
1213 filesToDelete
= set()
1215 pureRenameCopy
= set()
1216 filesToChangeExecBit
= {}
1219 diff
= parseDiffTreeEntry(line
)
1220 modifier
= diff
['status']
1224 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
1225 filesToChangeExecBit
[path
] = diff
['dst_mode']
1226 editedFiles
.add(path
)
1227 elif modifier
== "A":
1228 filesToAdd
.add(path
)
1229 filesToChangeExecBit
[path
] = diff
['dst_mode']
1230 if path
in filesToDelete
:
1231 filesToDelete
.remove(path
)
1232 elif modifier
== "D":
1233 filesToDelete
.add(path
)
1234 if path
in filesToAdd
:
1235 filesToAdd
.remove(path
)
1236 elif modifier
== "C":
1237 src
, dest
= diff
['src'], diff
['dst']
1238 p4_integrate(src
, dest
)
1239 pureRenameCopy
.add(dest
)
1240 if diff
['src_sha1'] != diff
['dst_sha1']:
1242 pureRenameCopy
.discard(dest
)
1243 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
1245 pureRenameCopy
.discard(dest
)
1246 filesToChangeExecBit
[dest
] = diff
['dst_mode']
1248 # turn off read-only attribute
1249 os
.chmod(dest
, stat
.S_IWRITE
)
1251 editedFiles
.add(dest
)
1252 elif modifier
== "R":
1253 src
, dest
= diff
['src'], diff
['dst']
1254 if self
.p4HasMoveCommand
:
1255 p4_edit(src
) # src must be open before move
1256 p4_move(src
, dest
) # opens for (move/delete, move/add)
1258 p4_integrate(src
, dest
)
1259 if diff
['src_sha1'] != diff
['dst_sha1']:
1262 pureRenameCopy
.add(dest
)
1263 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
1264 if not self
.p4HasMoveCommand
:
1265 p4_edit(dest
) # with move: already open, writable
1266 filesToChangeExecBit
[dest
] = diff
['dst_mode']
1267 if not self
.p4HasMoveCommand
:
1269 os
.chmod(dest
, stat
.S_IWRITE
)
1271 filesToDelete
.add(src
)
1272 editedFiles
.add(dest
)
1274 die("unknown modifier %s for %s" % (modifier
, path
))
1276 diffcmd
= "git format-patch -k --stdout \"%s^\"..\"%s\"" % (id, id)
1277 patchcmd
= diffcmd
+ " | git apply "
1278 tryPatchCmd
= patchcmd
+ "--check -"
1279 applyPatchCmd
= patchcmd
+ "--check --apply -"
1280 patch_succeeded
= True
1282 if os
.system(tryPatchCmd
) != 0:
1283 fixed_rcs_keywords
= False
1284 patch_succeeded
= False
1285 print "Unfortunately applying the change failed!"
1287 # Patch failed, maybe it's just RCS keyword woes. Look through
1288 # the patch to see if that's possible.
1289 if gitConfigBool("git-p4.attemptRCSCleanup"):
1293 for file in editedFiles | filesToDelete
:
1294 # did this file's delta contain RCS keywords?
1295 pattern
= p4_keywords_regexp_for_file(file)
1298 # this file is a possibility...look for RCS keywords.
1299 regexp
= re
.compile(pattern
, re
.VERBOSE
)
1300 for line
in read_pipe_lines(["git", "diff", "%s^..%s" % (id, id), file]):
1301 if regexp
.search(line
):
1303 print "got keyword match on %s in %s in %s" % (pattern
, line
, file)
1304 kwfiles
[file] = pattern
1307 for file in kwfiles
:
1309 print "zapping %s with %s" % (line
,pattern
)
1310 # File is being deleted, so not open in p4. Must
1311 # disable the read-only bit on windows.
1312 if self
.isWindows
and file not in editedFiles
:
1313 os
.chmod(file, stat
.S_IWRITE
)
1314 self
.patchRCSKeywords(file, kwfiles
[file])
1315 fixed_rcs_keywords
= True
1317 if fixed_rcs_keywords
:
1318 print "Retrying the patch with RCS keywords cleaned up"
1319 if os
.system(tryPatchCmd
) == 0:
1320 patch_succeeded
= True
1322 if not patch_succeeded
:
1323 for f
in editedFiles
:
1328 # Apply the patch for real, and do add/delete/+x handling.
1330 system(applyPatchCmd
)
1332 for f
in filesToAdd
:
1334 for f
in filesToDelete
:
1338 # Set/clear executable bits
1339 for f
in filesToChangeExecBit
.keys():
1340 mode
= filesToChangeExecBit
[f
]
1341 setP4ExecBit(f
, mode
)
1344 # Build p4 change description, starting with the contents
1345 # of the git commit message.
1347 logMessage
= extractLogMessageFromGitCommit(id)
1348 logMessage
= logMessage
.strip()
1349 (logMessage
, jobs
) = self
.separate_jobs_from_description(logMessage
)
1351 template
= self
.prepareSubmitTemplate()
1352 submitTemplate
= self
.prepareLogMessage(template
, logMessage
, jobs
)
1354 if self
.preserveUser
:
1355 submitTemplate
+= "\n######## Actual user %s, modified after commit\n" % p4User
1357 if self
.checkAuthorship
and not self
.p4UserIsMe(p4User
):
1358 submitTemplate
+= "######## git author %s does not match your p4 account.\n" % gitEmail
1359 submitTemplate
+= "######## Use option --preserve-user to modify authorship.\n"
1360 submitTemplate
+= "######## Variable git-p4.skipUserNameCheck hides this message.\n"
1362 separatorLine
= "######## everything below this line is just the diff #######\n"
1365 if os
.environ
.has_key("P4DIFF"):
1366 del(os
.environ
["P4DIFF"])
1368 for editedFile
in editedFiles
:
1369 diff
+= p4_read_pipe(['diff', '-du',
1370 wildcard_encode(editedFile
)])
1374 for newFile
in filesToAdd
:
1375 newdiff
+= "==== new file ====\n"
1376 newdiff
+= "--- /dev/null\n"
1377 newdiff
+= "+++ %s\n" % newFile
1378 f
= open(newFile
, "r")
1379 for line
in f
.readlines():
1380 newdiff
+= "+" + line
1383 # change description file: submitTemplate, separatorLine, diff, newdiff
1384 (handle
, fileName
) = tempfile
.mkstemp()
1385 tmpFile
= os
.fdopen(handle
, "w+")
1387 submitTemplate
= submitTemplate
.replace("\n", "\r\n")
1388 separatorLine
= separatorLine
.replace("\n", "\r\n")
1389 newdiff
= newdiff
.replace("\n", "\r\n")
1390 tmpFile
.write(submitTemplate
+ separatorLine
+ diff
+ newdiff
)
1393 if self
.prepare_p4_only
:
1395 # Leave the p4 tree prepared, and the submit template around
1396 # and let the user decide what to do next
1399 print "P4 workspace prepared for submission."
1400 print "To submit or revert, go to client workspace"
1401 print " " + self
.clientPath
1403 print "To submit, use \"p4 submit\" to write a new description,"
1404 print "or \"p4 submit -i %s\" to use the one prepared by" \
1405 " \"git p4\"." % fileName
1406 print "You can delete the file \"%s\" when finished." % fileName
1408 if self
.preserveUser
and p4User
and not self
.p4UserIsMe(p4User
):
1409 print "To preserve change ownership by user %s, you must\n" \
1410 "do \"p4 change -f <change>\" after submitting and\n" \
1411 "edit the User field."
1413 print "After submitting, renamed files must be re-synced."
1414 print "Invoke \"p4 sync -f\" on each of these files:"
1415 for f
in pureRenameCopy
:
1419 print "To revert the changes, use \"p4 revert ...\", and delete"
1420 print "the submit template file \"%s\"" % fileName
1422 print "Since the commit adds new files, they must be deleted:"
1423 for f
in filesToAdd
:
1429 # Let the user edit the change description, then submit it.
1431 if self
.edit_template(fileName
):
1432 # read the edited message and submit
1434 tmpFile
= open(fileName
, "rb")
1435 message
= tmpFile
.read()
1437 submitTemplate
= message
[:message
.index(separatorLine
)]
1439 submitTemplate
= submitTemplate
.replace("\r\n", "\n")
1440 p4_write_pipe(['submit', '-i'], submitTemplate
)
1442 if self
.preserveUser
:
1444 # Get last changelist number. Cannot easily get it from
1445 # the submit command output as the output is
1447 changelist
= self
.lastP4Changelist()
1448 self
.modifyChangelistUser(changelist
, p4User
)
1450 # The rename/copy happened by applying a patch that created a
1451 # new file. This leaves it writable, which confuses p4.
1452 for f
in pureRenameCopy
:
1458 print "Submission cancelled, undoing p4 changes."
1459 for f
in editedFiles
:
1461 for f
in filesToAdd
:
1464 for f
in filesToDelete
:
1470 # Export git tags as p4 labels. Create a p4 label and then tag
1472 def exportGitTags(self
, gitTags
):
1473 validLabelRegexp
= gitConfig("git-p4.labelExportRegexp")
1474 if len(validLabelRegexp
) == 0:
1475 validLabelRegexp
= defaultLabelRegexp
1476 m
= re
.compile(validLabelRegexp
)
1478 for name
in gitTags
:
1480 if not m
.match(name
):
1482 print "tag %s does not match regexp %s" % (name
, validLabelRegexp
)
1485 # Get the p4 commit this corresponds to
1486 logMessage
= extractLogMessageFromGitCommit(name
)
1487 values
= extractSettingsGitLog(logMessage
)
1489 if not values
.has_key('change'):
1490 # a tag pointing to something not sent to p4; ignore
1492 print "git tag %s does not give a p4 commit" % name
1495 changelist
= values
['change']
1497 # Get the tag details.
1501 for l
in read_pipe_lines(["git", "cat-file", "-p", name
]):
1504 if re
.match(r
'tag\s+', l
):
1506 elif re
.match(r
'\s*$', l
):
1513 body
= ["lightweight tag imported by git p4\n"]
1515 # Create the label - use the same view as the client spec we are using
1516 clientSpec
= getClientSpec()
1518 labelTemplate
= "Label: %s\n" % name
1519 labelTemplate
+= "Description:\n"
1521 labelTemplate
+= "\t" + b
+ "\n"
1522 labelTemplate
+= "View:\n"
1523 for mapping
in clientSpec
.mappings
:
1524 labelTemplate
+= "\t%s\n" % mapping
.depot_side
.path
1527 print "Would create p4 label %s for tag" % name
1528 elif self
.prepare_p4_only
:
1529 print "Not creating p4 label %s for tag due to option" \
1530 " --prepare-p4-only" % name
1532 p4_write_pipe(["label", "-i"], labelTemplate
)
1535 p4_system(["tag", "-l", name
] +
1536 ["%s@%s" % (mapping
.depot_side
.path
, changelist
) for mapping
in clientSpec
.mappings
])
1539 print "created p4 label for tag %s" % name
1541 def run(self
, args
):
1543 self
.master
= currentGitBranch()
1544 if len(self
.master
) == 0 or not gitBranchExists("refs/heads/%s" % self
.master
):
1545 die("Detecting current git branch failed!")
1546 elif len(args
) == 1:
1547 self
.master
= args
[0]
1548 if not branchExists(self
.master
):
1549 die("Branch %s does not exist" % self
.master
)
1553 allowSubmit
= gitConfig("git-p4.allowSubmit")
1554 if len(allowSubmit
) > 0 and not self
.master
in allowSubmit
.split(","):
1555 die("%s is not in git-p4.allowSubmit" % self
.master
)
1557 [upstream
, settings
] = findUpstreamBranchPoint()
1558 self
.depotPath
= settings
['depot-paths'][0]
1559 if len(self
.origin
) == 0:
1560 self
.origin
= upstream
1562 if self
.preserveUser
:
1563 if not self
.canChangeChangelists():
1564 die("Cannot preserve user names without p4 super-user or admin permissions")
1566 # if not set from the command line, try the config file
1567 if self
.conflict_behavior
is None:
1568 val
= gitConfig("git-p4.conflict")
1570 if val
not in self
.conflict_behavior_choices
:
1571 die("Invalid value '%s' for config git-p4.conflict" % val
)
1574 self
.conflict_behavior
= val
1577 print "Origin branch is " + self
.origin
1579 if len(self
.depotPath
) == 0:
1580 print "Internal error: cannot locate perforce depot path from existing branches"
1583 self
.useClientSpec
= False
1584 if gitConfigBool("git-p4.useclientspec"):
1585 self
.useClientSpec
= True
1586 if self
.useClientSpec
:
1587 self
.clientSpecDirs
= getClientSpec()
1589 if self
.useClientSpec
:
1590 # all files are relative to the client spec
1591 self
.clientPath
= getClientRoot()
1593 self
.clientPath
= p4Where(self
.depotPath
)
1595 if self
.clientPath
== "":
1596 die("Error: Cannot locate perforce checkout of %s in client view" % self
.depotPath
)
1598 print "Perforce checkout for depot path %s located at %s" % (self
.depotPath
, self
.clientPath
)
1599 self
.oldWorkingDirectory
= os
.getcwd()
1601 # ensure the clientPath exists
1602 new_client_dir
= False
1603 if not os
.path
.exists(self
.clientPath
):
1604 new_client_dir
= True
1605 os
.makedirs(self
.clientPath
)
1607 chdir(self
.clientPath
)
1609 print "Would synchronize p4 checkout in %s" % self
.clientPath
1611 print "Synchronizing p4 checkout..."
1613 # old one was destroyed, and maybe nobody told p4
1614 p4_sync("...", "-f")
1620 for line
in read_pipe_lines(["git", "rev-list", "--no-merges", "%s..%s" % (self
.origin
, self
.master
)]):
1621 commits
.append(line
.strip())
1624 if self
.preserveUser
or gitConfigBool("git-p4.skipUserNameCheck"):
1625 self
.checkAuthorship
= False
1627 self
.checkAuthorship
= True
1629 if self
.preserveUser
:
1630 self
.checkValidP4Users(commits
)
1633 # Build up a set of options to be passed to diff when
1634 # submitting each commit to p4.
1636 if self
.detectRenames
:
1637 # command-line -M arg
1638 self
.diffOpts
= "-M"
1640 # If not explicitly set check the config variable
1641 detectRenames
= gitConfig("git-p4.detectRenames")
1643 if detectRenames
.lower() == "false" or detectRenames
== "":
1645 elif detectRenames
.lower() == "true":
1646 self
.diffOpts
= "-M"
1648 self
.diffOpts
= "-M%s" % detectRenames
1650 # no command-line arg for -C or --find-copies-harder, just
1652 detectCopies
= gitConfig("git-p4.detectCopies")
1653 if detectCopies
.lower() == "false" or detectCopies
== "":
1655 elif detectCopies
.lower() == "true":
1656 self
.diffOpts
+= " -C"
1658 self
.diffOpts
+= " -C%s" % detectCopies
1660 if gitConfigBool("git-p4.detectCopiesHarder"):
1661 self
.diffOpts
+= " --find-copies-harder"
1664 # Apply the commits, one at a time. On failure, ask if should
1665 # continue to try the rest of the patches, or quit.
1670 last
= len(commits
) - 1
1671 for i
, commit
in enumerate(commits
):
1673 print " ", read_pipe(["git", "show", "-s",
1674 "--format=format:%h %s", commit
])
1677 ok
= self
.applyCommit(commit
)
1679 applied
.append(commit
)
1681 if self
.prepare_p4_only
and i
< last
:
1682 print "Processing only the first commit due to option" \
1683 " --prepare-p4-only"
1688 # prompt for what to do, or use the option/variable
1689 if self
.conflict_behavior
== "ask":
1690 print "What do you want to do?"
1691 response
= raw_input("[s]kip this commit but apply"
1692 " the rest, or [q]uit? ")
1695 elif self
.conflict_behavior
== "skip":
1697 elif self
.conflict_behavior
== "quit":
1700 die("Unknown conflict_behavior '%s'" %
1701 self
.conflict_behavior
)
1703 if response
[0] == "s":
1704 print "Skipping this commit, but applying the rest"
1706 if response
[0] == "q":
1713 chdir(self
.oldWorkingDirectory
)
1717 elif self
.prepare_p4_only
:
1719 elif len(commits
) == len(applied
):
1720 print "All commits applied!"
1724 sync
.branch
= self
.branch
1731 if len(applied
) == 0:
1732 print "No commits applied."
1734 print "Applied only the commits marked with '*':"
1740 print star
, read_pipe(["git", "show", "-s",
1741 "--format=format:%h %s", c
])
1742 print "You will have to do 'git p4 sync' and rebase."
1744 if gitConfigBool("git-p4.exportLabels"):
1745 self
.exportLabels
= True
1747 if self
.exportLabels
:
1748 p4Labels
= getP4Labels(self
.depotPath
)
1749 gitTags
= getGitTags()
1751 missingGitTags
= gitTags
- p4Labels
1752 self
.exportGitTags(missingGitTags
)
1754 # exit with error unless everything applied perfecly
1755 if len(commits
) != len(applied
):
1761 """Represent a p4 view ("p4 help views"), and map files in a
1762 repo according to the view."""
1765 """A depot or client path, possibly containing wildcards.
1766 The only one supported is ... at the end, currently.
1767 Initialize with the full path, with //depot or //client."""
1769 def __init__(self
, path
, is_depot
):
1771 self
.is_depot
= is_depot
1772 self
.find_wildcards()
1773 # remember the prefix bit, useful for relative mappings
1774 m
= re
.match("(//[^/]+/)", self
.path
)
1776 die("Path %s does not start with //prefix/" % self
.path
)
1778 if not self
.is_depot
:
1779 # strip //client/ on client paths
1780 self
.path
= self
.path
[len(prefix
):]
1782 def find_wildcards(self
):
1783 """Make sure wildcards are valid, and set up internal
1786 self
.ends_triple_dot
= False
1787 # There are three wildcards allowed in p4 views
1788 # (see "p4 help views"). This code knows how to
1789 # handle "..." (only at the end), but cannot deal with
1790 # "%%n" or "*". Only check the depot_side, as p4 should
1791 # validate that the client_side matches too.
1792 if re
.search(r
'%%[1-9]', self
.path
):
1793 die("Can't handle %%n wildcards in view: %s" % self
.path
)
1794 if self
.path
.find("*") >= 0:
1795 die("Can't handle * wildcards in view: %s" % self
.path
)
1796 triple_dot_index
= self
.path
.find("...")
1797 if triple_dot_index
>= 0:
1798 if triple_dot_index
!= len(self
.path
) - 3:
1799 die("Can handle only single ... wildcard, at end: %s" %
1801 self
.ends_triple_dot
= True
1803 def ensure_compatible(self
, other_path
):
1804 """Make sure the wildcards agree."""
1805 if self
.ends_triple_dot
!= other_path
.ends_triple_dot
:
1806 die("Both paths must end with ... if either does;\n" +
1807 "paths: %s %s" % (self
.path
, other_path
.path
))
1809 def match_wildcards(self
, test_path
):
1810 """See if this test_path matches us, and fill in the value
1811 of the wildcards if so. Returns a tuple of
1812 (True|False, wildcards[]). For now, only the ... at end
1813 is supported, so at most one wildcard."""
1814 if self
.ends_triple_dot
:
1815 dotless
= self
.path
[:-3]
1816 if test_path
.startswith(dotless
):
1817 wildcard
= test_path
[len(dotless
):]
1818 return (True, [ wildcard
])
1820 if test_path
== self
.path
:
1824 def match(self
, test_path
):
1825 """Just return if it matches; don't bother with the wildcards."""
1826 b
, _
= self
.match_wildcards(test_path
)
1829 def fill_in_wildcards(self
, wildcards
):
1830 """Return the relative path, with the wildcards filled in
1831 if there are any."""
1832 if self
.ends_triple_dot
:
1833 return self
.path
[:-3] + wildcards
[0]
1837 class Mapping(object):
1838 def __init__(self
, depot_side
, client_side
, overlay
, exclude
):
1839 # depot_side is without the trailing /... if it had one
1840 self
.depot_side
= View
.Path(depot_side
, is_depot
=True)
1841 self
.client_side
= View
.Path(client_side
, is_depot
=False)
1842 self
.overlay
= overlay
# started with "+"
1843 self
.exclude
= exclude
# started with "-"
1844 assert not (self
.overlay
and self
.exclude
)
1845 self
.depot_side
.ensure_compatible(self
.client_side
)
1853 return "View.Mapping: %s%s -> %s" % \
1854 (c
, self
.depot_side
.path
, self
.client_side
.path
)
1856 def map_depot_to_client(self
, depot_path
):
1857 """Calculate the client path if using this mapping on the
1858 given depot path; does not consider the effect of other
1859 mappings in a view. Even excluded mappings are returned."""
1860 matches
, wildcards
= self
.depot_side
.match_wildcards(depot_path
)
1863 client_path
= self
.client_side
.fill_in_wildcards(wildcards
)
1872 def append(self
, view_line
):
1873 """Parse a view line, splitting it into depot and client
1874 sides. Append to self.mappings, preserving order."""
1876 # Split the view line into exactly two words. P4 enforces
1877 # structure on these lines that simplifies this quite a bit.
1879 # Either or both words may be double-quoted.
1880 # Single quotes do not matter.
1881 # Double-quote marks cannot occur inside the words.
1882 # A + or - prefix is also inside the quotes.
1883 # There are no quotes unless they contain a space.
1884 # The line is already white-space stripped.
1885 # The two words are separated by a single space.
1887 if view_line
[0] == '"':
1888 # First word is double quoted. Find its end.
1889 close_quote_index
= view_line
.find('"', 1)
1890 if close_quote_index
<= 0:
1891 die("No first-word closing quote found: %s" % view_line
)
1892 depot_side
= view_line
[1:close_quote_index
]
1893 # skip closing quote and space
1894 rhs_index
= close_quote_index
+ 1 + 1
1896 space_index
= view_line
.find(" ")
1897 if space_index
<= 0:
1898 die("No word-splitting space found: %s" % view_line
)
1899 depot_side
= view_line
[0:space_index
]
1900 rhs_index
= space_index
+ 1
1902 if view_line
[rhs_index
] == '"':
1903 # Second word is double quoted. Make sure there is a
1904 # double quote at the end too.
1905 if not view_line
.endswith('"'):
1906 die("View line with rhs quote should end with one: %s" %
1909 client_side
= view_line
[rhs_index
+1:-1]
1911 client_side
= view_line
[rhs_index
:]
1913 # prefix + means overlay on previous mapping
1915 if depot_side
.startswith("+"):
1917 depot_side
= depot_side
[1:]
1919 # prefix - means exclude this path
1921 if depot_side
.startswith("-"):
1923 depot_side
= depot_side
[1:]
1925 m
= View
.Mapping(depot_side
, client_side
, overlay
, exclude
)
1926 self
.mappings
.append(m
)
1928 def map_in_client(self
, depot_path
):
1929 """Return the relative location in the client where this
1930 depot file should live. Returns "" if the file should
1931 not be mapped in the client."""
1936 # look at later entries first
1937 for m
in self
.mappings
[::-1]:
1939 # see where will this path end up in the client
1940 p
= m
.map_depot_to_client(depot_path
)
1943 # Depot path does not belong in client. Must remember
1944 # this, as previous items should not cause files to
1945 # exist in this path either. Remember that the list is
1946 # being walked from the end, which has higher precedence.
1947 # Overlap mappings do not exclude previous mappings.
1949 paths_filled
.append(m
.client_side
)
1952 # This mapping matched; no need to search any further.
1953 # But, the mapping could be rejected if the client path
1954 # has already been claimed by an earlier mapping (i.e.
1955 # one later in the list, which we are walking backwards).
1956 already_mapped_in_client
= False
1957 for f
in paths_filled
:
1958 # this is View.Path.match
1960 already_mapped_in_client
= True
1962 if not already_mapped_in_client
:
1963 # Include this file, unless it is from a line that
1964 # explicitly said to exclude it.
1968 # a match, even if rejected, always stops the search
1973 class P4Sync(Command
, P4UserMap
):
1974 delete_actions
= ( "delete", "move/delete", "purge" )
1977 Command
.__init
__(self
)
1978 P4UserMap
.__init
__(self
)
1980 optparse
.make_option("--branch", dest
="branch"),
1981 optparse
.make_option("--detect-branches", dest
="detectBranches", action
="store_true"),
1982 optparse
.make_option("--changesfile", dest
="changesFile"),
1983 optparse
.make_option("--silent", dest
="silent", action
="store_true"),
1984 optparse
.make_option("--detect-labels", dest
="detectLabels", action
="store_true"),
1985 optparse
.make_option("--import-labels", dest
="importLabels", action
="store_true"),
1986 optparse
.make_option("--import-local", dest
="importIntoRemotes", action
="store_false",
1987 help="Import into refs/heads/ , not refs/remotes"),
1988 optparse
.make_option("--max-changes", dest
="maxChanges"),
1989 optparse
.make_option("--keep-path", dest
="keepRepoPath", action
='store_true',
1990 help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),
1991 optparse
.make_option("--use-client-spec", dest
="useClientSpec", action
='store_true',
1992 help="Only sync files that are included in the Perforce Client Spec")
1994 self
.description
= """Imports from Perforce into a git repository.\n
1996 //depot/my/project/ -- to import the current head
1997 //depot/my/project/@all -- to import everything
1998 //depot/my/project/@1,6 -- to import only from revision 1 to 6
2000 (a ... is not needed in the path p4 specification, it's added implicitly)"""
2002 self
.usage
+= " //depot/path[@revRange]"
2004 self
.createdBranches
= set()
2005 self
.committedChanges
= set()
2007 self
.detectBranches
= False
2008 self
.detectLabels
= False
2009 self
.importLabels
= False
2010 self
.changesFile
= ""
2011 self
.syncWithOrigin
= True
2012 self
.importIntoRemotes
= True
2013 self
.maxChanges
= ""
2014 self
.keepRepoPath
= False
2015 self
.depotPaths
= None
2016 self
.p4BranchesInGit
= []
2017 self
.cloneExclude
= []
2018 self
.useClientSpec
= False
2019 self
.useClientSpec_from_options
= False
2020 self
.clientSpecDirs
= None
2021 self
.tempBranches
= []
2022 self
.tempBranchLocation
= "git-p4-tmp"
2024 if gitConfig("git-p4.syncFromOrigin") == "false":
2025 self
.syncWithOrigin
= False
2027 # Force a checkpoint in fast-import and wait for it to finish
2028 def checkpoint(self
):
2029 self
.gitStream
.write("checkpoint\n\n")
2030 self
.gitStream
.write("progress checkpoint\n\n")
2031 out
= self
.gitOutput
.readline()
2033 print "checkpoint finished: " + out
2035 def extractFilesFromCommit(self
, commit
):
2036 self
.cloneExclude
= [re
.sub(r
"\.\.\.$", "", path
)
2037 for path
in self
.cloneExclude
]
2040 while commit
.has_key("depotFile%s" % fnum
):
2041 path
= commit
["depotFile%s" % fnum
]
2043 if [p
for p
in self
.cloneExclude
2044 if p4PathStartsWith(path
, p
)]:
2047 found
= [p
for p
in self
.depotPaths
2048 if p4PathStartsWith(path
, p
)]
2055 file["rev"] = commit
["rev%s" % fnum
]
2056 file["action"] = commit
["action%s" % fnum
]
2057 file["type"] = commit
["type%s" % fnum
]
2062 def stripRepoPath(self
, path
, prefixes
):
2063 """When streaming files, this is called to map a p4 depot path
2064 to where it should go in git. The prefixes are either
2065 self.depotPaths, or self.branchPrefixes in the case of
2066 branch detection."""
2068 if self
.useClientSpec
:
2069 # branch detection moves files up a level (the branch name)
2070 # from what client spec interpretation gives
2071 path
= self
.clientSpecDirs
.map_in_client(path
)
2072 if self
.detectBranches
:
2073 for b
in self
.knownBranches
:
2074 if path
.startswith(b
+ "/"):
2075 path
= path
[len(b
)+1:]
2077 elif self
.keepRepoPath
:
2078 # Preserve everything in relative path name except leading
2079 # //depot/; just look at first prefix as they all should
2080 # be in the same depot.
2081 depot
= re
.sub("^(//[^/]+/).*", r
'\1', prefixes
[0])
2082 if p4PathStartsWith(path
, depot
):
2083 path
= path
[len(depot
):]
2087 if p4PathStartsWith(path
, p
):
2088 path
= path
[len(p
):]
2091 path
= wildcard_decode(path
)
2094 def splitFilesIntoBranches(self
, commit
):
2095 """Look at each depotFile in the commit to figure out to what
2096 branch it belongs."""
2100 while commit
.has_key("depotFile%s" % fnum
):
2101 path
= commit
["depotFile%s" % fnum
]
2102 found
= [p
for p
in self
.depotPaths
2103 if p4PathStartsWith(path
, p
)]
2110 file["rev"] = commit
["rev%s" % fnum
]
2111 file["action"] = commit
["action%s" % fnum
]
2112 file["type"] = commit
["type%s" % fnum
]
2115 # start with the full relative path where this file would
2117 if self
.useClientSpec
:
2118 relPath
= self
.clientSpecDirs
.map_in_client(path
)
2120 relPath
= self
.stripRepoPath(path
, self
.depotPaths
)
2122 for branch
in self
.knownBranches
.keys():
2123 # add a trailing slash so that a commit into qt/4.2foo
2124 # doesn't end up in qt/4.2, e.g.
2125 if relPath
.startswith(branch
+ "/"):
2126 if branch
not in branches
:
2127 branches
[branch
] = []
2128 branches
[branch
].append(file)
2133 # output one file from the P4 stream
2134 # - helper for streamP4Files
2136 def streamOneP4File(self
, file, contents
):
2137 relPath
= self
.stripRepoPath(file['depotFile'], self
.branchPrefixes
)
2139 sys
.stderr
.write("%s\n" % relPath
)
2141 (type_base
, type_mods
) = split_p4_type(file["type"])
2144 if "x" in type_mods
:
2146 if type_base
== "symlink":
2148 # p4 print on a symlink contains "target\n"; remove the newline
2149 data
= ''.join(contents
)
2150 contents
= [data
[:-1]]
2152 if type_base
== "utf16":
2153 # p4 delivers different text in the python output to -G
2154 # than it does when using "print -o", or normal p4 client
2155 # operations. utf16 is converted to ascii or utf8, perhaps.
2156 # But ascii text saved as -t utf16 is completely mangled.
2157 # Invoke print -o to get the real contents.
2159 # On windows, the newlines will always be mangled by print, so put
2160 # them back too. This is not needed to the cygwin windows version,
2161 # just the native "NT" type.
2163 text
= p4_read_pipe(['print', '-q', '-o', '-', file['depotFile']])
2164 if p4_version_string().find("/NT") >= 0:
2165 text
= text
.replace("\r\n", "\n")
2168 if type_base
== "apple":
2169 # Apple filetype files will be streamed as a concatenation of
2170 # its appledouble header and the contents. This is useless
2171 # on both macs and non-macs. If using "print -q -o xx", it
2172 # will create "xx" with the data, and "%xx" with the header.
2173 # This is also not very useful.
2175 # Ideally, someday, this script can learn how to generate
2176 # appledouble files directly and import those to git, but
2177 # non-mac machines can never find a use for apple filetype.
2178 print "\nIgnoring apple filetype file %s" % file['depotFile']
2181 # Note that we do not try to de-mangle keywords on utf16 files,
2182 # even though in theory somebody may want that.
2183 pattern
= p4_keywords_regexp_for_type(type_base
, type_mods
)
2185 regexp
= re
.compile(pattern
, re
.VERBOSE
)
2186 text
= ''.join(contents
)
2187 text
= regexp
.sub(r
'$\1$', text
)
2190 self
.gitStream
.write("M %s inline %s\n" % (git_mode
, relPath
))
2195 length
= length
+ len(d
)
2197 self
.gitStream
.write("data %d\n" % length
)
2199 self
.gitStream
.write(d
)
2200 self
.gitStream
.write("\n")
2202 def streamOneP4Deletion(self
, file):
2203 relPath
= self
.stripRepoPath(file['path'], self
.branchPrefixes
)
2205 sys
.stderr
.write("delete %s\n" % relPath
)
2206 self
.gitStream
.write("D %s\n" % relPath
)
2208 # handle another chunk of streaming data
2209 def streamP4FilesCb(self
, marshalled
):
2211 # catch p4 errors and complain
2213 if "code" in marshalled
:
2214 if marshalled
["code"] == "error":
2215 if "data" in marshalled
:
2216 err
= marshalled
["data"].rstrip()
2219 if self
.stream_have_file_info
:
2220 if "depotFile" in self
.stream_file
:
2221 f
= self
.stream_file
["depotFile"]
2222 # force a failure in fast-import, else an empty
2223 # commit will be made
2224 self
.gitStream
.write("\n")
2225 self
.gitStream
.write("die-now\n")
2226 self
.gitStream
.close()
2227 # ignore errors, but make sure it exits first
2228 self
.importProcess
.wait()
2230 die("Error from p4 print for %s: %s" % (f
, err
))
2232 die("Error from p4 print: %s" % err
)
2234 if marshalled
.has_key('depotFile') and self
.stream_have_file_info
:
2235 # start of a new file - output the old one first
2236 self
.streamOneP4File(self
.stream_file
, self
.stream_contents
)
2237 self
.stream_file
= {}
2238 self
.stream_contents
= []
2239 self
.stream_have_file_info
= False
2241 # pick up the new file information... for the
2242 # 'data' field we need to append to our array
2243 for k
in marshalled
.keys():
2245 self
.stream_contents
.append(marshalled
['data'])
2247 self
.stream_file
[k
] = marshalled
[k
]
2249 self
.stream_have_file_info
= True
2251 # Stream directly from "p4 files" into "git fast-import"
2252 def streamP4Files(self
, files
):
2258 # if using a client spec, only add the files that have
2259 # a path in the client
2260 if self
.clientSpecDirs
:
2261 if self
.clientSpecDirs
.map_in_client(f
['path']) == "":
2264 filesForCommit
.append(f
)
2265 if f
['action'] in self
.delete_actions
:
2266 filesToDelete
.append(f
)
2268 filesToRead
.append(f
)
2271 for f
in filesToDelete
:
2272 self
.streamOneP4Deletion(f
)
2274 if len(filesToRead
) > 0:
2275 self
.stream_file
= {}
2276 self
.stream_contents
= []
2277 self
.stream_have_file_info
= False
2279 # curry self argument
2280 def streamP4FilesCbSelf(entry
):
2281 self
.streamP4FilesCb(entry
)
2283 fileArgs
= ['%s#%s' % (f
['path'], f
['rev']) for f
in filesToRead
]
2285 p4CmdList(["-x", "-", "print"],
2287 cb
=streamP4FilesCbSelf
)
2290 if self
.stream_file
.has_key('depotFile'):
2291 self
.streamOneP4File(self
.stream_file
, self
.stream_contents
)
2293 def make_email(self
, userid
):
2294 if userid
in self
.users
:
2295 return self
.users
[userid
]
2297 return "%s <a@b>" % userid
2300 def streamTag(self
, gitStream
, labelName
, labelDetails
, commit
, epoch
):
2302 print "writing tag %s for commit %s" % (labelName
, commit
)
2303 gitStream
.write("tag %s\n" % labelName
)
2304 gitStream
.write("from %s\n" % commit
)
2306 if labelDetails
.has_key('Owner'):
2307 owner
= labelDetails
["Owner"]
2311 # Try to use the owner of the p4 label, or failing that,
2312 # the current p4 user id.
2314 email
= self
.make_email(owner
)
2316 email
= self
.make_email(self
.p4UserId())
2317 tagger
= "%s %s %s" % (email
, epoch
, self
.tz
)
2319 gitStream
.write("tagger %s\n" % tagger
)
2321 print "labelDetails=",labelDetails
2322 if labelDetails
.has_key('Description'):
2323 description
= labelDetails
['Description']
2325 description
= 'Label from git p4'
2327 gitStream
.write("data %d\n" % len(description
))
2328 gitStream
.write(description
)
2329 gitStream
.write("\n")
2331 def commit(self
, details
, files
, branch
, parent
= ""):
2332 epoch
= details
["time"]
2333 author
= details
["user"]
2336 print "commit into %s" % branch
2338 # start with reading files; if that fails, we should not
2342 if [p
for p
in self
.branchPrefixes
if p4PathStartsWith(f
['path'], p
)]:
2343 new_files
.append (f
)
2345 sys
.stderr
.write("Ignoring file outside of prefix: %s\n" % f
['path'])
2347 self
.gitStream
.write("commit %s\n" % branch
)
2348 # gitStream.write("mark :%s\n" % details["change"])
2349 self
.committedChanges
.add(int(details
["change"]))
2351 if author
not in self
.users
:
2352 self
.getUserMapFromPerforceServer()
2353 committer
= "%s %s %s" % (self
.make_email(author
), epoch
, self
.tz
)
2355 self
.gitStream
.write("committer %s\n" % committer
)
2357 self
.gitStream
.write("data <<EOT\n")
2358 self
.gitStream
.write(details
["desc"])
2359 self
.gitStream
.write("\n[git-p4: depot-paths = \"%s\": change = %s" %
2360 (','.join(self
.branchPrefixes
), details
["change"]))
2361 if len(details
['options']) > 0:
2362 self
.gitStream
.write(": options = %s" % details
['options'])
2363 self
.gitStream
.write("]\nEOT\n\n")
2367 print "parent %s" % parent
2368 self
.gitStream
.write("from %s\n" % parent
)
2370 self
.streamP4Files(new_files
)
2371 self
.gitStream
.write("\n")
2373 change
= int(details
["change"])
2375 if self
.labels
.has_key(change
):
2376 label
= self
.labels
[change
]
2377 labelDetails
= label
[0]
2378 labelRevisions
= label
[1]
2380 print "Change %s is labelled %s" % (change
, labelDetails
)
2382 files
= p4CmdList(["files"] + ["%s...@%s" % (p
, change
)
2383 for p
in self
.branchPrefixes
])
2385 if len(files
) == len(labelRevisions
):
2389 if info
["action"] in self
.delete_actions
:
2391 cleanedFiles
[info
["depotFile"]] = info
["rev"]
2393 if cleanedFiles
== labelRevisions
:
2394 self
.streamTag(self
.gitStream
, 'tag_%s' % labelDetails
['label'], labelDetails
, branch
, epoch
)
2398 print ("Tag %s does not match with change %s: files do not match."
2399 % (labelDetails
["label"], change
))
2403 print ("Tag %s does not match with change %s: file count is different."
2404 % (labelDetails
["label"], change
))
2406 # Build a dictionary of changelists and labels, for "detect-labels" option.
2407 def getLabels(self
):
2410 l
= p4CmdList(["labels"] + ["%s..." % p
for p
in self
.depotPaths
])
2411 if len(l
) > 0 and not self
.silent
:
2412 print "Finding files belonging to labels in %s" % `self
.depotPaths`
2415 label
= output
["label"]
2419 print "Querying files for label %s" % label
2420 for file in p4CmdList(["files"] +
2421 ["%s...@%s" % (p
, label
)
2422 for p
in self
.depotPaths
]):
2423 revisions
[file["depotFile"]] = file["rev"]
2424 change
= int(file["change"])
2425 if change
> newestChange
:
2426 newestChange
= change
2428 self
.labels
[newestChange
] = [output
, revisions
]
2431 print "Label changes: %s" % self
.labels
.keys()
2433 # Import p4 labels as git tags. A direct mapping does not
2434 # exist, so assume that if all the files are at the same revision
2435 # then we can use that, or it's something more complicated we should
2437 def importP4Labels(self
, stream
, p4Labels
):
2439 print "import p4 labels: " + ' '.join(p4Labels
)
2441 ignoredP4Labels
= gitConfigList("git-p4.ignoredP4Labels")
2442 validLabelRegexp
= gitConfig("git-p4.labelImportRegexp")
2443 if len(validLabelRegexp
) == 0:
2444 validLabelRegexp
= defaultLabelRegexp
2445 m
= re
.compile(validLabelRegexp
)
2447 for name
in p4Labels
:
2450 if not m
.match(name
):
2452 print "label %s does not match regexp %s" % (name
,validLabelRegexp
)
2455 if name
in ignoredP4Labels
:
2458 labelDetails
= p4CmdList(['label', "-o", name
])[0]
2460 # get the most recent changelist for each file in this label
2461 change
= p4Cmd(["changes", "-m", "1"] + ["%s...@%s" % (p
, name
)
2462 for p
in self
.depotPaths
])
2464 if change
.has_key('change'):
2465 # find the corresponding git commit; take the oldest commit
2466 changelist
= int(change
['change'])
2467 gitCommit
= read_pipe(["git", "rev-list", "--max-count=1",
2468 "--reverse", ":/\[git-p4:.*change = %d\]" % changelist
])
2469 if len(gitCommit
) == 0:
2470 print "could not find git commit for changelist %d" % changelist
2472 gitCommit
= gitCommit
.strip()
2474 # Convert from p4 time format
2476 tmwhen
= time
.strptime(labelDetails
['Update'], "%Y/%m/%d %H:%M:%S")
2478 print "Could not convert label time %s" % labelDetails
['Update']
2481 when
= int(time
.mktime(tmwhen
))
2482 self
.streamTag(stream
, name
, labelDetails
, gitCommit
, when
)
2484 print "p4 label %s mapped to git commit %s" % (name
, gitCommit
)
2487 print "Label %s has no changelists - possibly deleted?" % name
2490 # We can't import this label; don't try again as it will get very
2491 # expensive repeatedly fetching all the files for labels that will
2492 # never be imported. If the label is moved in the future, the
2493 # ignore will need to be removed manually.
2494 system(["git", "config", "--add", "git-p4.ignoredP4Labels", name
])
2496 def guessProjectName(self
):
2497 for p
in self
.depotPaths
:
2500 p
= p
[p
.strip().rfind("/") + 1:]
2501 if not p
.endswith("/"):
2505 def getBranchMapping(self
):
2506 lostAndFoundBranches
= set()
2508 user
= gitConfig("git-p4.branchUser")
2510 command
= "branches -u %s" % user
2512 command
= "branches"
2514 for info
in p4CmdList(command
):
2515 details
= p4Cmd(["branch", "-o", info
["branch"]])
2517 while details
.has_key("View%s" % viewIdx
):
2518 paths
= details
["View%s" % viewIdx
].split(" ")
2519 viewIdx
= viewIdx
+ 1
2520 # require standard //depot/foo/... //depot/bar/... mapping
2521 if len(paths
) != 2 or not paths
[0].endswith("/...") or not paths
[1].endswith("/..."):
2524 destination
= paths
[1]
2526 if p4PathStartsWith(source
, self
.depotPaths
[0]) and p4PathStartsWith(destination
, self
.depotPaths
[0]):
2527 source
= source
[len(self
.depotPaths
[0]):-4]
2528 destination
= destination
[len(self
.depotPaths
[0]):-4]
2530 if destination
in self
.knownBranches
:
2532 print "p4 branch %s defines a mapping from %s to %s" % (info
["branch"], source
, destination
)
2533 print "but there exists another mapping from %s to %s already!" % (self
.knownBranches
[destination
], destination
)
2536 self
.knownBranches
[destination
] = source
2538 lostAndFoundBranches
.discard(destination
)
2540 if source
not in self
.knownBranches
:
2541 lostAndFoundBranches
.add(source
)
2543 # Perforce does not strictly require branches to be defined, so we also
2544 # check git config for a branch list.
2546 # Example of branch definition in git config file:
2548 # branchList=main:branchA
2549 # branchList=main:branchB
2550 # branchList=branchA:branchC
2551 configBranches
= gitConfigList("git-p4.branchList")
2552 for branch
in configBranches
:
2554 (source
, destination
) = branch
.split(":")
2555 self
.knownBranches
[destination
] = source
2557 lostAndFoundBranches
.discard(destination
)
2559 if source
not in self
.knownBranches
:
2560 lostAndFoundBranches
.add(source
)
2563 for branch
in lostAndFoundBranches
:
2564 self
.knownBranches
[branch
] = branch
2566 def getBranchMappingFromGitBranches(self
):
2567 branches
= p4BranchesInGit(self
.importIntoRemotes
)
2568 for branch
in branches
.keys():
2569 if branch
== "master":
2572 branch
= branch
[len(self
.projectName
):]
2573 self
.knownBranches
[branch
] = branch
2575 def updateOptionDict(self
, d
):
2577 if self
.keepRepoPath
:
2578 option_keys
['keepRepoPath'] = 1
2580 d
["options"] = ' '.join(sorted(option_keys
.keys()))
2582 def readOptions(self
, d
):
2583 self
.keepRepoPath
= (d
.has_key('options')
2584 and ('keepRepoPath' in d
['options']))
2586 def gitRefForBranch(self
, branch
):
2587 if branch
== "main":
2588 return self
.refPrefix
+ "master"
2590 if len(branch
) <= 0:
2593 return self
.refPrefix
+ self
.projectName
+ branch
2595 def gitCommitByP4Change(self
, ref
, change
):
2597 print "looking in ref " + ref
+ " for change %s using bisect..." % change
2600 latestCommit
= parseRevision(ref
)
2604 print "trying: earliest %s latest %s" % (earliestCommit
, latestCommit
)
2605 next
= read_pipe("git rev-list --bisect %s %s" % (latestCommit
, earliestCommit
)).strip()
2610 log
= extractLogMessageFromGitCommit(next
)
2611 settings
= extractSettingsGitLog(log
)
2612 currentChange
= int(settings
['change'])
2614 print "current change %s" % currentChange
2616 if currentChange
== change
:
2618 print "found %s" % next
2621 if currentChange
< change
:
2622 earliestCommit
= "^%s" % next
2624 latestCommit
= "%s" % next
2628 def importNewBranch(self
, branch
, maxChange
):
2629 # make fast-import flush all changes to disk and update the refs using the checkpoint
2630 # command so that we can try to find the branch parent in the git history
2631 self
.gitStream
.write("checkpoint\n\n");
2632 self
.gitStream
.flush();
2633 branchPrefix
= self
.depotPaths
[0] + branch
+ "/"
2634 range = "@1,%s" % maxChange
2635 #print "prefix" + branchPrefix
2636 changes
= p4ChangesForPaths([branchPrefix
], range)
2637 if len(changes
) <= 0:
2639 firstChange
= changes
[0]
2640 #print "first change in branch: %s" % firstChange
2641 sourceBranch
= self
.knownBranches
[branch
]
2642 sourceDepotPath
= self
.depotPaths
[0] + sourceBranch
2643 sourceRef
= self
.gitRefForBranch(sourceBranch
)
2644 #print "source " + sourceBranch
2646 branchParentChange
= int(p4Cmd(["changes", "-m", "1", "%s...@1,%s" % (sourceDepotPath
, firstChange
)])["change"])
2647 #print "branch parent: %s" % branchParentChange
2648 gitParent
= self
.gitCommitByP4Change(sourceRef
, branchParentChange
)
2649 if len(gitParent
) > 0:
2650 self
.initialParents
[self
.gitRefForBranch(branch
)] = gitParent
2651 #print "parent git commit: %s" % gitParent
2653 self
.importChanges(changes
)
2656 def searchParent(self
, parent
, branch
, target
):
2658 for blob
in read_pipe_lines(["git", "rev-list", "--reverse",
2659 "--no-merges", parent
]):
2661 if len(read_pipe(["git", "diff-tree", blob
, target
])) == 0:
2664 print "Found parent of %s in commit %s" % (branch
, blob
)
2671 def importChanges(self
, changes
):
2673 for change
in changes
:
2674 description
= p4_describe(change
)
2675 self
.updateOptionDict(description
)
2678 sys
.stdout
.write("\rImporting revision %s (%s%%)" % (change
, cnt
* 100 / len(changes
)))
2683 if self
.detectBranches
:
2684 branches
= self
.splitFilesIntoBranches(description
)
2685 for branch
in branches
.keys():
2687 branchPrefix
= self
.depotPaths
[0] + branch
+ "/"
2688 self
.branchPrefixes
= [ branchPrefix
]
2692 filesForCommit
= branches
[branch
]
2695 print "branch is %s" % branch
2697 self
.updatedBranches
.add(branch
)
2699 if branch
not in self
.createdBranches
:
2700 self
.createdBranches
.add(branch
)
2701 parent
= self
.knownBranches
[branch
]
2702 if parent
== branch
:
2705 fullBranch
= self
.projectName
+ branch
2706 if fullBranch
not in self
.p4BranchesInGit
:
2708 print("\n Importing new branch %s" % fullBranch
);
2709 if self
.importNewBranch(branch
, change
- 1):
2711 self
.p4BranchesInGit
.append(fullBranch
)
2713 print("\n Resuming with change %s" % change
);
2716 print "parent determined through known branches: %s" % parent
2718 branch
= self
.gitRefForBranch(branch
)
2719 parent
= self
.gitRefForBranch(parent
)
2722 print "looking for initial parent for %s; current parent is %s" % (branch
, parent
)
2724 if len(parent
) == 0 and branch
in self
.initialParents
:
2725 parent
= self
.initialParents
[branch
]
2726 del self
.initialParents
[branch
]
2730 tempBranch
= "%s/%d" % (self
.tempBranchLocation
, change
)
2732 print "Creating temporary branch: " + tempBranch
2733 self
.commit(description
, filesForCommit
, tempBranch
)
2734 self
.tempBranches
.append(tempBranch
)
2736 blob
= self
.searchParent(parent
, branch
, tempBranch
)
2738 self
.commit(description
, filesForCommit
, branch
, blob
)
2741 print "Parent of %s not found. Committing into head of %s" % (branch
, parent
)
2742 self
.commit(description
, filesForCommit
, branch
, parent
)
2744 files
= self
.extractFilesFromCommit(description
)
2745 self
.commit(description
, files
, self
.branch
,
2747 # only needed once, to connect to the previous commit
2748 self
.initialParent
= ""
2750 print self
.gitError
.read()
2753 def importHeadRevision(self
, revision
):
2754 print "Doing initial import of %s from revision %s into %s" % (' '.join(self
.depotPaths
), revision
, self
.branch
)
2757 details
["user"] = "git perforce import user"
2758 details
["desc"] = ("Initial import of %s from the state at revision %s\n"
2759 % (' '.join(self
.depotPaths
), revision
))
2760 details
["change"] = revision
2764 fileArgs
= ["%s...%s" % (p
,revision
) for p
in self
.depotPaths
]
2766 for info
in p4CmdList(["files"] + fileArgs
):
2768 if 'code' in info
and info
['code'] == 'error':
2769 sys
.stderr
.write("p4 returned an error: %s\n"
2771 if info
['data'].find("must refer to client") >= 0:
2772 sys
.stderr
.write("This particular p4 error is misleading.\n")
2773 sys
.stderr
.write("Perhaps the depot path was misspelled.\n");
2774 sys
.stderr
.write("Depot path: %s\n" % " ".join(self
.depotPaths
))
2776 if 'p4ExitCode' in info
:
2777 sys
.stderr
.write("p4 exitcode: %s\n" % info
['p4ExitCode'])
2781 change
= int(info
["change"])
2782 if change
> newestRevision
:
2783 newestRevision
= change
2785 if info
["action"] in self
.delete_actions
:
2786 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
2787 #fileCnt = fileCnt + 1
2790 for prop
in ["depotFile", "rev", "action", "type" ]:
2791 details
["%s%s" % (prop
, fileCnt
)] = info
[prop
]
2793 fileCnt
= fileCnt
+ 1
2795 details
["change"] = newestRevision
2797 # Use time from top-most change so that all git p4 clones of
2798 # the same p4 repo have the same commit SHA1s.
2799 res
= p4_describe(newestRevision
)
2800 details
["time"] = res
["time"]
2802 self
.updateOptionDict(details
)
2804 self
.commit(details
, self
.extractFilesFromCommit(details
), self
.branch
)
2806 print "IO error with git fast-import. Is your git version recent enough?"
2807 print self
.gitError
.read()
2810 def run(self
, args
):
2811 self
.depotPaths
= []
2812 self
.changeRange
= ""
2813 self
.previousDepotPaths
= []
2814 self
.hasOrigin
= False
2816 # map from branch depot path to parent branch
2817 self
.knownBranches
= {}
2818 self
.initialParents
= {}
2820 if self
.importIntoRemotes
:
2821 self
.refPrefix
= "refs/remotes/p4/"
2823 self
.refPrefix
= "refs/heads/p4/"
2825 if self
.syncWithOrigin
:
2826 self
.hasOrigin
= originP4BranchesExist()
2829 print 'Syncing with origin first, using "git fetch origin"'
2830 system("git fetch origin")
2832 branch_arg_given
= bool(self
.branch
)
2833 if len(self
.branch
) == 0:
2834 self
.branch
= self
.refPrefix
+ "master"
2835 if gitBranchExists("refs/heads/p4") and self
.importIntoRemotes
:
2836 system("git update-ref %s refs/heads/p4" % self
.branch
)
2837 system("git branch -D p4")
2839 # accept either the command-line option, or the configuration variable
2840 if self
.useClientSpec
:
2841 # will use this after clone to set the variable
2842 self
.useClientSpec_from_options
= True
2844 if gitConfigBool("git-p4.useclientspec"):
2845 self
.useClientSpec
= True
2846 if self
.useClientSpec
:
2847 self
.clientSpecDirs
= getClientSpec()
2849 # TODO: should always look at previous commits,
2850 # merge with previous imports, if possible.
2853 createOrUpdateBranchesFromOrigin(self
.refPrefix
, self
.silent
)
2855 # branches holds mapping from branch name to sha1
2856 branches
= p4BranchesInGit(self
.importIntoRemotes
)
2858 # restrict to just this one, disabling detect-branches
2859 if branch_arg_given
:
2860 short
= self
.branch
.split("/")[-1]
2861 if short
in branches
:
2862 self
.p4BranchesInGit
= [ short
]
2864 self
.p4BranchesInGit
= branches
.keys()
2866 if len(self
.p4BranchesInGit
) > 1:
2868 print "Importing from/into multiple branches"
2869 self
.detectBranches
= True
2870 for branch
in branches
.keys():
2871 self
.initialParents
[self
.refPrefix
+ branch
] = \
2875 print "branches: %s" % self
.p4BranchesInGit
2878 for branch
in self
.p4BranchesInGit
:
2879 logMsg
= extractLogMessageFromGitCommit(self
.refPrefix
+ branch
)
2881 settings
= extractSettingsGitLog(logMsg
)
2883 self
.readOptions(settings
)
2884 if (settings
.has_key('depot-paths')
2885 and settings
.has_key ('change')):
2886 change
= int(settings
['change']) + 1
2887 p4Change
= max(p4Change
, change
)
2889 depotPaths
= sorted(settings
['depot-paths'])
2890 if self
.previousDepotPaths
== []:
2891 self
.previousDepotPaths
= depotPaths
2894 for (prev
, cur
) in zip(self
.previousDepotPaths
, depotPaths
):
2895 prev_list
= prev
.split("/")
2896 cur_list
= cur
.split("/")
2897 for i
in range(0, min(len(cur_list
), len(prev_list
))):
2898 if cur_list
[i
] <> prev_list
[i
]:
2902 paths
.append ("/".join(cur_list
[:i
+ 1]))
2904 self
.previousDepotPaths
= paths
2907 self
.depotPaths
= sorted(self
.previousDepotPaths
)
2908 self
.changeRange
= "@%s,#head" % p4Change
2909 if not self
.silent
and not self
.detectBranches
:
2910 print "Performing incremental import into %s git branch" % self
.branch
2912 # accept multiple ref name abbreviations:
2913 # refs/foo/bar/branch -> use it exactly
2914 # p4/branch -> prepend refs/remotes/ or refs/heads/
2915 # branch -> prepend refs/remotes/p4/ or refs/heads/p4/
2916 if not self
.branch
.startswith("refs/"):
2917 if self
.importIntoRemotes
:
2918 prepend
= "refs/remotes/"
2920 prepend
= "refs/heads/"
2921 if not self
.branch
.startswith("p4/"):
2923 self
.branch
= prepend
+ self
.branch
2925 if len(args
) == 0 and self
.depotPaths
:
2927 print "Depot paths: %s" % ' '.join(self
.depotPaths
)
2929 if self
.depotPaths
and self
.depotPaths
!= args
:
2930 print ("previous import used depot path %s and now %s was specified. "
2931 "This doesn't work!" % (' '.join (self
.depotPaths
),
2935 self
.depotPaths
= sorted(args
)
2940 # Make sure no revision specifiers are used when --changesfile
2942 bad_changesfile
= False
2943 if len(self
.changesFile
) > 0:
2944 for p
in self
.depotPaths
:
2945 if p
.find("@") >= 0 or p
.find("#") >= 0:
2946 bad_changesfile
= True
2949 die("Option --changesfile is incompatible with revision specifiers")
2952 for p
in self
.depotPaths
:
2953 if p
.find("@") != -1:
2954 atIdx
= p
.index("@")
2955 self
.changeRange
= p
[atIdx
:]
2956 if self
.changeRange
== "@all":
2957 self
.changeRange
= ""
2958 elif ',' not in self
.changeRange
:
2959 revision
= self
.changeRange
2960 self
.changeRange
= ""
2962 elif p
.find("#") != -1:
2963 hashIdx
= p
.index("#")
2964 revision
= p
[hashIdx
:]
2966 elif self
.previousDepotPaths
== []:
2967 # pay attention to changesfile, if given, else import
2968 # the entire p4 tree at the head revision
2969 if len(self
.changesFile
) == 0:
2972 p
= re
.sub ("\.\.\.$", "", p
)
2973 if not p
.endswith("/"):
2978 self
.depotPaths
= newPaths
2980 # --detect-branches may change this for each branch
2981 self
.branchPrefixes
= self
.depotPaths
2983 self
.loadUserMapFromCache()
2985 if self
.detectLabels
:
2988 if self
.detectBranches
:
2989 ## FIXME - what's a P4 projectName ?
2990 self
.projectName
= self
.guessProjectName()
2993 self
.getBranchMappingFromGitBranches()
2995 self
.getBranchMapping()
2997 print "p4-git branches: %s" % self
.p4BranchesInGit
2998 print "initial parents: %s" % self
.initialParents
2999 for b
in self
.p4BranchesInGit
:
3003 b
= b
[len(self
.projectName
):]
3004 self
.createdBranches
.add(b
)
3006 self
.tz
= "%+03d%02d" % (- time
.timezone
/ 3600, ((- time
.timezone
% 3600) / 60))
3008 self
.importProcess
= subprocess
.Popen(["git", "fast-import"],
3009 stdin
=subprocess
.PIPE
,
3010 stdout
=subprocess
.PIPE
,
3011 stderr
=subprocess
.PIPE
);
3012 self
.gitOutput
= self
.importProcess
.stdout
3013 self
.gitStream
= self
.importProcess
.stdin
3014 self
.gitError
= self
.importProcess
.stderr
3017 self
.importHeadRevision(revision
)
3021 if len(self
.changesFile
) > 0:
3022 output
= open(self
.changesFile
).readlines()
3025 changeSet
.add(int(line
))
3027 for change
in changeSet
:
3028 changes
.append(change
)
3032 # catch "git p4 sync" with no new branches, in a repo that
3033 # does not have any existing p4 branches
3035 if not self
.p4BranchesInGit
:
3036 die("No remote p4 branches. Perhaps you never did \"git p4 clone\" in here.")
3038 # The default branch is master, unless --branch is used to
3039 # specify something else. Make sure it exists, or complain
3040 # nicely about how to use --branch.
3041 if not self
.detectBranches
:
3042 if not branch_exists(self
.branch
):
3043 if branch_arg_given
:
3044 die("Error: branch %s does not exist." % self
.branch
)
3046 die("Error: no branch %s; perhaps specify one with --branch." %
3050 print "Getting p4 changes for %s...%s" % (', '.join(self
.depotPaths
),
3052 changes
= p4ChangesForPaths(self
.depotPaths
, self
.changeRange
)
3054 if len(self
.maxChanges
) > 0:
3055 changes
= changes
[:min(int(self
.maxChanges
), len(changes
))]
3057 if len(changes
) == 0:
3059 print "No changes to import!"
3061 if not self
.silent
and not self
.detectBranches
:
3062 print "Import destination: %s" % self
.branch
3064 self
.updatedBranches
= set()
3066 if not self
.detectBranches
:
3068 # start a new branch
3069 self
.initialParent
= ""
3071 # build on a previous revision
3072 self
.initialParent
= parseRevision(self
.branch
)
3074 self
.importChanges(changes
)
3078 if len(self
.updatedBranches
) > 0:
3079 sys
.stdout
.write("Updated branches: ")
3080 for b
in self
.updatedBranches
:
3081 sys
.stdout
.write("%s " % b
)
3082 sys
.stdout
.write("\n")
3084 if gitConfigBool("git-p4.importLabels"):
3085 self
.importLabels
= True
3087 if self
.importLabels
:
3088 p4Labels
= getP4Labels(self
.depotPaths
)
3089 gitTags
= getGitTags()
3091 missingP4Labels
= p4Labels
- gitTags
3092 self
.importP4Labels(self
.gitStream
, missingP4Labels
)
3094 self
.gitStream
.close()
3095 if self
.importProcess
.wait() != 0:
3096 die("fast-import failed: %s" % self
.gitError
.read())
3097 self
.gitOutput
.close()
3098 self
.gitError
.close()
3100 # Cleanup temporary branches created during import
3101 if self
.tempBranches
!= []:
3102 for branch
in self
.tempBranches
:
3103 read_pipe("git update-ref -d %s" % branch
)
3104 os
.rmdir(os
.path
.join(os
.environ
.get("GIT_DIR", ".git"), self
.tempBranchLocation
))
3106 # Create a symbolic ref p4/HEAD pointing to p4/<branch> to allow
3107 # a convenient shortcut refname "p4".
3108 if self
.importIntoRemotes
:
3109 head_ref
= self
.refPrefix
+ "HEAD"
3110 if not gitBranchExists(head_ref
) and gitBranchExists(self
.branch
):
3111 system(["git", "symbolic-ref", head_ref
, self
.branch
])
3115 class P4Rebase(Command
):
3117 Command
.__init
__(self
)
3119 optparse
.make_option("--import-labels", dest
="importLabels", action
="store_true"),
3121 self
.importLabels
= False
3122 self
.description
= ("Fetches the latest revision from perforce and "
3123 + "rebases the current work (branch) against it")
3125 def run(self
, args
):
3127 sync
.importLabels
= self
.importLabels
3130 return self
.rebase()
3133 if os
.system("git update-index --refresh") != 0:
3134 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.");
3135 if len(read_pipe("git diff-index HEAD --")) > 0:
3136 die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
3138 [upstream
, settings
] = findUpstreamBranchPoint()
3139 if len(upstream
) == 0:
3140 die("Cannot find upstream branchpoint for rebase")
3142 # the branchpoint may be p4/foo~3, so strip off the parent
3143 upstream
= re
.sub("~[0-9]+$", "", upstream
)
3145 print "Rebasing the current branch onto %s" % upstream
3146 oldHead
= read_pipe("git rev-parse HEAD").strip()
3147 system("git rebase %s" % upstream
)
3148 system("git diff-tree --stat --summary -M %s HEAD" % oldHead
)
3151 class P4Clone(P4Sync
):
3153 P4Sync
.__init
__(self
)
3154 self
.description
= "Creates a new git repository and imports from Perforce into it"
3155 self
.usage
= "usage: %prog [options] //depot/path[@revRange]"
3157 optparse
.make_option("--destination", dest
="cloneDestination",
3158 action
='store', default
=None,
3159 help="where to leave result of the clone"),
3160 optparse
.make_option("-/", dest
="cloneExclude",
3161 action
="append", type="string",
3162 help="exclude depot path"),
3163 optparse
.make_option("--bare", dest
="cloneBare",
3164 action
="store_true", default
=False),
3166 self
.cloneDestination
= None
3167 self
.needsGit
= False
3168 self
.cloneBare
= False
3170 # This is required for the "append" cloneExclude action
3171 def ensure_value(self
, attr
, value
):
3172 if not hasattr(self
, attr
) or getattr(self
, attr
) is None:
3173 setattr(self
, attr
, value
)
3174 return getattr(self
, attr
)
3176 def defaultDestination(self
, args
):
3177 ## TODO: use common prefix of args?
3179 depotDir
= re
.sub("(@[^@]*)$", "", depotPath
)
3180 depotDir
= re
.sub("(#[^#]*)$", "", depotDir
)
3181 depotDir
= re
.sub(r
"\.\.\.$", "", depotDir
)
3182 depotDir
= re
.sub(r
"/$", "", depotDir
)
3183 return os
.path
.split(depotDir
)[1]
3185 def run(self
, args
):
3189 if self
.keepRepoPath
and not self
.cloneDestination
:
3190 sys
.stderr
.write("Must specify destination for --keep-path\n")
3195 if not self
.cloneDestination
and len(depotPaths
) > 1:
3196 self
.cloneDestination
= depotPaths
[-1]
3197 depotPaths
= depotPaths
[:-1]
3199 self
.cloneExclude
= ["/"+p
for p
in self
.cloneExclude
]
3200 for p
in depotPaths
:
3201 if not p
.startswith("//"):
3202 sys
.stderr
.write('Depot paths must start with "//": %s\n' % p
)
3205 if not self
.cloneDestination
:
3206 self
.cloneDestination
= self
.defaultDestination(args
)
3208 print "Importing from %s into %s" % (', '.join(depotPaths
), self
.cloneDestination
)
3210 if not os
.path
.exists(self
.cloneDestination
):
3211 os
.makedirs(self
.cloneDestination
)
3212 chdir(self
.cloneDestination
)
3214 init_cmd
= [ "git", "init" ]
3216 init_cmd
.append("--bare")
3217 subprocess
.check_call(init_cmd
)
3219 if not P4Sync
.run(self
, depotPaths
):
3222 # create a master branch and check out a work tree
3223 if gitBranchExists(self
.branch
):
3224 system([ "git", "branch", "master", self
.branch
])
3225 if not self
.cloneBare
:
3226 system([ "git", "checkout", "-f" ])
3228 print 'Not checking out any branch, use ' \
3229 '"git checkout -q -b master <branch>"'
3231 # auto-set this variable if invoked with --use-client-spec
3232 if self
.useClientSpec_from_options
:
3233 system("git config --bool git-p4.useclientspec true")
3237 class P4Branches(Command
):
3239 Command
.__init
__(self
)
3241 self
.description
= ("Shows the git branches that hold imports and their "
3242 + "corresponding perforce depot paths")
3243 self
.verbose
= False
3245 def run(self
, args
):
3246 if originP4BranchesExist():
3247 createOrUpdateBranchesFromOrigin()
3249 cmdline
= "git rev-parse --symbolic "
3250 cmdline
+= " --remotes"
3252 for line
in read_pipe_lines(cmdline
):
3255 if not line
.startswith('p4/') or line
== "p4/HEAD":
3259 log
= extractLogMessageFromGitCommit("refs/remotes/%s" % branch
)
3260 settings
= extractSettingsGitLog(log
)
3262 print "%s <= %s (%s)" % (branch
, ",".join(settings
["depot-paths"]), settings
["change"])
3265 class HelpFormatter(optparse
.IndentedHelpFormatter
):
3267 optparse
.IndentedHelpFormatter
.__init
__(self
)
3269 def format_description(self
, description
):
3271 return description
+ "\n"
3275 def printUsage(commands
):
3276 print "usage: %s <command> [options]" % sys
.argv
[0]
3278 print "valid commands: %s" % ", ".join(commands
)
3280 print "Try %s <command> --help for command specific help." % sys
.argv
[0]
3285 "submit" : P4Submit
,
3286 "commit" : P4Submit
,
3288 "rebase" : P4Rebase
,
3290 "rollback" : P4RollBack
,
3291 "branches" : P4Branches
3296 if len(sys
.argv
[1:]) == 0:
3297 printUsage(commands
.keys())
3300 cmdName
= sys
.argv
[1]
3302 klass
= commands
[cmdName
]
3305 print "unknown command %s" % cmdName
3307 printUsage(commands
.keys())
3310 options
= cmd
.options
3311 cmd
.gitdir
= os
.environ
.get("GIT_DIR", None)
3315 options
.append(optparse
.make_option("--verbose", "-v", dest
="verbose", action
="store_true"))
3317 options
.append(optparse
.make_option("--git-dir", dest
="gitdir"))
3319 parser
= optparse
.OptionParser(cmd
.usage
.replace("%prog", "%prog " + cmdName
),
3321 description
= cmd
.description
,
3322 formatter
= HelpFormatter())
3324 (cmd
, args
) = parser
.parse_args(sys
.argv
[2:], cmd
);
3326 verbose
= cmd
.verbose
3328 if cmd
.gitdir
== None:
3329 cmd
.gitdir
= os
.path
.abspath(".git")
3330 if not isValidGitDir(cmd
.gitdir
):
3331 cmd
.gitdir
= read_pipe("git rev-parse --git-dir").strip()
3332 if os
.path
.exists(cmd
.gitdir
):
3333 cdup
= read_pipe("git rev-parse --show-cdup").strip()
3337 if not isValidGitDir(cmd
.gitdir
):
3338 if isValidGitDir(cmd
.gitdir
+ "/.git"):
3339 cmd
.gitdir
+= "/.git"
3341 die("fatal: cannot locate git repository at %s" % cmd
.gitdir
)
3343 os
.environ
["GIT_DIR"] = cmd
.gitdir
3345 if not cmd
.run(args
):
3350 if __name__
== '__main__':