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")
27 # Only labels/tags matching this will be imported/exported
28 defaultLabelRegexp
= r
'[a-zA-Z0-9_\-.]+$'
30 def p4_build_cmd(cmd
):
31 """Build a suitable p4 command line.
33 This consolidates building and returning a p4 command line into one
34 location. It means that hooking into the environment, or other configuration
35 can be done more easily.
39 user
= gitConfig("git-p4.user")
41 real_cmd
+= ["-u",user
]
43 password
= gitConfig("git-p4.password")
45 real_cmd
+= ["-P", password
]
47 port
= gitConfig("git-p4.port")
49 real_cmd
+= ["-p", port
]
51 host
= gitConfig("git-p4.host")
53 real_cmd
+= ["-H", host
]
55 client
= gitConfig("git-p4.client")
57 real_cmd
+= ["-c", client
]
60 if isinstance(cmd
,basestring
):
61 real_cmd
= ' '.join(real_cmd
) + ' ' + cmd
67 # P4 uses the PWD environment variable rather than getcwd(). Since we're
68 # not using the shell, we have to set it ourselves. This path could
69 # be relative, so go there first, then figure out where we ended up.
71 os
.environ
['PWD'] = os
.getcwd()
77 sys
.stderr
.write(msg
+ "\n")
80 def write_pipe(c
, stdin
):
82 sys
.stderr
.write('Writing pipe: %s\n' % str(c
))
84 expand
= isinstance(c
,basestring
)
85 p
= subprocess
.Popen(c
, stdin
=subprocess
.PIPE
, shell
=expand
)
87 val
= pipe
.write(stdin
)
90 die('Command failed: %s' % str(c
))
94 def p4_write_pipe(c
, stdin
):
95 real_cmd
= p4_build_cmd(c
)
96 return write_pipe(real_cmd
, stdin
)
98 def read_pipe(c
, ignore_error
=False):
100 sys
.stderr
.write('Reading pipe: %s\n' % str(c
))
102 expand
= isinstance(c
,basestring
)
103 p
= subprocess
.Popen(c
, stdout
=subprocess
.PIPE
, shell
=expand
)
106 if p
.wait() and not ignore_error
:
107 die('Command failed: %s' % str(c
))
111 def p4_read_pipe(c
, ignore_error
=False):
112 real_cmd
= p4_build_cmd(c
)
113 return read_pipe(real_cmd
, ignore_error
)
115 def read_pipe_lines(c
):
117 sys
.stderr
.write('Reading pipe: %s\n' % str(c
))
119 expand
= isinstance(c
, basestring
)
120 p
= subprocess
.Popen(c
, stdout
=subprocess
.PIPE
, shell
=expand
)
122 val
= pipe
.readlines()
123 if pipe
.close() or p
.wait():
124 die('Command failed: %s' % str(c
))
128 def p4_read_pipe_lines(c
):
129 """Specifically invoke p4 on the command supplied. """
130 real_cmd
= p4_build_cmd(c
)
131 return read_pipe_lines(real_cmd
)
133 def p4_has_command(cmd
):
134 """Ask p4 for help on this command. If it returns an error, the
135 command does not exist in this version of p4."""
136 real_cmd
= p4_build_cmd(["help", cmd
])
137 p
= subprocess
.Popen(real_cmd
, stdout
=subprocess
.PIPE
,
138 stderr
=subprocess
.PIPE
)
140 return p
.returncode
== 0
142 def p4_has_move_command():
143 """See if the move command exists, that it supports -k, and that
144 it has not been administratively disabled. The arguments
145 must be correct, but the filenames do not have to exist. Use
146 ones with wildcards so even if they exist, it will fail."""
148 if not p4_has_command("move"):
150 cmd
= p4_build_cmd(["move", "-k", "@from", "@to"])
151 p
= subprocess
.Popen(cmd
, stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
)
152 (out
, err
) = p
.communicate()
153 # return code will be 1 in either case
154 if err
.find("Invalid option") >= 0:
156 if err
.find("disabled") >= 0:
158 # assume it failed because @... was invalid changelist
162 expand
= isinstance(cmd
,basestring
)
164 sys
.stderr
.write("executing %s\n" % str(cmd
))
165 subprocess
.check_call(cmd
, shell
=expand
)
168 """Specifically invoke p4 as the system command. """
169 real_cmd
= p4_build_cmd(cmd
)
170 expand
= isinstance(real_cmd
, basestring
)
171 subprocess
.check_call(real_cmd
, shell
=expand
)
173 def p4_integrate(src
, dest
):
174 p4_system(["integrate", "-Dt", wildcard_encode(src
), wildcard_encode(dest
)])
176 def p4_sync(f
, *options
):
177 p4_system(["sync"] + list(options
) + [wildcard_encode(f
)])
180 # forcibly add file names with wildcards
181 if wildcard_present(f
):
182 p4_system(["add", "-f", f
])
184 p4_system(["add", f
])
187 p4_system(["delete", wildcard_encode(f
)])
190 p4_system(["edit", wildcard_encode(f
)])
193 p4_system(["revert", wildcard_encode(f
)])
195 def p4_reopen(type, f
):
196 p4_system(["reopen", "-t", type, wildcard_encode(f
)])
198 def p4_move(src
, dest
):
199 p4_system(["move", "-k", wildcard_encode(src
), wildcard_encode(dest
)])
201 def p4_describe(change
):
202 """Make sure it returns a valid result by checking for
203 the presence of field "time". Return a dict of the
206 ds
= p4CmdList(["describe", "-s", str(change
)])
208 die("p4 describe -s %d did not return 1 result: %s" % (change
, str(ds
)))
212 if "p4ExitCode" in d
:
213 die("p4 describe -s %d exited with %d: %s" % (change
, d
["p4ExitCode"],
216 if d
["code"] == "error":
217 die("p4 describe -s %d returned error code: %s" % (change
, str(d
)))
220 die("p4 describe -s %d returned no \"time\": %s" % (change
, str(d
)))
225 # Canonicalize the p4 type and return a tuple of the
226 # base type, plus any modifiers. See "p4 help filetypes"
227 # for a list and explanation.
229 def split_p4_type(p4type
):
231 p4_filetypes_historical
= {
232 "ctempobj": "binary+Sw",
238 "tempobj": "binary+FSw",
239 "ubinary": "binary+F",
240 "uresource": "resource+F",
241 "uxbinary": "binary+Fx",
242 "xbinary": "binary+x",
244 "xtempobj": "binary+Swx",
246 "xunicode": "unicode+x",
249 if p4type
in p4_filetypes_historical
:
250 p4type
= p4_filetypes_historical
[p4type
]
252 s
= p4type
.split("+")
260 # return the raw p4 type of a file (text, text+ko, etc)
263 results
= p4CmdList(["fstat", "-T", "headType", file])
264 return results
[0]['headType']
267 # Given a type base and modifier, return a regexp matching
268 # the keywords that can be expanded in the file
270 def p4_keywords_regexp_for_type(base
, type_mods
):
271 if base
in ("text", "unicode", "binary"):
273 if "ko" in type_mods
:
275 elif "k" in type_mods
:
276 kwords
= 'Id|Header|Author|Date|DateTime|Change|File|Revision'
280 \$ # Starts with a dollar, followed by...
281 (%s) # one of the keywords, followed by...
282 (:[^$\n]+)? # possibly an old expansion, followed by...
290 # Given a file, return a regexp matching the possible
291 # RCS keywords that will be expanded, or None for files
292 # with kw expansion turned off.
294 def p4_keywords_regexp_for_file(file):
295 if not os
.path
.exists(file):
298 (type_base
, type_mods
) = split_p4_type(p4_type(file))
299 return p4_keywords_regexp_for_type(type_base
, type_mods
)
301 def setP4ExecBit(file, mode
):
302 # Reopens an already open file and changes the execute bit to match
303 # the execute bit setting in the passed in mode.
307 if not isModeExec(mode
):
308 p4Type
= getP4OpenedType(file)
309 p4Type
= re
.sub('^([cku]?)x(.*)', '\\1\\2', p4Type
)
310 p4Type
= re
.sub('(.*?\+.*?)x(.*?)', '\\1\\2', p4Type
)
311 if p4Type
[-1] == "+":
312 p4Type
= p4Type
[0:-1]
314 p4_reopen(p4Type
, file)
316 def getP4OpenedType(file):
317 # Returns the perforce file type for the given file.
319 result
= p4_read_pipe(["opened", wildcard_encode(file)])
320 match
= re
.match(".*\((.+)\)\r?$", result
)
322 return match
.group(1)
324 die("Could not determine file type for %s (result: '%s')" % (file, result
))
326 # Return the set of all p4 labels
327 def getP4Labels(depotPaths
):
329 if isinstance(depotPaths
,basestring
):
330 depotPaths
= [depotPaths
]
332 for l
in p4CmdList(["labels"] + ["%s..." % p
for p
in depotPaths
]):
338 # Return the set of all git tags
341 for line
in read_pipe_lines(["git", "tag"]):
346 def diffTreePattern():
347 # This is a simple generator for the diff tree regex pattern. This could be
348 # a class variable if this and parseDiffTreeEntry were a part of a class.
349 pattern
= re
.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)')
353 def parseDiffTreeEntry(entry
):
354 """Parses a single diff tree entry into its component elements.
356 See git-diff-tree(1) manpage for details about the format of the diff
357 output. This method returns a dictionary with the following elements:
359 src_mode - The mode of the source file
360 dst_mode - The mode of the destination file
361 src_sha1 - The sha1 for the source file
362 dst_sha1 - The sha1 fr the destination file
363 status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc)
364 status_score - The score for the status (applicable for 'C' and 'R'
365 statuses). This is None if there is no score.
366 src - The path for the source file.
367 dst - The path for the destination file. This is only present for
368 copy or renames. If it is not present, this is None.
370 If the pattern is not matched, None is returned."""
372 match
= diffTreePattern().next().match(entry
)
375 'src_mode': match
.group(1),
376 'dst_mode': match
.group(2),
377 'src_sha1': match
.group(3),
378 'dst_sha1': match
.group(4),
379 'status': match
.group(5),
380 'status_score': match
.group(6),
381 'src': match
.group(7),
382 'dst': match
.group(10)
386 def isModeExec(mode
):
387 # Returns True if the given git mode represents an executable file,
389 return mode
[-3:] == "755"
391 def isModeExecChanged(src_mode
, dst_mode
):
392 return isModeExec(src_mode
) != isModeExec(dst_mode
)
394 def p4CmdList(cmd
, stdin
=None, stdin_mode
='w+b', cb
=None):
396 if isinstance(cmd
,basestring
):
403 cmd
= p4_build_cmd(cmd
)
405 sys
.stderr
.write("Opening pipe: %s\n" % str(cmd
))
407 # Use a temporary file to avoid deadlocks without
408 # subprocess.communicate(), which would put another copy
409 # of stdout into memory.
411 if stdin
is not None:
412 stdin_file
= tempfile
.TemporaryFile(prefix
='p4-stdin', mode
=stdin_mode
)
413 if isinstance(stdin
,basestring
):
414 stdin_file
.write(stdin
)
417 stdin_file
.write(i
+ '\n')
421 p4
= subprocess
.Popen(cmd
,
424 stdout
=subprocess
.PIPE
)
429 entry
= marshal
.load(p4
.stdout
)
439 entry
["p4ExitCode"] = exitCode
445 list = p4CmdList(cmd
)
451 def p4Where(depotPath
):
452 if not depotPath
.endswith("/"):
454 depotPath
= depotPath
+ "..."
455 outputList
= p4CmdList(["where", depotPath
])
457 for entry
in outputList
:
458 if "depotFile" in entry
:
459 if entry
["depotFile"] == depotPath
:
462 elif "data" in entry
:
463 data
= entry
.get("data")
464 space
= data
.find(" ")
465 if data
[:space
] == depotPath
:
470 if output
["code"] == "error":
474 clientPath
= output
.get("path")
475 elif "data" in output
:
476 data
= output
.get("data")
477 lastSpace
= data
.rfind(" ")
478 clientPath
= data
[lastSpace
+ 1:]
480 if clientPath
.endswith("..."):
481 clientPath
= clientPath
[:-3]
484 def currentGitBranch():
485 return read_pipe("git name-rev HEAD").split(" ")[1].strip()
487 def isValidGitDir(path
):
488 if (os
.path
.exists(path
+ "/HEAD")
489 and os
.path
.exists(path
+ "/refs") and os
.path
.exists(path
+ "/objects")):
493 def parseRevision(ref
):
494 return read_pipe("git rev-parse %s" % ref
).strip()
496 def branchExists(ref
):
497 rev
= read_pipe(["git", "rev-parse", "-q", "--verify", ref
],
501 def extractLogMessageFromGitCommit(commit
):
504 ## fixme: title is first line of commit, not 1st paragraph.
506 for log
in read_pipe_lines("git cat-file commit %s" % commit
):
515 def extractSettingsGitLog(log
):
517 for line
in log
.split("\n"):
519 m
= re
.search (r
"^ *\[git-p4: (.*)\]$", line
)
523 assignments
= m
.group(1).split (':')
524 for a
in assignments
:
526 key
= vals
[0].strip()
527 val
= ('='.join (vals
[1:])).strip()
528 if val
.endswith ('\"') and val
.startswith('"'):
533 paths
= values
.get("depot-paths")
535 paths
= values
.get("depot-path")
537 values
['depot-paths'] = paths
.split(',')
540 def gitBranchExists(branch
):
541 proc
= subprocess
.Popen(["git", "rev-parse", branch
],
542 stderr
=subprocess
.PIPE
, stdout
=subprocess
.PIPE
);
543 return proc
.wait() == 0;
546 def gitConfig(key
, args
= None): # set args to "--bool", for instance
547 if not _gitConfig
.has_key(key
):
550 argsFilter
= "%s " % args
551 cmd
= "git config %s%s" % (argsFilter
, key
)
552 _gitConfig
[key
] = read_pipe(cmd
, ignore_error
=True).strip()
553 return _gitConfig
[key
]
555 def gitConfigList(key
):
556 if not _gitConfig
.has_key(key
):
557 _gitConfig
[key
] = read_pipe("git config --get-all %s" % key
, ignore_error
=True).strip().split(os
.linesep
)
558 return _gitConfig
[key
]
560 def p4BranchesInGit(branchesAreInRemotes
=True):
561 """Find all the branches whose names start with "p4/", looking
562 in remotes or heads as specified by the argument. Return
563 a dictionary of { branch: revision } for each one found.
564 The branch names are the short names, without any
569 cmdline
= "git rev-parse --symbolic "
570 if branchesAreInRemotes
:
571 cmdline
+= "--remotes"
573 cmdline
+= "--branches"
575 for line
in read_pipe_lines(cmdline
):
579 if not line
.startswith('p4/'):
581 # special symbolic ref to p4/master
582 if line
== "p4/HEAD":
585 # strip off p4/ prefix
586 branch
= line
[len("p4/"):]
588 branches
[branch
] = parseRevision(line
)
592 def branch_exists(branch
):
593 """Make sure that the given ref name really exists."""
595 cmd
= [ "git", "rev-parse", "--symbolic", "--verify", branch
]
596 p
= subprocess
.Popen(cmd
, stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
)
597 out
, _
= p
.communicate()
600 # expect exactly one line of output: the branch name
601 return out
.rstrip() == branch
603 def findUpstreamBranchPoint(head
= "HEAD"):
604 branches
= p4BranchesInGit()
605 # map from depot-path to branch name
606 branchByDepotPath
= {}
607 for branch
in branches
.keys():
608 tip
= branches
[branch
]
609 log
= extractLogMessageFromGitCommit(tip
)
610 settings
= extractSettingsGitLog(log
)
611 if settings
.has_key("depot-paths"):
612 paths
= ",".join(settings
["depot-paths"])
613 branchByDepotPath
[paths
] = "remotes/p4/" + branch
617 while parent
< 65535:
618 commit
= head
+ "~%s" % parent
619 log
= extractLogMessageFromGitCommit(commit
)
620 settings
= extractSettingsGitLog(log
)
621 if settings
.has_key("depot-paths"):
622 paths
= ",".join(settings
["depot-paths"])
623 if branchByDepotPath
.has_key(paths
):
624 return [branchByDepotPath
[paths
], settings
]
628 return ["", settings
]
630 def createOrUpdateBranchesFromOrigin(localRefPrefix
= "refs/remotes/p4/", silent
=True):
632 print ("Creating/updating branch(es) in %s based on origin branch(es)"
635 originPrefix
= "origin/p4/"
637 for line
in read_pipe_lines("git rev-parse --symbolic --remotes"):
639 if (not line
.startswith(originPrefix
)) or line
.endswith("HEAD"):
642 headName
= line
[len(originPrefix
):]
643 remoteHead
= localRefPrefix
+ headName
646 original
= extractSettingsGitLog(extractLogMessageFromGitCommit(originHead
))
647 if (not original
.has_key('depot-paths')
648 or not original
.has_key('change')):
652 if not gitBranchExists(remoteHead
):
654 print "creating %s" % remoteHead
657 settings
= extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead
))
658 if settings
.has_key('change') > 0:
659 if settings
['depot-paths'] == original
['depot-paths']:
660 originP4Change
= int(original
['change'])
661 p4Change
= int(settings
['change'])
662 if originP4Change
> p4Change
:
663 print ("%s (%s) is newer than %s (%s). "
664 "Updating p4 branch from origin."
665 % (originHead
, originP4Change
,
666 remoteHead
, p4Change
))
669 print ("Ignoring: %s was imported from %s while "
670 "%s was imported from %s"
671 % (originHead
, ','.join(original
['depot-paths']),
672 remoteHead
, ','.join(settings
['depot-paths'])))
675 system("git update-ref %s %s" % (remoteHead
, originHead
))
677 def originP4BranchesExist():
678 return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
680 def p4ChangesForPaths(depotPaths
, changeRange
):
684 cmd
+= ["%s...%s" % (p
, changeRange
)]
685 output
= p4_read_pipe_lines(cmd
)
689 changeNum
= int(line
.split(" ")[1])
690 changes
[changeNum
] = True
692 changelist
= changes
.keys()
696 def p4PathStartsWith(path
, prefix
):
697 # This method tries to remedy a potential mixed-case issue:
699 # If UserA adds //depot/DirA/file1
700 # and UserB adds //depot/dira/file2
702 # we may or may not have a problem. If you have core.ignorecase=true,
703 # we treat DirA and dira as the same directory
704 ignorecase
= gitConfig("core.ignorecase", "--bool") == "true"
706 return path
.lower().startswith(prefix
.lower())
707 return path
.startswith(prefix
)
710 """Look at the p4 client spec, create a View() object that contains
711 all the mappings, and return it."""
713 specList
= p4CmdList("client -o")
714 if len(specList
) != 1:
715 die('Output from "client -o" is %d lines, expecting 1' %
718 # dictionary of all client parameters
721 # just the keys that start with "View"
722 view_keys
= [ k
for k
in entry
.keys() if k
.startswith("View") ]
727 # append the lines, in order, to the view
728 for view_num
in range(len(view_keys
)):
729 k
= "View%d" % view_num
730 if k
not in view_keys
:
731 die("Expected view key %s missing" % k
)
732 view
.append(entry
[k
])
737 """Grab the client directory."""
739 output
= p4CmdList("client -o")
741 die('Output from "client -o" is %d lines, expecting 1' % len(output
))
744 if "Root" not in entry
:
745 die('Client has no "Root"')
750 # P4 wildcards are not allowed in filenames. P4 complains
751 # if you simply add them, but you can force it with "-f", in
752 # which case it translates them into %xx encoding internally.
754 def wildcard_decode(path
):
755 # Search for and fix just these four characters. Do % last so
756 # that fixing it does not inadvertently create new %-escapes.
757 # Cannot have * in a filename in windows; untested as to
758 # what p4 would do in such a case.
759 if not platform
.system() == "Windows":
760 path
= path
.replace("%2A", "*")
761 path
= path
.replace("%23", "#") \
762 .replace("%40", "@") \
766 def wildcard_encode(path
):
767 # do % first to avoid double-encoding the %s introduced here
768 path
= path
.replace("%", "%25") \
769 .replace("*", "%2A") \
770 .replace("#", "%23") \
774 def wildcard_present(path
):
775 return path
.translate(None, "*#@%") != path
779 self
.usage
= "usage: %prog [options]"
785 self
.userMapFromPerforceServer
= False
786 self
.myP4UserId
= None
790 return self
.myP4UserId
792 results
= p4CmdList("user -o")
794 if r
.has_key('User'):
795 self
.myP4UserId
= r
['User']
797 die("Could not find your p4 user id")
799 def p4UserIsMe(self
, p4User
):
800 # return True if the given p4 user is actually me
802 if not p4User
or p4User
!= me
:
807 def getUserCacheFilename(self
):
808 home
= os
.environ
.get("HOME", os
.environ
.get("USERPROFILE"))
809 return home
+ "/.gitp4-usercache.txt"
811 def getUserMapFromPerforceServer(self
):
812 if self
.userMapFromPerforceServer
:
817 for output
in p4CmdList("users"):
818 if not output
.has_key("User"):
820 self
.users
[output
["User"]] = output
["FullName"] + " <" + output
["Email"] + ">"
821 self
.emails
[output
["Email"]] = output
["User"]
825 for (key
, val
) in self
.users
.items():
826 s
+= "%s\t%s\n" % (key
.expandtabs(1), val
.expandtabs(1))
828 open(self
.getUserCacheFilename(), "wb").write(s
)
829 self
.userMapFromPerforceServer
= True
831 def loadUserMapFromCache(self
):
833 self
.userMapFromPerforceServer
= False
835 cache
= open(self
.getUserCacheFilename(), "rb")
836 lines
= cache
.readlines()
839 entry
= line
.strip().split("\t")
840 self
.users
[entry
[0]] = entry
[1]
842 self
.getUserMapFromPerforceServer()
844 class P4Debug(Command
):
846 Command
.__init
__(self
)
848 self
.description
= "A tool to debug the output of p4 -G."
849 self
.needsGit
= False
853 for output
in p4CmdList(args
):
854 print 'Element: %d' % j
859 class P4RollBack(Command
):
861 Command
.__init
__(self
)
863 optparse
.make_option("--local", dest
="rollbackLocalBranches", action
="store_true")
865 self
.description
= "A tool to debug the multi-branch import. Don't use :)"
866 self
.rollbackLocalBranches
= False
871 maxChange
= int(args
[0])
873 if "p4ExitCode" in p4Cmd("changes -m 1"):
874 die("Problems executing p4");
876 if self
.rollbackLocalBranches
:
877 refPrefix
= "refs/heads/"
878 lines
= read_pipe_lines("git rev-parse --symbolic --branches")
880 refPrefix
= "refs/remotes/"
881 lines
= read_pipe_lines("git rev-parse --symbolic --remotes")
884 if self
.rollbackLocalBranches
or (line
.startswith("p4/") and line
!= "p4/HEAD\n"):
886 ref
= refPrefix
+ line
887 log
= extractLogMessageFromGitCommit(ref
)
888 settings
= extractSettingsGitLog(log
)
890 depotPaths
= settings
['depot-paths']
891 change
= settings
['change']
895 if len(p4Cmd("changes -m 1 " + ' '.join (['%s...@%s' % (p
, maxChange
)
896 for p
in depotPaths
]))) == 0:
897 print "Branch %s did not exist at change %s, deleting." % (ref
, maxChange
)
898 system("git update-ref -d %s `git rev-parse %s`" % (ref
, ref
))
901 while change
and int(change
) > maxChange
:
904 print "%s is at %s ; rewinding towards %s" % (ref
, change
, maxChange
)
905 system("git update-ref %s \"%s^\"" % (ref
, ref
))
906 log
= extractLogMessageFromGitCommit(ref
)
907 settings
= extractSettingsGitLog(log
)
910 depotPaths
= settings
['depot-paths']
911 change
= settings
['change']
914 print "%s rewound to %s" % (ref
, change
)
918 class P4Submit(Command
, P4UserMap
):
920 conflict_behavior_choices
= ("ask", "skip", "quit")
923 Command
.__init
__(self
)
924 P4UserMap
.__init
__(self
)
926 optparse
.make_option("--origin", dest
="origin"),
927 optparse
.make_option("-M", dest
="detectRenames", action
="store_true"),
928 # preserve the user, requires relevant p4 permissions
929 optparse
.make_option("--preserve-user", dest
="preserveUser", action
="store_true"),
930 optparse
.make_option("--export-labels", dest
="exportLabels", action
="store_true"),
931 optparse
.make_option("--dry-run", "-n", dest
="dry_run", action
="store_true"),
932 optparse
.make_option("--prepare-p4-only", dest
="prepare_p4_only", action
="store_true"),
933 optparse
.make_option("--conflict", dest
="conflict_behavior",
934 choices
=self
.conflict_behavior_choices
),
935 optparse
.make_option("--branch", dest
="branch"),
937 self
.description
= "Submit changes from git to the perforce depot."
938 self
.usage
+= " [name of git branch to submit into perforce depot]"
940 self
.detectRenames
= False
941 self
.preserveUser
= gitConfig("git-p4.preserveUser").lower() == "true"
943 self
.prepare_p4_only
= False
944 self
.conflict_behavior
= None
945 self
.isWindows
= (platform
.system() == "Windows")
946 self
.exportLabels
= False
947 self
.p4HasMoveCommand
= p4_has_move_command()
951 if len(p4CmdList("opened ...")) > 0:
952 die("You have files opened with perforce! Close them before starting the sync.")
954 def separate_jobs_from_description(self
, message
):
955 """Extract and return a possible Jobs field in the commit
956 message. It goes into a separate section in the p4 change
959 A jobs line starts with "Jobs:" and looks like a new field
960 in a form. Values are white-space separated on the same
961 line or on following lines that start with a tab.
963 This does not parse and extract the full git commit message
964 like a p4 form. It just sees the Jobs: line as a marker
965 to pass everything from then on directly into the p4 form,
966 but outside the description section.
968 Return a tuple (stripped log message, jobs string)."""
970 m
= re
.search(r
'^Jobs:', message
, re
.MULTILINE
)
972 return (message
, None)
974 jobtext
= message
[m
.start():]
975 stripped_message
= message
[:m
.start()].rstrip()
976 return (stripped_message
, jobtext
)
978 def prepareLogMessage(self
, template
, message
, jobs
):
979 """Edits the template returned from "p4 change -o" to insert
980 the message in the Description field, and the jobs text in
984 inDescriptionSection
= False
986 for line
in template
.split("\n"):
987 if line
.startswith("#"):
988 result
+= line
+ "\n"
991 if inDescriptionSection
:
992 if line
.startswith("Files:") or line
.startswith("Jobs:"):
993 inDescriptionSection
= False
994 # insert Jobs section
996 result
+= jobs
+ "\n"
1000 if line
.startswith("Description:"):
1001 inDescriptionSection
= True
1003 for messageLine
in message
.split("\n"):
1004 line
+= "\t" + messageLine
+ "\n"
1006 result
+= line
+ "\n"
1010 def patchRCSKeywords(self
, file, pattern
):
1011 # Attempt to zap the RCS keywords in a p4 controlled file matching the given pattern
1012 (handle
, outFileName
) = tempfile
.mkstemp(dir='.')
1014 outFile
= os
.fdopen(handle
, "w+")
1015 inFile
= open(file, "r")
1016 regexp
= re
.compile(pattern
, re
.VERBOSE
)
1017 for line
in inFile
.readlines():
1018 line
= regexp
.sub(r
'$\1$', line
)
1022 # Forcibly overwrite the original file
1024 shutil
.move(outFileName
, file)
1026 # cleanup our temporary file
1027 os
.unlink(outFileName
)
1028 print "Failed to strip RCS keywords in %s" % file
1031 print "Patched up RCS keywords in %s" % file
1033 def p4UserForCommit(self
,id):
1034 # Return the tuple (perforce user,git email) for a given git commit id
1035 self
.getUserMapFromPerforceServer()
1036 gitEmail
= read_pipe("git log --max-count=1 --format='%%ae' %s" % id)
1037 gitEmail
= gitEmail
.strip()
1038 if not self
.emails
.has_key(gitEmail
):
1039 return (None,gitEmail
)
1041 return (self
.emails
[gitEmail
],gitEmail
)
1043 def checkValidP4Users(self
,commits
):
1044 # check if any git authors cannot be mapped to p4 users
1046 (user
,email
) = self
.p4UserForCommit(id)
1048 msg
= "Cannot find p4 user for email %s in commit %s." % (email
, id)
1049 if gitConfig('git-p4.allowMissingP4Users').lower() == "true":
1052 die("Error: %s\nSet git-p4.allowMissingP4Users to true to allow this." % msg
)
1054 def lastP4Changelist(self
):
1055 # Get back the last changelist number submitted in this client spec. This
1056 # then gets used to patch up the username in the change. If the same
1057 # client spec is being used by multiple processes then this might go
1059 results
= p4CmdList("client -o") # find the current client
1062 if r
.has_key('Client'):
1063 client
= r
['Client']
1066 die("could not get client spec")
1067 results
= p4CmdList(["changes", "-c", client
, "-m", "1"])
1069 if r
.has_key('change'):
1071 die("Could not get changelist number for last submit - cannot patch up user details")
1073 def modifyChangelistUser(self
, changelist
, newUser
):
1074 # fixup the user field of a changelist after it has been submitted.
1075 changes
= p4CmdList("change -o %s" % changelist
)
1076 if len(changes
) != 1:
1077 die("Bad output from p4 change modifying %s to user %s" %
1078 (changelist
, newUser
))
1081 if c
['User'] == newUser
: return # nothing to do
1083 input = marshal
.dumps(c
)
1085 result
= p4CmdList("change -f -i", stdin
=input)
1087 if r
.has_key('code'):
1088 if r
['code'] == 'error':
1089 die("Could not modify user field of changelist %s to %s:%s" % (changelist
, newUser
, r
['data']))
1090 if r
.has_key('data'):
1091 print("Updated user field for changelist %s to %s" % (changelist
, newUser
))
1093 die("Could not modify user field of changelist %s to %s" % (changelist
, newUser
))
1095 def canChangeChangelists(self
):
1096 # check to see if we have p4 admin or super-user permissions, either of
1097 # which are required to modify changelists.
1098 results
= p4CmdList(["protects", self
.depotPath
])
1100 if r
.has_key('perm'):
1101 if r
['perm'] == 'admin':
1103 if r
['perm'] == 'super':
1107 def prepareSubmitTemplate(self
):
1108 """Run "p4 change -o" to grab a change specification template.
1109 This does not use "p4 -G", as it is nice to keep the submission
1110 template in original order, since a human might edit it.
1112 Remove lines in the Files section that show changes to files
1113 outside the depot path we're committing into."""
1116 inFilesSection
= False
1117 for line
in p4_read_pipe_lines(['change', '-o']):
1118 if line
.endswith("\r\n"):
1119 line
= line
[:-2] + "\n"
1121 if line
.startswith("\t"):
1122 # path starts and ends with a tab
1124 lastTab
= path
.rfind("\t")
1126 path
= path
[:lastTab
]
1127 if not p4PathStartsWith(path
, self
.depotPath
):
1130 inFilesSection
= False
1132 if line
.startswith("Files:"):
1133 inFilesSection
= True
1139 def edit_template(self
, template_file
):
1140 """Invoke the editor to let the user change the submission
1141 message. Return true if okay to continue with the submit."""
1143 # if configured to skip the editing part, just submit
1144 if gitConfig("git-p4.skipSubmitEdit") == "true":
1147 # look at the modification time, to check later if the user saved
1149 mtime
= os
.stat(template_file
).st_mtime
1152 if os
.environ
.has_key("P4EDITOR") and (os
.environ
.get("P4EDITOR") != ""):
1153 editor
= os
.environ
.get("P4EDITOR")
1155 editor
= read_pipe("git var GIT_EDITOR").strip()
1156 system(editor
+ " " + template_file
)
1158 # If the file was not saved, prompt to see if this patch should
1159 # be skipped. But skip this verification step if configured so.
1160 if gitConfig("git-p4.skipSubmitEditCheck") == "true":
1163 # modification time updated means user saved the file
1164 if os
.stat(template_file
).st_mtime
> mtime
:
1168 response
= raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")
1174 def applyCommit(self
, id):
1175 """Apply one commit, return True if it succeeded."""
1177 print "Applying", read_pipe(["git", "show", "-s",
1178 "--format=format:%h %s", id])
1180 (p4User
, gitEmail
) = self
.p4UserForCommit(id)
1182 diff
= read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (self
.diffOpts
, id, id))
1184 filesToDelete
= set()
1186 pureRenameCopy
= set()
1187 filesToChangeExecBit
= {}
1190 diff
= parseDiffTreeEntry(line
)
1191 modifier
= diff
['status']
1195 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
1196 filesToChangeExecBit
[path
] = diff
['dst_mode']
1197 editedFiles
.add(path
)
1198 elif modifier
== "A":
1199 filesToAdd
.add(path
)
1200 filesToChangeExecBit
[path
] = diff
['dst_mode']
1201 if path
in filesToDelete
:
1202 filesToDelete
.remove(path
)
1203 elif modifier
== "D":
1204 filesToDelete
.add(path
)
1205 if path
in filesToAdd
:
1206 filesToAdd
.remove(path
)
1207 elif modifier
== "C":
1208 src
, dest
= diff
['src'], diff
['dst']
1209 p4_integrate(src
, dest
)
1210 pureRenameCopy
.add(dest
)
1211 if diff
['src_sha1'] != diff
['dst_sha1']:
1213 pureRenameCopy
.discard(dest
)
1214 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
1216 pureRenameCopy
.discard(dest
)
1217 filesToChangeExecBit
[dest
] = diff
['dst_mode']
1219 editedFiles
.add(dest
)
1220 elif modifier
== "R":
1221 src
, dest
= diff
['src'], diff
['dst']
1222 if self
.p4HasMoveCommand
:
1223 p4_edit(src
) # src must be open before move
1224 p4_move(src
, dest
) # opens for (move/delete, move/add)
1226 p4_integrate(src
, dest
)
1227 if diff
['src_sha1'] != diff
['dst_sha1']:
1230 pureRenameCopy
.add(dest
)
1231 if isModeExecChanged(diff
['src_mode'], diff
['dst_mode']):
1232 if not self
.p4HasMoveCommand
:
1233 p4_edit(dest
) # with move: already open, writable
1234 filesToChangeExecBit
[dest
] = diff
['dst_mode']
1235 if not self
.p4HasMoveCommand
:
1237 filesToDelete
.add(src
)
1238 editedFiles
.add(dest
)
1240 die("unknown modifier %s for %s" % (modifier
, path
))
1242 diffcmd
= "git format-patch -k --stdout \"%s^\"..\"%s\"" % (id, id)
1243 patchcmd
= diffcmd
+ " | git apply "
1244 tryPatchCmd
= patchcmd
+ "--check -"
1245 applyPatchCmd
= patchcmd
+ "--check --apply -"
1246 patch_succeeded
= True
1248 if os
.system(tryPatchCmd
) != 0:
1249 fixed_rcs_keywords
= False
1250 patch_succeeded
= False
1251 print "Unfortunately applying the change failed!"
1253 # Patch failed, maybe it's just RCS keyword woes. Look through
1254 # the patch to see if that's possible.
1255 if gitConfig("git-p4.attemptRCSCleanup","--bool") == "true":
1259 for file in editedFiles | filesToDelete
:
1260 # did this file's delta contain RCS keywords?
1261 pattern
= p4_keywords_regexp_for_file(file)
1264 # this file is a possibility...look for RCS keywords.
1265 regexp
= re
.compile(pattern
, re
.VERBOSE
)
1266 for line
in read_pipe_lines(["git", "diff", "%s^..%s" % (id, id), file]):
1267 if regexp
.search(line
):
1269 print "got keyword match on %s in %s in %s" % (pattern
, line
, file)
1270 kwfiles
[file] = pattern
1273 for file in kwfiles
:
1275 print "zapping %s with %s" % (line
,pattern
)
1276 self
.patchRCSKeywords(file, kwfiles
[file])
1277 fixed_rcs_keywords
= True
1279 if fixed_rcs_keywords
:
1280 print "Retrying the patch with RCS keywords cleaned up"
1281 if os
.system(tryPatchCmd
) == 0:
1282 patch_succeeded
= True
1284 if not patch_succeeded
:
1285 for f
in editedFiles
:
1290 # Apply the patch for real, and do add/delete/+x handling.
1292 system(applyPatchCmd
)
1294 for f
in filesToAdd
:
1296 for f
in filesToDelete
:
1300 # Set/clear executable bits
1301 for f
in filesToChangeExecBit
.keys():
1302 mode
= filesToChangeExecBit
[f
]
1303 setP4ExecBit(f
, mode
)
1306 # Build p4 change description, starting with the contents
1307 # of the git commit message.
1309 logMessage
= extractLogMessageFromGitCommit(id)
1310 logMessage
= logMessage
.strip()
1311 (logMessage
, jobs
) = self
.separate_jobs_from_description(logMessage
)
1313 template
= self
.prepareSubmitTemplate()
1314 submitTemplate
= self
.prepareLogMessage(template
, logMessage
, jobs
)
1316 if self
.preserveUser
:
1317 submitTemplate
+= "\n######## Actual user %s, modified after commit\n" % p4User
1319 if self
.checkAuthorship
and not self
.p4UserIsMe(p4User
):
1320 submitTemplate
+= "######## git author %s does not match your p4 account.\n" % gitEmail
1321 submitTemplate
+= "######## Use option --preserve-user to modify authorship.\n"
1322 submitTemplate
+= "######## Variable git-p4.skipUserNameCheck hides this message.\n"
1324 separatorLine
= "######## everything below this line is just the diff #######\n"
1327 if os
.environ
.has_key("P4DIFF"):
1328 del(os
.environ
["P4DIFF"])
1330 for editedFile
in editedFiles
:
1331 diff
+= p4_read_pipe(['diff', '-du',
1332 wildcard_encode(editedFile
)])
1336 for newFile
in filesToAdd
:
1337 newdiff
+= "==== new file ====\n"
1338 newdiff
+= "--- /dev/null\n"
1339 newdiff
+= "+++ %s\n" % newFile
1340 f
= open(newFile
, "r")
1341 for line
in f
.readlines():
1342 newdiff
+= "+" + line
1345 # change description file: submitTemplate, separatorLine, diff, newdiff
1346 (handle
, fileName
) = tempfile
.mkstemp()
1347 tmpFile
= os
.fdopen(handle
, "w+")
1349 submitTemplate
= submitTemplate
.replace("\n", "\r\n")
1350 separatorLine
= separatorLine
.replace("\n", "\r\n")
1351 newdiff
= newdiff
.replace("\n", "\r\n")
1352 tmpFile
.write(submitTemplate
+ separatorLine
+ diff
+ newdiff
)
1355 if self
.prepare_p4_only
:
1357 # Leave the p4 tree prepared, and the submit template around
1358 # and let the user decide what to do next
1361 print "P4 workspace prepared for submission."
1362 print "To submit or revert, go to client workspace"
1363 print " " + self
.clientPath
1365 print "To submit, use \"p4 submit\" to write a new description,"
1366 print "or \"p4 submit -i %s\" to use the one prepared by" \
1367 " \"git p4\"." % fileName
1368 print "You can delete the file \"%s\" when finished." % fileName
1370 if self
.preserveUser
and p4User
and not self
.p4UserIsMe(p4User
):
1371 print "To preserve change ownership by user %s, you must\n" \
1372 "do \"p4 change -f <change>\" after submitting and\n" \
1373 "edit the User field."
1375 print "After submitting, renamed files must be re-synced."
1376 print "Invoke \"p4 sync -f\" on each of these files:"
1377 for f
in pureRenameCopy
:
1381 print "To revert the changes, use \"p4 revert ...\", and delete"
1382 print "the submit template file \"%s\"" % fileName
1384 print "Since the commit adds new files, they must be deleted:"
1385 for f
in filesToAdd
:
1391 # Let the user edit the change description, then submit it.
1393 if self
.edit_template(fileName
):
1394 # read the edited message and submit
1396 tmpFile
= open(fileName
, "rb")
1397 message
= tmpFile
.read()
1399 submitTemplate
= message
[:message
.index(separatorLine
)]
1401 submitTemplate
= submitTemplate
.replace("\r\n", "\n")
1402 p4_write_pipe(['submit', '-i'], submitTemplate
)
1404 if self
.preserveUser
:
1406 # Get last changelist number. Cannot easily get it from
1407 # the submit command output as the output is
1409 changelist
= self
.lastP4Changelist()
1410 self
.modifyChangelistUser(changelist
, p4User
)
1412 # The rename/copy happened by applying a patch that created a
1413 # new file. This leaves it writable, which confuses p4.
1414 for f
in pureRenameCopy
:
1420 print "Submission cancelled, undoing p4 changes."
1421 for f
in editedFiles
:
1423 for f
in filesToAdd
:
1426 for f
in filesToDelete
:
1432 # Export git tags as p4 labels. Create a p4 label and then tag
1434 def exportGitTags(self
, gitTags
):
1435 validLabelRegexp
= gitConfig("git-p4.labelExportRegexp")
1436 if len(validLabelRegexp
) == 0:
1437 validLabelRegexp
= defaultLabelRegexp
1438 m
= re
.compile(validLabelRegexp
)
1440 for name
in gitTags
:
1442 if not m
.match(name
):
1444 print "tag %s does not match regexp %s" % (name
, validLabelRegexp
)
1447 # Get the p4 commit this corresponds to
1448 logMessage
= extractLogMessageFromGitCommit(name
)
1449 values
= extractSettingsGitLog(logMessage
)
1451 if not values
.has_key('change'):
1452 # a tag pointing to something not sent to p4; ignore
1454 print "git tag %s does not give a p4 commit" % name
1457 changelist
= values
['change']
1459 # Get the tag details.
1463 for l
in read_pipe_lines(["git", "cat-file", "-p", name
]):
1466 if re
.match(r
'tag\s+', l
):
1468 elif re
.match(r
'\s*$', l
):
1475 body
= ["lightweight tag imported by git p4\n"]
1477 # Create the label - use the same view as the client spec we are using
1478 clientSpec
= getClientSpec()
1480 labelTemplate
= "Label: %s\n" % name
1481 labelTemplate
+= "Description:\n"
1483 labelTemplate
+= "\t" + b
+ "\n"
1484 labelTemplate
+= "View:\n"
1485 for mapping
in clientSpec
.mappings
:
1486 labelTemplate
+= "\t%s\n" % mapping
.depot_side
.path
1489 print "Would create p4 label %s for tag" % name
1490 elif self
.prepare_p4_only
:
1491 print "Not creating p4 label %s for tag due to option" \
1492 " --prepare-p4-only" % name
1494 p4_write_pipe(["label", "-i"], labelTemplate
)
1497 p4_system(["tag", "-l", name
] +
1498 ["%s@%s" % (mapping
.depot_side
.path
, changelist
) for mapping
in clientSpec
.mappings
])
1501 print "created p4 label for tag %s" % name
1503 def run(self
, args
):
1505 self
.master
= currentGitBranch()
1506 if len(self
.master
) == 0 or not gitBranchExists("refs/heads/%s" % self
.master
):
1507 die("Detecting current git branch failed!")
1508 elif len(args
) == 1:
1509 self
.master
= args
[0]
1510 if not branchExists(self
.master
):
1511 die("Branch %s does not exist" % self
.master
)
1515 allowSubmit
= gitConfig("git-p4.allowSubmit")
1516 if len(allowSubmit
) > 0 and not self
.master
in allowSubmit
.split(","):
1517 die("%s is not in git-p4.allowSubmit" % self
.master
)
1519 [upstream
, settings
] = findUpstreamBranchPoint()
1520 self
.depotPath
= settings
['depot-paths'][0]
1521 if len(self
.origin
) == 0:
1522 self
.origin
= upstream
1524 if self
.preserveUser
:
1525 if not self
.canChangeChangelists():
1526 die("Cannot preserve user names without p4 super-user or admin permissions")
1528 # if not set from the command line, try the config file
1529 if self
.conflict_behavior
is None:
1530 val
= gitConfig("git-p4.conflict")
1532 if val
not in self
.conflict_behavior_choices
:
1533 die("Invalid value '%s' for config git-p4.conflict" % val
)
1536 self
.conflict_behavior
= val
1539 print "Origin branch is " + self
.origin
1541 if len(self
.depotPath
) == 0:
1542 print "Internal error: cannot locate perforce depot path from existing branches"
1545 self
.useClientSpec
= False
1546 if gitConfig("git-p4.useclientspec", "--bool") == "true":
1547 self
.useClientSpec
= True
1548 if self
.useClientSpec
:
1549 self
.clientSpecDirs
= getClientSpec()
1551 if self
.useClientSpec
:
1552 # all files are relative to the client spec
1553 self
.clientPath
= getClientRoot()
1555 self
.clientPath
= p4Where(self
.depotPath
)
1557 if self
.clientPath
== "":
1558 die("Error: Cannot locate perforce checkout of %s in client view" % self
.depotPath
)
1560 print "Perforce checkout for depot path %s located at %s" % (self
.depotPath
, self
.clientPath
)
1561 self
.oldWorkingDirectory
= os
.getcwd()
1563 # ensure the clientPath exists
1564 new_client_dir
= False
1565 if not os
.path
.exists(self
.clientPath
):
1566 new_client_dir
= True
1567 os
.makedirs(self
.clientPath
)
1569 chdir(self
.clientPath
)
1571 print "Would synchronize p4 checkout in %s" % self
.clientPath
1573 print "Synchronizing p4 checkout..."
1575 # old one was destroyed, and maybe nobody told p4
1576 p4_sync("...", "-f")
1582 for line
in read_pipe_lines("git rev-list --no-merges %s..%s" % (self
.origin
, self
.master
)):
1583 commits
.append(line
.strip())
1586 if self
.preserveUser
or (gitConfig("git-p4.skipUserNameCheck") == "true"):
1587 self
.checkAuthorship
= False
1589 self
.checkAuthorship
= True
1591 if self
.preserveUser
:
1592 self
.checkValidP4Users(commits
)
1595 # Build up a set of options to be passed to diff when
1596 # submitting each commit to p4.
1598 if self
.detectRenames
:
1599 # command-line -M arg
1600 self
.diffOpts
= "-M"
1602 # If not explicitly set check the config variable
1603 detectRenames
= gitConfig("git-p4.detectRenames")
1605 if detectRenames
.lower() == "false" or detectRenames
== "":
1607 elif detectRenames
.lower() == "true":
1608 self
.diffOpts
= "-M"
1610 self
.diffOpts
= "-M%s" % detectRenames
1612 # no command-line arg for -C or --find-copies-harder, just
1614 detectCopies
= gitConfig("git-p4.detectCopies")
1615 if detectCopies
.lower() == "false" or detectCopies
== "":
1617 elif detectCopies
.lower() == "true":
1618 self
.diffOpts
+= " -C"
1620 self
.diffOpts
+= " -C%s" % detectCopies
1622 if gitConfig("git-p4.detectCopiesHarder", "--bool") == "true":
1623 self
.diffOpts
+= " --find-copies-harder"
1626 # Apply the commits, one at a time. On failure, ask if should
1627 # continue to try the rest of the patches, or quit.
1632 last
= len(commits
) - 1
1633 for i
, commit
in enumerate(commits
):
1635 print " ", read_pipe(["git", "show", "-s",
1636 "--format=format:%h %s", commit
])
1639 ok
= self
.applyCommit(commit
)
1641 applied
.append(commit
)
1643 if self
.prepare_p4_only
and i
< last
:
1644 print "Processing only the first commit due to option" \
1645 " --prepare-p4-only"
1650 # prompt for what to do, or use the option/variable
1651 if self
.conflict_behavior
== "ask":
1652 print "What do you want to do?"
1653 response
= raw_input("[s]kip this commit but apply"
1654 " the rest, or [q]uit? ")
1657 elif self
.conflict_behavior
== "skip":
1659 elif self
.conflict_behavior
== "quit":
1662 die("Unknown conflict_behavior '%s'" %
1663 self
.conflict_behavior
)
1665 if response
[0] == "s":
1666 print "Skipping this commit, but applying the rest"
1668 if response
[0] == "q":
1675 chdir(self
.oldWorkingDirectory
)
1679 elif self
.prepare_p4_only
:
1681 elif len(commits
) == len(applied
):
1682 print "All commits applied!"
1686 sync
.branch
= self
.branch
1693 if len(applied
) == 0:
1694 print "No commits applied."
1696 print "Applied only the commits marked with '*':"
1702 print star
, read_pipe(["git", "show", "-s",
1703 "--format=format:%h %s", c
])
1704 print "You will have to do 'git p4 sync' and rebase."
1706 if gitConfig("git-p4.exportLabels", "--bool") == "true":
1707 self
.exportLabels
= True
1709 if self
.exportLabels
:
1710 p4Labels
= getP4Labels(self
.depotPath
)
1711 gitTags
= getGitTags()
1713 missingGitTags
= gitTags
- p4Labels
1714 self
.exportGitTags(missingGitTags
)
1716 # exit with error unless everything applied perfecly
1717 if len(commits
) != len(applied
):
1723 """Represent a p4 view ("p4 help views"), and map files in a
1724 repo according to the view."""
1727 """A depot or client path, possibly containing wildcards.
1728 The only one supported is ... at the end, currently.
1729 Initialize with the full path, with //depot or //client."""
1731 def __init__(self
, path
, is_depot
):
1733 self
.is_depot
= is_depot
1734 self
.find_wildcards()
1735 # remember the prefix bit, useful for relative mappings
1736 m
= re
.match("(//[^/]+/)", self
.path
)
1738 die("Path %s does not start with //prefix/" % self
.path
)
1740 if not self
.is_depot
:
1741 # strip //client/ on client paths
1742 self
.path
= self
.path
[len(prefix
):]
1744 def find_wildcards(self
):
1745 """Make sure wildcards are valid, and set up internal
1748 self
.ends_triple_dot
= False
1749 # There are three wildcards allowed in p4 views
1750 # (see "p4 help views"). This code knows how to
1751 # handle "..." (only at the end), but cannot deal with
1752 # "%%n" or "*". Only check the depot_side, as p4 should
1753 # validate that the client_side matches too.
1754 if re
.search(r
'%%[1-9]', self
.path
):
1755 die("Can't handle %%n wildcards in view: %s" % self
.path
)
1756 if self
.path
.find("*") >= 0:
1757 die("Can't handle * wildcards in view: %s" % self
.path
)
1758 triple_dot_index
= self
.path
.find("...")
1759 if triple_dot_index
>= 0:
1760 if triple_dot_index
!= len(self
.path
) - 3:
1761 die("Can handle only single ... wildcard, at end: %s" %
1763 self
.ends_triple_dot
= True
1765 def ensure_compatible(self
, other_path
):
1766 """Make sure the wildcards agree."""
1767 if self
.ends_triple_dot
!= other_path
.ends_triple_dot
:
1768 die("Both paths must end with ... if either does;\n" +
1769 "paths: %s %s" % (self
.path
, other_path
.path
))
1771 def match_wildcards(self
, test_path
):
1772 """See if this test_path matches us, and fill in the value
1773 of the wildcards if so. Returns a tuple of
1774 (True|False, wildcards[]). For now, only the ... at end
1775 is supported, so at most one wildcard."""
1776 if self
.ends_triple_dot
:
1777 dotless
= self
.path
[:-3]
1778 if test_path
.startswith(dotless
):
1779 wildcard
= test_path
[len(dotless
):]
1780 return (True, [ wildcard
])
1782 if test_path
== self
.path
:
1786 def match(self
, test_path
):
1787 """Just return if it matches; don't bother with the wildcards."""
1788 b
, _
= self
.match_wildcards(test_path
)
1791 def fill_in_wildcards(self
, wildcards
):
1792 """Return the relative path, with the wildcards filled in
1793 if there are any."""
1794 if self
.ends_triple_dot
:
1795 return self
.path
[:-3] + wildcards
[0]
1799 class Mapping(object):
1800 def __init__(self
, depot_side
, client_side
, overlay
, exclude
):
1801 # depot_side is without the trailing /... if it had one
1802 self
.depot_side
= View
.Path(depot_side
, is_depot
=True)
1803 self
.client_side
= View
.Path(client_side
, is_depot
=False)
1804 self
.overlay
= overlay
# started with "+"
1805 self
.exclude
= exclude
# started with "-"
1806 assert not (self
.overlay
and self
.exclude
)
1807 self
.depot_side
.ensure_compatible(self
.client_side
)
1815 return "View.Mapping: %s%s -> %s" % \
1816 (c
, self
.depot_side
.path
, self
.client_side
.path
)
1818 def map_depot_to_client(self
, depot_path
):
1819 """Calculate the client path if using this mapping on the
1820 given depot path; does not consider the effect of other
1821 mappings in a view. Even excluded mappings are returned."""
1822 matches
, wildcards
= self
.depot_side
.match_wildcards(depot_path
)
1825 client_path
= self
.client_side
.fill_in_wildcards(wildcards
)
1834 def append(self
, view_line
):
1835 """Parse a view line, splitting it into depot and client
1836 sides. Append to self.mappings, preserving order."""
1838 # Split the view line into exactly two words. P4 enforces
1839 # structure on these lines that simplifies this quite a bit.
1841 # Either or both words may be double-quoted.
1842 # Single quotes do not matter.
1843 # Double-quote marks cannot occur inside the words.
1844 # A + or - prefix is also inside the quotes.
1845 # There are no quotes unless they contain a space.
1846 # The line is already white-space stripped.
1847 # The two words are separated by a single space.
1849 if view_line
[0] == '"':
1850 # First word is double quoted. Find its end.
1851 close_quote_index
= view_line
.find('"', 1)
1852 if close_quote_index
<= 0:
1853 die("No first-word closing quote found: %s" % view_line
)
1854 depot_side
= view_line
[1:close_quote_index
]
1855 # skip closing quote and space
1856 rhs_index
= close_quote_index
+ 1 + 1
1858 space_index
= view_line
.find(" ")
1859 if space_index
<= 0:
1860 die("No word-splitting space found: %s" % view_line
)
1861 depot_side
= view_line
[0:space_index
]
1862 rhs_index
= space_index
+ 1
1864 if view_line
[rhs_index
] == '"':
1865 # Second word is double quoted. Make sure there is a
1866 # double quote at the end too.
1867 if not view_line
.endswith('"'):
1868 die("View line with rhs quote should end with one: %s" %
1871 client_side
= view_line
[rhs_index
+1:-1]
1873 client_side
= view_line
[rhs_index
:]
1875 # prefix + means overlay on previous mapping
1877 if depot_side
.startswith("+"):
1879 depot_side
= depot_side
[1:]
1881 # prefix - means exclude this path
1883 if depot_side
.startswith("-"):
1885 depot_side
= depot_side
[1:]
1887 m
= View
.Mapping(depot_side
, client_side
, overlay
, exclude
)
1888 self
.mappings
.append(m
)
1890 def map_in_client(self
, depot_path
):
1891 """Return the relative location in the client where this
1892 depot file should live. Returns "" if the file should
1893 not be mapped in the client."""
1898 # look at later entries first
1899 for m
in self
.mappings
[::-1]:
1901 # see where will this path end up in the client
1902 p
= m
.map_depot_to_client(depot_path
)
1905 # Depot path does not belong in client. Must remember
1906 # this, as previous items should not cause files to
1907 # exist in this path either. Remember that the list is
1908 # being walked from the end, which has higher precedence.
1909 # Overlap mappings do not exclude previous mappings.
1911 paths_filled
.append(m
.client_side
)
1914 # This mapping matched; no need to search any further.
1915 # But, the mapping could be rejected if the client path
1916 # has already been claimed by an earlier mapping (i.e.
1917 # one later in the list, which we are walking backwards).
1918 already_mapped_in_client
= False
1919 for f
in paths_filled
:
1920 # this is View.Path.match
1922 already_mapped_in_client
= True
1924 if not already_mapped_in_client
:
1925 # Include this file, unless it is from a line that
1926 # explicitly said to exclude it.
1930 # a match, even if rejected, always stops the search
1935 class P4Sync(Command
, P4UserMap
):
1936 delete_actions
= ( "delete", "move/delete", "purge" )
1939 Command
.__init
__(self
)
1940 P4UserMap
.__init
__(self
)
1942 optparse
.make_option("--branch", dest
="branch"),
1943 optparse
.make_option("--detect-branches", dest
="detectBranches", action
="store_true"),
1944 optparse
.make_option("--changesfile", dest
="changesFile"),
1945 optparse
.make_option("--silent", dest
="silent", action
="store_true"),
1946 optparse
.make_option("--detect-labels", dest
="detectLabels", action
="store_true"),
1947 optparse
.make_option("--import-labels", dest
="importLabels", action
="store_true"),
1948 optparse
.make_option("--import-local", dest
="importIntoRemotes", action
="store_false",
1949 help="Import into refs/heads/ , not refs/remotes"),
1950 optparse
.make_option("--max-changes", dest
="maxChanges"),
1951 optparse
.make_option("--keep-path", dest
="keepRepoPath", action
='store_true',
1952 help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),
1953 optparse
.make_option("--use-client-spec", dest
="useClientSpec", action
='store_true',
1954 help="Only sync files that are included in the Perforce Client Spec")
1956 self
.description
= """Imports from Perforce into a git repository.\n
1958 //depot/my/project/ -- to import the current head
1959 //depot/my/project/@all -- to import everything
1960 //depot/my/project/@1,6 -- to import only from revision 1 to 6
1962 (a ... is not needed in the path p4 specification, it's added implicitly)"""
1964 self
.usage
+= " //depot/path[@revRange]"
1966 self
.createdBranches
= set()
1967 self
.committedChanges
= set()
1969 self
.detectBranches
= False
1970 self
.detectLabels
= False
1971 self
.importLabels
= False
1972 self
.changesFile
= ""
1973 self
.syncWithOrigin
= True
1974 self
.importIntoRemotes
= True
1975 self
.maxChanges
= ""
1976 self
.isWindows
= (platform
.system() == "Windows")
1977 self
.keepRepoPath
= False
1978 self
.depotPaths
= None
1979 self
.p4BranchesInGit
= []
1980 self
.cloneExclude
= []
1981 self
.useClientSpec
= False
1982 self
.useClientSpec_from_options
= False
1983 self
.clientSpecDirs
= None
1984 self
.tempBranches
= []
1985 self
.tempBranchLocation
= "git-p4-tmp"
1987 if gitConfig("git-p4.syncFromOrigin") == "false":
1988 self
.syncWithOrigin
= False
1990 # Force a checkpoint in fast-import and wait for it to finish
1991 def checkpoint(self
):
1992 self
.gitStream
.write("checkpoint\n\n")
1993 self
.gitStream
.write("progress checkpoint\n\n")
1994 out
= self
.gitOutput
.readline()
1996 print "checkpoint finished: " + out
1998 def extractFilesFromCommit(self
, commit
):
1999 self
.cloneExclude
= [re
.sub(r
"\.\.\.$", "", path
)
2000 for path
in self
.cloneExclude
]
2003 while commit
.has_key("depotFile%s" % fnum
):
2004 path
= commit
["depotFile%s" % fnum
]
2006 if [p
for p
in self
.cloneExclude
2007 if p4PathStartsWith(path
, p
)]:
2010 found
= [p
for p
in self
.depotPaths
2011 if p4PathStartsWith(path
, p
)]
2018 file["rev"] = commit
["rev%s" % fnum
]
2019 file["action"] = commit
["action%s" % fnum
]
2020 file["type"] = commit
["type%s" % fnum
]
2025 def stripRepoPath(self
, path
, prefixes
):
2026 """When streaming files, this is called to map a p4 depot path
2027 to where it should go in git. The prefixes are either
2028 self.depotPaths, or self.branchPrefixes in the case of
2029 branch detection."""
2031 if self
.useClientSpec
:
2032 # branch detection moves files up a level (the branch name)
2033 # from what client spec interpretation gives
2034 path
= self
.clientSpecDirs
.map_in_client(path
)
2035 if self
.detectBranches
:
2036 for b
in self
.knownBranches
:
2037 if path
.startswith(b
+ "/"):
2038 path
= path
[len(b
)+1:]
2040 elif self
.keepRepoPath
:
2041 # Preserve everything in relative path name except leading
2042 # //depot/; just look at first prefix as they all should
2043 # be in the same depot.
2044 depot
= re
.sub("^(//[^/]+/).*", r
'\1', prefixes
[0])
2045 if p4PathStartsWith(path
, depot
):
2046 path
= path
[len(depot
):]
2050 if p4PathStartsWith(path
, p
):
2051 path
= path
[len(p
):]
2054 path
= wildcard_decode(path
)
2057 def splitFilesIntoBranches(self
, commit
):
2058 """Look at each depotFile in the commit to figure out to what
2059 branch it belongs."""
2063 while commit
.has_key("depotFile%s" % fnum
):
2064 path
= commit
["depotFile%s" % fnum
]
2065 found
= [p
for p
in self
.depotPaths
2066 if p4PathStartsWith(path
, p
)]
2073 file["rev"] = commit
["rev%s" % fnum
]
2074 file["action"] = commit
["action%s" % fnum
]
2075 file["type"] = commit
["type%s" % fnum
]
2078 # start with the full relative path where this file would
2080 if self
.useClientSpec
:
2081 relPath
= self
.clientSpecDirs
.map_in_client(path
)
2083 relPath
= self
.stripRepoPath(path
, self
.depotPaths
)
2085 for branch
in self
.knownBranches
.keys():
2086 # add a trailing slash so that a commit into qt/4.2foo
2087 # doesn't end up in qt/4.2, e.g.
2088 if relPath
.startswith(branch
+ "/"):
2089 if branch
not in branches
:
2090 branches
[branch
] = []
2091 branches
[branch
].append(file)
2096 # output one file from the P4 stream
2097 # - helper for streamP4Files
2099 def streamOneP4File(self
, file, contents
):
2100 relPath
= self
.stripRepoPath(file['depotFile'], self
.branchPrefixes
)
2102 sys
.stderr
.write("%s\n" % relPath
)
2104 (type_base
, type_mods
) = split_p4_type(file["type"])
2107 if "x" in type_mods
:
2109 if type_base
== "symlink":
2111 # p4 print on a symlink contains "target\n"; remove the newline
2112 data
= ''.join(contents
)
2113 contents
= [data
[:-1]]
2115 if type_base
== "utf16":
2116 # p4 delivers different text in the python output to -G
2117 # than it does when using "print -o", or normal p4 client
2118 # operations. utf16 is converted to ascii or utf8, perhaps.
2119 # But ascii text saved as -t utf16 is completely mangled.
2120 # Invoke print -o to get the real contents.
2121 text
= p4_read_pipe(['print', '-q', '-o', '-', file['depotFile']])
2124 if type_base
== "apple":
2125 # Apple filetype files will be streamed as a concatenation of
2126 # its appledouble header and the contents. This is useless
2127 # on both macs and non-macs. If using "print -q -o xx", it
2128 # will create "xx" with the data, and "%xx" with the header.
2129 # This is also not very useful.
2131 # Ideally, someday, this script can learn how to generate
2132 # appledouble files directly and import those to git, but
2133 # non-mac machines can never find a use for apple filetype.
2134 print "\nIgnoring apple filetype file %s" % file['depotFile']
2137 # Note that we do not try to de-mangle keywords on utf16 files,
2138 # even though in theory somebody may want that.
2139 pattern
= p4_keywords_regexp_for_type(type_base
, type_mods
)
2141 regexp
= re
.compile(pattern
, re
.VERBOSE
)
2142 text
= ''.join(contents
)
2143 text
= regexp
.sub(r
'$\1$', text
)
2146 self
.gitStream
.write("M %s inline %s\n" % (git_mode
, relPath
))
2151 length
= length
+ len(d
)
2153 self
.gitStream
.write("data %d\n" % length
)
2155 self
.gitStream
.write(d
)
2156 self
.gitStream
.write("\n")
2158 def streamOneP4Deletion(self
, file):
2159 relPath
= self
.stripRepoPath(file['path'], self
.branchPrefixes
)
2161 sys
.stderr
.write("delete %s\n" % relPath
)
2162 self
.gitStream
.write("D %s\n" % relPath
)
2164 # handle another chunk of streaming data
2165 def streamP4FilesCb(self
, marshalled
):
2167 # catch p4 errors and complain
2169 if "code" in marshalled
:
2170 if marshalled
["code"] == "error":
2171 if "data" in marshalled
:
2172 err
= marshalled
["data"].rstrip()
2175 if self
.stream_have_file_info
:
2176 if "depotFile" in self
.stream_file
:
2177 f
= self
.stream_file
["depotFile"]
2178 # force a failure in fast-import, else an empty
2179 # commit will be made
2180 self
.gitStream
.write("\n")
2181 self
.gitStream
.write("die-now\n")
2182 self
.gitStream
.close()
2183 # ignore errors, but make sure it exits first
2184 self
.importProcess
.wait()
2186 die("Error from p4 print for %s: %s" % (f
, err
))
2188 die("Error from p4 print: %s" % err
)
2190 if marshalled
.has_key('depotFile') and self
.stream_have_file_info
:
2191 # start of a new file - output the old one first
2192 self
.streamOneP4File(self
.stream_file
, self
.stream_contents
)
2193 self
.stream_file
= {}
2194 self
.stream_contents
= []
2195 self
.stream_have_file_info
= False
2197 # pick up the new file information... for the
2198 # 'data' field we need to append to our array
2199 for k
in marshalled
.keys():
2201 self
.stream_contents
.append(marshalled
['data'])
2203 self
.stream_file
[k
] = marshalled
[k
]
2205 self
.stream_have_file_info
= True
2207 # Stream directly from "p4 files" into "git fast-import"
2208 def streamP4Files(self
, files
):
2214 # if using a client spec, only add the files that have
2215 # a path in the client
2216 if self
.clientSpecDirs
:
2217 if self
.clientSpecDirs
.map_in_client(f
['path']) == "":
2220 filesForCommit
.append(f
)
2221 if f
['action'] in self
.delete_actions
:
2222 filesToDelete
.append(f
)
2224 filesToRead
.append(f
)
2227 for f
in filesToDelete
:
2228 self
.streamOneP4Deletion(f
)
2230 if len(filesToRead
) > 0:
2231 self
.stream_file
= {}
2232 self
.stream_contents
= []
2233 self
.stream_have_file_info
= False
2235 # curry self argument
2236 def streamP4FilesCbSelf(entry
):
2237 self
.streamP4FilesCb(entry
)
2239 fileArgs
= ['%s#%s' % (f
['path'], f
['rev']) for f
in filesToRead
]
2241 p4CmdList(["-x", "-", "print"],
2243 cb
=streamP4FilesCbSelf
)
2246 if self
.stream_file
.has_key('depotFile'):
2247 self
.streamOneP4File(self
.stream_file
, self
.stream_contents
)
2249 def make_email(self
, userid
):
2250 if userid
in self
.users
:
2251 return self
.users
[userid
]
2253 return "%s <a@b>" % userid
2256 def streamTag(self
, gitStream
, labelName
, labelDetails
, commit
, epoch
):
2258 print "writing tag %s for commit %s" % (labelName
, commit
)
2259 gitStream
.write("tag %s\n" % labelName
)
2260 gitStream
.write("from %s\n" % commit
)
2262 if labelDetails
.has_key('Owner'):
2263 owner
= labelDetails
["Owner"]
2267 # Try to use the owner of the p4 label, or failing that,
2268 # the current p4 user id.
2270 email
= self
.make_email(owner
)
2272 email
= self
.make_email(self
.p4UserId())
2273 tagger
= "%s %s %s" % (email
, epoch
, self
.tz
)
2275 gitStream
.write("tagger %s\n" % tagger
)
2277 print "labelDetails=",labelDetails
2278 if labelDetails
.has_key('Description'):
2279 description
= labelDetails
['Description']
2281 description
= 'Label from git p4'
2283 gitStream
.write("data %d\n" % len(description
))
2284 gitStream
.write(description
)
2285 gitStream
.write("\n")
2287 def commit(self
, details
, files
, branch
, parent
= ""):
2288 epoch
= details
["time"]
2289 author
= details
["user"]
2292 print "commit into %s" % branch
2294 # start with reading files; if that fails, we should not
2298 if [p
for p
in self
.branchPrefixes
if p4PathStartsWith(f
['path'], p
)]:
2299 new_files
.append (f
)
2301 sys
.stderr
.write("Ignoring file outside of prefix: %s\n" % f
['path'])
2303 self
.gitStream
.write("commit %s\n" % branch
)
2304 # gitStream.write("mark :%s\n" % details["change"])
2305 self
.committedChanges
.add(int(details
["change"]))
2307 if author
not in self
.users
:
2308 self
.getUserMapFromPerforceServer()
2309 committer
= "%s %s %s" % (self
.make_email(author
), epoch
, self
.tz
)
2311 self
.gitStream
.write("committer %s\n" % committer
)
2313 self
.gitStream
.write("data <<EOT\n")
2314 self
.gitStream
.write(details
["desc"])
2315 self
.gitStream
.write("\n[git-p4: depot-paths = \"%s\": change = %s" %
2316 (','.join(self
.branchPrefixes
), details
["change"]))
2317 if len(details
['options']) > 0:
2318 self
.gitStream
.write(": options = %s" % details
['options'])
2319 self
.gitStream
.write("]\nEOT\n\n")
2323 print "parent %s" % parent
2324 self
.gitStream
.write("from %s\n" % parent
)
2326 self
.streamP4Files(new_files
)
2327 self
.gitStream
.write("\n")
2329 change
= int(details
["change"])
2331 if self
.labels
.has_key(change
):
2332 label
= self
.labels
[change
]
2333 labelDetails
= label
[0]
2334 labelRevisions
= label
[1]
2336 print "Change %s is labelled %s" % (change
, labelDetails
)
2338 files
= p4CmdList(["files"] + ["%s...@%s" % (p
, change
)
2339 for p
in self
.branchPrefixes
])
2341 if len(files
) == len(labelRevisions
):
2345 if info
["action"] in self
.delete_actions
:
2347 cleanedFiles
[info
["depotFile"]] = info
["rev"]
2349 if cleanedFiles
== labelRevisions
:
2350 self
.streamTag(self
.gitStream
, 'tag_%s' % labelDetails
['label'], labelDetails
, branch
, epoch
)
2354 print ("Tag %s does not match with change %s: files do not match."
2355 % (labelDetails
["label"], change
))
2359 print ("Tag %s does not match with change %s: file count is different."
2360 % (labelDetails
["label"], change
))
2362 # Build a dictionary of changelists and labels, for "detect-labels" option.
2363 def getLabels(self
):
2366 l
= p4CmdList(["labels"] + ["%s..." % p
for p
in self
.depotPaths
])
2367 if len(l
) > 0 and not self
.silent
:
2368 print "Finding files belonging to labels in %s" % `self
.depotPaths`
2371 label
= output
["label"]
2375 print "Querying files for label %s" % label
2376 for file in p4CmdList(["files"] +
2377 ["%s...@%s" % (p
, label
)
2378 for p
in self
.depotPaths
]):
2379 revisions
[file["depotFile"]] = file["rev"]
2380 change
= int(file["change"])
2381 if change
> newestChange
:
2382 newestChange
= change
2384 self
.labels
[newestChange
] = [output
, revisions
]
2387 print "Label changes: %s" % self
.labels
.keys()
2389 # Import p4 labels as git tags. A direct mapping does not
2390 # exist, so assume that if all the files are at the same revision
2391 # then we can use that, or it's something more complicated we should
2393 def importP4Labels(self
, stream
, p4Labels
):
2395 print "import p4 labels: " + ' '.join(p4Labels
)
2397 ignoredP4Labels
= gitConfigList("git-p4.ignoredP4Labels")
2398 validLabelRegexp
= gitConfig("git-p4.labelImportRegexp")
2399 if len(validLabelRegexp
) == 0:
2400 validLabelRegexp
= defaultLabelRegexp
2401 m
= re
.compile(validLabelRegexp
)
2403 for name
in p4Labels
:
2406 if not m
.match(name
):
2408 print "label %s does not match regexp %s" % (name
,validLabelRegexp
)
2411 if name
in ignoredP4Labels
:
2414 labelDetails
= p4CmdList(['label', "-o", name
])[0]
2416 # get the most recent changelist for each file in this label
2417 change
= p4Cmd(["changes", "-m", "1"] + ["%s...@%s" % (p
, name
)
2418 for p
in self
.depotPaths
])
2420 if change
.has_key('change'):
2421 # find the corresponding git commit; take the oldest commit
2422 changelist
= int(change
['change'])
2423 gitCommit
= read_pipe(["git", "rev-list", "--max-count=1",
2424 "--reverse", ":/\[git-p4:.*change = %d\]" % changelist
])
2425 if len(gitCommit
) == 0:
2426 print "could not find git commit for changelist %d" % changelist
2428 gitCommit
= gitCommit
.strip()
2430 # Convert from p4 time format
2432 tmwhen
= time
.strptime(labelDetails
['Update'], "%Y/%m/%d %H:%M:%S")
2434 print "Could not convert label time %s" % labelDetails
['Update']
2437 when
= int(time
.mktime(tmwhen
))
2438 self
.streamTag(stream
, name
, labelDetails
, gitCommit
, when
)
2440 print "p4 label %s mapped to git commit %s" % (name
, gitCommit
)
2443 print "Label %s has no changelists - possibly deleted?" % name
2446 # We can't import this label; don't try again as it will get very
2447 # expensive repeatedly fetching all the files for labels that will
2448 # never be imported. If the label is moved in the future, the
2449 # ignore will need to be removed manually.
2450 system(["git", "config", "--add", "git-p4.ignoredP4Labels", name
])
2452 def guessProjectName(self
):
2453 for p
in self
.depotPaths
:
2456 p
= p
[p
.strip().rfind("/") + 1:]
2457 if not p
.endswith("/"):
2461 def getBranchMapping(self
):
2462 lostAndFoundBranches
= set()
2464 user
= gitConfig("git-p4.branchUser")
2466 command
= "branches -u %s" % user
2468 command
= "branches"
2470 for info
in p4CmdList(command
):
2471 details
= p4Cmd(["branch", "-o", info
["branch"]])
2473 while details
.has_key("View%s" % viewIdx
):
2474 paths
= details
["View%s" % viewIdx
].split(" ")
2475 viewIdx
= viewIdx
+ 1
2476 # require standard //depot/foo/... //depot/bar/... mapping
2477 if len(paths
) != 2 or not paths
[0].endswith("/...") or not paths
[1].endswith("/..."):
2480 destination
= paths
[1]
2482 if p4PathStartsWith(source
, self
.depotPaths
[0]) and p4PathStartsWith(destination
, self
.depotPaths
[0]):
2483 source
= source
[len(self
.depotPaths
[0]):-4]
2484 destination
= destination
[len(self
.depotPaths
[0]):-4]
2486 if destination
in self
.knownBranches
:
2488 print "p4 branch %s defines a mapping from %s to %s" % (info
["branch"], source
, destination
)
2489 print "but there exists another mapping from %s to %s already!" % (self
.knownBranches
[destination
], destination
)
2492 self
.knownBranches
[destination
] = source
2494 lostAndFoundBranches
.discard(destination
)
2496 if source
not in self
.knownBranches
:
2497 lostAndFoundBranches
.add(source
)
2499 # Perforce does not strictly require branches to be defined, so we also
2500 # check git config for a branch list.
2502 # Example of branch definition in git config file:
2504 # branchList=main:branchA
2505 # branchList=main:branchB
2506 # branchList=branchA:branchC
2507 configBranches
= gitConfigList("git-p4.branchList")
2508 for branch
in configBranches
:
2510 (source
, destination
) = branch
.split(":")
2511 self
.knownBranches
[destination
] = source
2513 lostAndFoundBranches
.discard(destination
)
2515 if source
not in self
.knownBranches
:
2516 lostAndFoundBranches
.add(source
)
2519 for branch
in lostAndFoundBranches
:
2520 self
.knownBranches
[branch
] = branch
2522 def getBranchMappingFromGitBranches(self
):
2523 branches
= p4BranchesInGit(self
.importIntoRemotes
)
2524 for branch
in branches
.keys():
2525 if branch
== "master":
2528 branch
= branch
[len(self
.projectName
):]
2529 self
.knownBranches
[branch
] = branch
2531 def updateOptionDict(self
, d
):
2533 if self
.keepRepoPath
:
2534 option_keys
['keepRepoPath'] = 1
2536 d
["options"] = ' '.join(sorted(option_keys
.keys()))
2538 def readOptions(self
, d
):
2539 self
.keepRepoPath
= (d
.has_key('options')
2540 and ('keepRepoPath' in d
['options']))
2542 def gitRefForBranch(self
, branch
):
2543 if branch
== "main":
2544 return self
.refPrefix
+ "master"
2546 if len(branch
) <= 0:
2549 return self
.refPrefix
+ self
.projectName
+ branch
2551 def gitCommitByP4Change(self
, ref
, change
):
2553 print "looking in ref " + ref
+ " for change %s using bisect..." % change
2556 latestCommit
= parseRevision(ref
)
2560 print "trying: earliest %s latest %s" % (earliestCommit
, latestCommit
)
2561 next
= read_pipe("git rev-list --bisect %s %s" % (latestCommit
, earliestCommit
)).strip()
2566 log
= extractLogMessageFromGitCommit(next
)
2567 settings
= extractSettingsGitLog(log
)
2568 currentChange
= int(settings
['change'])
2570 print "current change %s" % currentChange
2572 if currentChange
== change
:
2574 print "found %s" % next
2577 if currentChange
< change
:
2578 earliestCommit
= "^%s" % next
2580 latestCommit
= "%s" % next
2584 def importNewBranch(self
, branch
, maxChange
):
2585 # make fast-import flush all changes to disk and update the refs using the checkpoint
2586 # command so that we can try to find the branch parent in the git history
2587 self
.gitStream
.write("checkpoint\n\n");
2588 self
.gitStream
.flush();
2589 branchPrefix
= self
.depotPaths
[0] + branch
+ "/"
2590 range = "@1,%s" % maxChange
2591 #print "prefix" + branchPrefix
2592 changes
= p4ChangesForPaths([branchPrefix
], range)
2593 if len(changes
) <= 0:
2595 firstChange
= changes
[0]
2596 #print "first change in branch: %s" % firstChange
2597 sourceBranch
= self
.knownBranches
[branch
]
2598 sourceDepotPath
= self
.depotPaths
[0] + sourceBranch
2599 sourceRef
= self
.gitRefForBranch(sourceBranch
)
2600 #print "source " + sourceBranch
2602 branchParentChange
= int(p4Cmd(["changes", "-m", "1", "%s...@1,%s" % (sourceDepotPath
, firstChange
)])["change"])
2603 #print "branch parent: %s" % branchParentChange
2604 gitParent
= self
.gitCommitByP4Change(sourceRef
, branchParentChange
)
2605 if len(gitParent
) > 0:
2606 self
.initialParents
[self
.gitRefForBranch(branch
)] = gitParent
2607 #print "parent git commit: %s" % gitParent
2609 self
.importChanges(changes
)
2612 def searchParent(self
, parent
, branch
, target
):
2614 for blob
in read_pipe_lines(["git", "rev-list", "--reverse", "--no-merges", parent
]):
2616 if len(read_pipe(["git", "diff-tree", blob
, target
])) == 0:
2619 print "Found parent of %s in commit %s" % (branch
, blob
)
2626 def importChanges(self
, changes
):
2628 for change
in changes
:
2629 description
= p4_describe(change
)
2630 self
.updateOptionDict(description
)
2633 sys
.stdout
.write("\rImporting revision %s (%s%%)" % (change
, cnt
* 100 / len(changes
)))
2638 if self
.detectBranches
:
2639 branches
= self
.splitFilesIntoBranches(description
)
2640 for branch
in branches
.keys():
2642 branchPrefix
= self
.depotPaths
[0] + branch
+ "/"
2643 self
.branchPrefixes
= [ branchPrefix
]
2647 filesForCommit
= branches
[branch
]
2650 print "branch is %s" % branch
2652 self
.updatedBranches
.add(branch
)
2654 if branch
not in self
.createdBranches
:
2655 self
.createdBranches
.add(branch
)
2656 parent
= self
.knownBranches
[branch
]
2657 if parent
== branch
:
2660 fullBranch
= self
.projectName
+ branch
2661 if fullBranch
not in self
.p4BranchesInGit
:
2663 print("\n Importing new branch %s" % fullBranch
);
2664 if self
.importNewBranch(branch
, change
- 1):
2666 self
.p4BranchesInGit
.append(fullBranch
)
2668 print("\n Resuming with change %s" % change
);
2671 print "parent determined through known branches: %s" % parent
2673 branch
= self
.gitRefForBranch(branch
)
2674 parent
= self
.gitRefForBranch(parent
)
2677 print "looking for initial parent for %s; current parent is %s" % (branch
, parent
)
2679 if len(parent
) == 0 and branch
in self
.initialParents
:
2680 parent
= self
.initialParents
[branch
]
2681 del self
.initialParents
[branch
]
2685 tempBranch
= "%s/%d" % (self
.tempBranchLocation
, change
)
2687 print "Creating temporary branch: " + tempBranch
2688 self
.commit(description
, filesForCommit
, tempBranch
)
2689 self
.tempBranches
.append(tempBranch
)
2691 blob
= self
.searchParent(parent
, branch
, tempBranch
)
2693 self
.commit(description
, filesForCommit
, branch
, blob
)
2696 print "Parent of %s not found. Committing into head of %s" % (branch
, parent
)
2697 self
.commit(description
, filesForCommit
, branch
, parent
)
2699 files
= self
.extractFilesFromCommit(description
)
2700 self
.commit(description
, files
, self
.branch
,
2702 # only needed once, to connect to the previous commit
2703 self
.initialParent
= ""
2705 print self
.gitError
.read()
2708 def importHeadRevision(self
, revision
):
2709 print "Doing initial import of %s from revision %s into %s" % (' '.join(self
.depotPaths
), revision
, self
.branch
)
2712 details
["user"] = "git perforce import user"
2713 details
["desc"] = ("Initial import of %s from the state at revision %s\n"
2714 % (' '.join(self
.depotPaths
), revision
))
2715 details
["change"] = revision
2719 fileArgs
= ["%s...%s" % (p
,revision
) for p
in self
.depotPaths
]
2721 for info
in p4CmdList(["files"] + fileArgs
):
2723 if 'code' in info
and info
['code'] == 'error':
2724 sys
.stderr
.write("p4 returned an error: %s\n"
2726 if info
['data'].find("must refer to client") >= 0:
2727 sys
.stderr
.write("This particular p4 error is misleading.\n")
2728 sys
.stderr
.write("Perhaps the depot path was misspelled.\n");
2729 sys
.stderr
.write("Depot path: %s\n" % " ".join(self
.depotPaths
))
2731 if 'p4ExitCode' in info
:
2732 sys
.stderr
.write("p4 exitcode: %s\n" % info
['p4ExitCode'])
2736 change
= int(info
["change"])
2737 if change
> newestRevision
:
2738 newestRevision
= change
2740 if info
["action"] in self
.delete_actions
:
2741 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
2742 #fileCnt = fileCnt + 1
2745 for prop
in ["depotFile", "rev", "action", "type" ]:
2746 details
["%s%s" % (prop
, fileCnt
)] = info
[prop
]
2748 fileCnt
= fileCnt
+ 1
2750 details
["change"] = newestRevision
2752 # Use time from top-most change so that all git p4 clones of
2753 # the same p4 repo have the same commit SHA1s.
2754 res
= p4_describe(newestRevision
)
2755 details
["time"] = res
["time"]
2757 self
.updateOptionDict(details
)
2759 self
.commit(details
, self
.extractFilesFromCommit(details
), self
.branch
)
2761 print "IO error with git fast-import. Is your git version recent enough?"
2762 print self
.gitError
.read()
2765 def run(self
, args
):
2766 self
.depotPaths
= []
2767 self
.changeRange
= ""
2768 self
.previousDepotPaths
= []
2769 self
.hasOrigin
= False
2771 # map from branch depot path to parent branch
2772 self
.knownBranches
= {}
2773 self
.initialParents
= {}
2775 if self
.importIntoRemotes
:
2776 self
.refPrefix
= "refs/remotes/p4/"
2778 self
.refPrefix
= "refs/heads/p4/"
2780 if self
.syncWithOrigin
:
2781 self
.hasOrigin
= originP4BranchesExist()
2784 print 'Syncing with origin first, using "git fetch origin"'
2785 system("git fetch origin")
2787 branch_arg_given
= bool(self
.branch
)
2788 if len(self
.branch
) == 0:
2789 self
.branch
= self
.refPrefix
+ "master"
2790 if gitBranchExists("refs/heads/p4") and self
.importIntoRemotes
:
2791 system("git update-ref %s refs/heads/p4" % self
.branch
)
2792 system("git branch -D p4")
2794 # accept either the command-line option, or the configuration variable
2795 if self
.useClientSpec
:
2796 # will use this after clone to set the variable
2797 self
.useClientSpec_from_options
= True
2799 if gitConfig("git-p4.useclientspec", "--bool") == "true":
2800 self
.useClientSpec
= True
2801 if self
.useClientSpec
:
2802 self
.clientSpecDirs
= getClientSpec()
2804 # TODO: should always look at previous commits,
2805 # merge with previous imports, if possible.
2808 createOrUpdateBranchesFromOrigin(self
.refPrefix
, self
.silent
)
2810 # branches holds mapping from branch name to sha1
2811 branches
= p4BranchesInGit(self
.importIntoRemotes
)
2813 # restrict to just this one, disabling detect-branches
2814 if branch_arg_given
:
2815 short
= self
.branch
.split("/")[-1]
2816 if short
in branches
:
2817 self
.p4BranchesInGit
= [ short
]
2819 self
.p4BranchesInGit
= branches
.keys()
2821 if len(self
.p4BranchesInGit
) > 1:
2823 print "Importing from/into multiple branches"
2824 self
.detectBranches
= True
2825 for branch
in branches
.keys():
2826 self
.initialParents
[self
.refPrefix
+ branch
] = \
2830 print "branches: %s" % self
.p4BranchesInGit
2833 for branch
in self
.p4BranchesInGit
:
2834 logMsg
= extractLogMessageFromGitCommit(self
.refPrefix
+ branch
)
2836 settings
= extractSettingsGitLog(logMsg
)
2838 self
.readOptions(settings
)
2839 if (settings
.has_key('depot-paths')
2840 and settings
.has_key ('change')):
2841 change
= int(settings
['change']) + 1
2842 p4Change
= max(p4Change
, change
)
2844 depotPaths
= sorted(settings
['depot-paths'])
2845 if self
.previousDepotPaths
== []:
2846 self
.previousDepotPaths
= depotPaths
2849 for (prev
, cur
) in zip(self
.previousDepotPaths
, depotPaths
):
2850 prev_list
= prev
.split("/")
2851 cur_list
= cur
.split("/")
2852 for i
in range(0, min(len(cur_list
), len(prev_list
))):
2853 if cur_list
[i
] <> prev_list
[i
]:
2857 paths
.append ("/".join(cur_list
[:i
+ 1]))
2859 self
.previousDepotPaths
= paths
2862 self
.depotPaths
= sorted(self
.previousDepotPaths
)
2863 self
.changeRange
= "@%s,#head" % p4Change
2864 if not self
.silent
and not self
.detectBranches
:
2865 print "Performing incremental import into %s git branch" % self
.branch
2867 # accept multiple ref name abbreviations:
2868 # refs/foo/bar/branch -> use it exactly
2869 # p4/branch -> prepend refs/remotes/ or refs/heads/
2870 # branch -> prepend refs/remotes/p4/ or refs/heads/p4/
2871 if not self
.branch
.startswith("refs/"):
2872 if self
.importIntoRemotes
:
2873 prepend
= "refs/remotes/"
2875 prepend
= "refs/heads/"
2876 if not self
.branch
.startswith("p4/"):
2878 self
.branch
= prepend
+ self
.branch
2880 if len(args
) == 0 and self
.depotPaths
:
2882 print "Depot paths: %s" % ' '.join(self
.depotPaths
)
2884 if self
.depotPaths
and self
.depotPaths
!= args
:
2885 print ("previous import used depot path %s and now %s was specified. "
2886 "This doesn't work!" % (' '.join (self
.depotPaths
),
2890 self
.depotPaths
= sorted(args
)
2895 # Make sure no revision specifiers are used when --changesfile
2897 bad_changesfile
= False
2898 if len(self
.changesFile
) > 0:
2899 for p
in self
.depotPaths
:
2900 if p
.find("@") >= 0 or p
.find("#") >= 0:
2901 bad_changesfile
= True
2904 die("Option --changesfile is incompatible with revision specifiers")
2907 for p
in self
.depotPaths
:
2908 if p
.find("@") != -1:
2909 atIdx
= p
.index("@")
2910 self
.changeRange
= p
[atIdx
:]
2911 if self
.changeRange
== "@all":
2912 self
.changeRange
= ""
2913 elif ',' not in self
.changeRange
:
2914 revision
= self
.changeRange
2915 self
.changeRange
= ""
2917 elif p
.find("#") != -1:
2918 hashIdx
= p
.index("#")
2919 revision
= p
[hashIdx
:]
2921 elif self
.previousDepotPaths
== []:
2922 # pay attention to changesfile, if given, else import
2923 # the entire p4 tree at the head revision
2924 if len(self
.changesFile
) == 0:
2927 p
= re
.sub ("\.\.\.$", "", p
)
2928 if not p
.endswith("/"):
2933 self
.depotPaths
= newPaths
2935 # --detect-branches may change this for each branch
2936 self
.branchPrefixes
= self
.depotPaths
2938 self
.loadUserMapFromCache()
2940 if self
.detectLabels
:
2943 if self
.detectBranches
:
2944 ## FIXME - what's a P4 projectName ?
2945 self
.projectName
= self
.guessProjectName()
2948 self
.getBranchMappingFromGitBranches()
2950 self
.getBranchMapping()
2952 print "p4-git branches: %s" % self
.p4BranchesInGit
2953 print "initial parents: %s" % self
.initialParents
2954 for b
in self
.p4BranchesInGit
:
2958 b
= b
[len(self
.projectName
):]
2959 self
.createdBranches
.add(b
)
2961 self
.tz
= "%+03d%02d" % (- time
.timezone
/ 3600, ((- time
.timezone
% 3600) / 60))
2963 self
.importProcess
= subprocess
.Popen(["git", "fast-import"],
2964 stdin
=subprocess
.PIPE
,
2965 stdout
=subprocess
.PIPE
,
2966 stderr
=subprocess
.PIPE
);
2967 self
.gitOutput
= self
.importProcess
.stdout
2968 self
.gitStream
= self
.importProcess
.stdin
2969 self
.gitError
= self
.importProcess
.stderr
2972 self
.importHeadRevision(revision
)
2976 if len(self
.changesFile
) > 0:
2977 output
= open(self
.changesFile
).readlines()
2980 changeSet
.add(int(line
))
2982 for change
in changeSet
:
2983 changes
.append(change
)
2987 # catch "git p4 sync" with no new branches, in a repo that
2988 # does not have any existing p4 branches
2990 if not self
.p4BranchesInGit
:
2991 die("No remote p4 branches. Perhaps you never did \"git p4 clone\" in here.")
2993 # The default branch is master, unless --branch is used to
2994 # specify something else. Make sure it exists, or complain
2995 # nicely about how to use --branch.
2996 if not self
.detectBranches
:
2997 if not branch_exists(self
.branch
):
2998 if branch_arg_given
:
2999 die("Error: branch %s does not exist." % self
.branch
)
3001 die("Error: no branch %s; perhaps specify one with --branch." %
3005 print "Getting p4 changes for %s...%s" % (', '.join(self
.depotPaths
),
3007 changes
= p4ChangesForPaths(self
.depotPaths
, self
.changeRange
)
3009 if len(self
.maxChanges
) > 0:
3010 changes
= changes
[:min(int(self
.maxChanges
), len(changes
))]
3012 if len(changes
) == 0:
3014 print "No changes to import!"
3016 if not self
.silent
and not self
.detectBranches
:
3017 print "Import destination: %s" % self
.branch
3019 self
.updatedBranches
= set()
3021 if not self
.detectBranches
:
3023 # start a new branch
3024 self
.initialParent
= ""
3026 # build on a previous revision
3027 self
.initialParent
= parseRevision(self
.branch
)
3029 self
.importChanges(changes
)
3033 if len(self
.updatedBranches
) > 0:
3034 sys
.stdout
.write("Updated branches: ")
3035 for b
in self
.updatedBranches
:
3036 sys
.stdout
.write("%s " % b
)
3037 sys
.stdout
.write("\n")
3039 if gitConfig("git-p4.importLabels", "--bool") == "true":
3040 self
.importLabels
= True
3042 if self
.importLabels
:
3043 p4Labels
= getP4Labels(self
.depotPaths
)
3044 gitTags
= getGitTags()
3046 missingP4Labels
= p4Labels
- gitTags
3047 self
.importP4Labels(self
.gitStream
, missingP4Labels
)
3049 self
.gitStream
.close()
3050 if self
.importProcess
.wait() != 0:
3051 die("fast-import failed: %s" % self
.gitError
.read())
3052 self
.gitOutput
.close()
3053 self
.gitError
.close()
3055 # Cleanup temporary branches created during import
3056 if self
.tempBranches
!= []:
3057 for branch
in self
.tempBranches
:
3058 read_pipe("git update-ref -d %s" % branch
)
3059 os
.rmdir(os
.path
.join(os
.environ
.get("GIT_DIR", ".git"), self
.tempBranchLocation
))
3061 # Create a symbolic ref p4/HEAD pointing to p4/<branch> to allow
3062 # a convenient shortcut refname "p4".
3063 if self
.importIntoRemotes
:
3064 head_ref
= self
.refPrefix
+ "HEAD"
3065 if not gitBranchExists(head_ref
) and gitBranchExists(self
.branch
):
3066 system(["git", "symbolic-ref", head_ref
, self
.branch
])
3070 class P4Rebase(Command
):
3072 Command
.__init
__(self
)
3074 optparse
.make_option("--import-labels", dest
="importLabels", action
="store_true"),
3076 self
.importLabels
= False
3077 self
.description
= ("Fetches the latest revision from perforce and "
3078 + "rebases the current work (branch) against it")
3080 def run(self
, args
):
3082 sync
.importLabels
= self
.importLabels
3085 return self
.rebase()
3088 if os
.system("git update-index --refresh") != 0:
3089 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.");
3090 if len(read_pipe("git diff-index HEAD --")) > 0:
3091 die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
3093 [upstream
, settings
] = findUpstreamBranchPoint()
3094 if len(upstream
) == 0:
3095 die("Cannot find upstream branchpoint for rebase")
3097 # the branchpoint may be p4/foo~3, so strip off the parent
3098 upstream
= re
.sub("~[0-9]+$", "", upstream
)
3100 print "Rebasing the current branch onto %s" % upstream
3101 oldHead
= read_pipe("git rev-parse HEAD").strip()
3102 system("git rebase %s" % upstream
)
3103 system("git diff-tree --stat --summary -M %s HEAD" % oldHead
)
3106 class P4Clone(P4Sync
):
3108 P4Sync
.__init
__(self
)
3109 self
.description
= "Creates a new git repository and imports from Perforce into it"
3110 self
.usage
= "usage: %prog [options] //depot/path[@revRange]"
3112 optparse
.make_option("--destination", dest
="cloneDestination",
3113 action
='store', default
=None,
3114 help="where to leave result of the clone"),
3115 optparse
.make_option("-/", dest
="cloneExclude",
3116 action
="append", type="string",
3117 help="exclude depot path"),
3118 optparse
.make_option("--bare", dest
="cloneBare",
3119 action
="store_true", default
=False),
3121 self
.cloneDestination
= None
3122 self
.needsGit
= False
3123 self
.cloneBare
= False
3125 # This is required for the "append" cloneExclude action
3126 def ensure_value(self
, attr
, value
):
3127 if not hasattr(self
, attr
) or getattr(self
, attr
) is None:
3128 setattr(self
, attr
, value
)
3129 return getattr(self
, attr
)
3131 def defaultDestination(self
, args
):
3132 ## TODO: use common prefix of args?
3134 depotDir
= re
.sub("(@[^@]*)$", "", depotPath
)
3135 depotDir
= re
.sub("(#[^#]*)$", "", depotDir
)
3136 depotDir
= re
.sub(r
"\.\.\.$", "", depotDir
)
3137 depotDir
= re
.sub(r
"/$", "", depotDir
)
3138 return os
.path
.split(depotDir
)[1]
3140 def run(self
, args
):
3144 if self
.keepRepoPath
and not self
.cloneDestination
:
3145 sys
.stderr
.write("Must specify destination for --keep-path\n")
3150 if not self
.cloneDestination
and len(depotPaths
) > 1:
3151 self
.cloneDestination
= depotPaths
[-1]
3152 depotPaths
= depotPaths
[:-1]
3154 self
.cloneExclude
= ["/"+p
for p
in self
.cloneExclude
]
3155 for p
in depotPaths
:
3156 if not p
.startswith("//"):
3157 sys
.stderr
.write('Depot paths must start with "//": %s\n' % p
)
3160 if not self
.cloneDestination
:
3161 self
.cloneDestination
= self
.defaultDestination(args
)
3163 print "Importing from %s into %s" % (', '.join(depotPaths
), self
.cloneDestination
)
3165 if not os
.path
.exists(self
.cloneDestination
):
3166 os
.makedirs(self
.cloneDestination
)
3167 chdir(self
.cloneDestination
)
3169 init_cmd
= [ "git", "init" ]
3171 init_cmd
.append("--bare")
3172 subprocess
.check_call(init_cmd
)
3174 if not P4Sync
.run(self
, depotPaths
):
3177 # create a master branch and check out a work tree
3178 if gitBranchExists(self
.branch
):
3179 system([ "git", "branch", "master", self
.branch
])
3180 if not self
.cloneBare
:
3181 system([ "git", "checkout", "-f" ])
3183 print 'Not checking out any branch, use ' \
3184 '"git checkout -q -b master <branch>"'
3186 # auto-set this variable if invoked with --use-client-spec
3187 if self
.useClientSpec_from_options
:
3188 system("git config --bool git-p4.useclientspec true")
3192 class P4Branches(Command
):
3194 Command
.__init
__(self
)
3196 self
.description
= ("Shows the git branches that hold imports and their "
3197 + "corresponding perforce depot paths")
3198 self
.verbose
= False
3200 def run(self
, args
):
3201 if originP4BranchesExist():
3202 createOrUpdateBranchesFromOrigin()
3204 cmdline
= "git rev-parse --symbolic "
3205 cmdline
+= " --remotes"
3207 for line
in read_pipe_lines(cmdline
):
3210 if not line
.startswith('p4/') or line
== "p4/HEAD":
3214 log
= extractLogMessageFromGitCommit("refs/remotes/%s" % branch
)
3215 settings
= extractSettingsGitLog(log
)
3217 print "%s <= %s (%s)" % (branch
, ",".join(settings
["depot-paths"]), settings
["change"])
3220 class HelpFormatter(optparse
.IndentedHelpFormatter
):
3222 optparse
.IndentedHelpFormatter
.__init
__(self
)
3224 def format_description(self
, description
):
3226 return description
+ "\n"
3230 def printUsage(commands
):
3231 print "usage: %s <command> [options]" % sys
.argv
[0]
3233 print "valid commands: %s" % ", ".join(commands
)
3235 print "Try %s <command> --help for command specific help." % sys
.argv
[0]
3240 "submit" : P4Submit
,
3241 "commit" : P4Submit
,
3243 "rebase" : P4Rebase
,
3245 "rollback" : P4RollBack
,
3246 "branches" : P4Branches
3251 if len(sys
.argv
[1:]) == 0:
3252 printUsage(commands
.keys())
3255 cmdName
= sys
.argv
[1]
3257 klass
= commands
[cmdName
]
3260 print "unknown command %s" % cmdName
3262 printUsage(commands
.keys())
3265 options
= cmd
.options
3266 cmd
.gitdir
= os
.environ
.get("GIT_DIR", None)
3270 options
.append(optparse
.make_option("--verbose", "-v", dest
="verbose", action
="store_true"))
3272 options
.append(optparse
.make_option("--git-dir", dest
="gitdir"))
3274 parser
= optparse
.OptionParser(cmd
.usage
.replace("%prog", "%prog " + cmdName
),
3276 description
= cmd
.description
,
3277 formatter
= HelpFormatter())
3279 (cmd
, args
) = parser
.parse_args(sys
.argv
[2:], cmd
);
3281 verbose
= cmd
.verbose
3283 if cmd
.gitdir
== None:
3284 cmd
.gitdir
= os
.path
.abspath(".git")
3285 if not isValidGitDir(cmd
.gitdir
):
3286 cmd
.gitdir
= read_pipe("git rev-parse --git-dir").strip()
3287 if os
.path
.exists(cmd
.gitdir
):
3288 cdup
= read_pipe("git rev-parse --show-cdup").strip()
3292 if not isValidGitDir(cmd
.gitdir
):
3293 if isValidGitDir(cmd
.gitdir
+ "/.git"):
3294 cmd
.gitdir
+= "/.git"
3296 die("fatal: cannot locate git repository at %s" % cmd
.gitdir
)
3298 os
.environ
["GIT_DIR"] = cmd
.gitdir
3300 if not cmd
.run(args
):
3305 if __name__
== '__main__':