2007-03-19 20:59:12 +01:00
#!/usr/bin/env python
#
# git-p4.py -- A tool for bidirectional operation between a Perforce depot and git.
#
2007-05-28 14:43:25 +02:00
# Author: Simon Hausmann <simon@lst.de>
# Copyright: 2007 Simon Hausmann <simon@lst.de>
2007-03-19 22:26:36 +01:00
# 2007 Trolltech ASA
2007-03-19 20:59:12 +01:00
# License: MIT <http://www.opensource.org/licenses/mit-license.php>
#
2007-05-15 14:31:06 +02:00
import optparse, sys, os, marshal, popen2, subprocess, shelve
2007-05-15 15:15:39 +02:00
import tempfile, getopt, sha, os.path, time, platform
2007-05-23 21:46:29 +02:00
import re
2007-05-23 23:20:53 +02:00
2007-03-20 20:54:23 +01:00
from sets import Set;
2007-03-19 22:25:17 +01:00
2007-05-23 23:49:35 +02:00
verbose = False
2007-03-19 20:59:12 +01:00
2007-05-23 23:49:35 +02:00
def die(msg):
if verbose:
raise Exception(msg)
else:
sys.stderr.write(msg + "\n")
sys.exit(1)
2007-05-23 22:14:33 +02:00
def write_pipe(c, str):
2007-05-23 23:49:35 +02:00
if verbose:
2007-05-23 23:49:35 +02:00
sys.stderr.write('Writing pipe: %s\n' % c)
2007-05-23 22:10:46 +02:00
2007-05-23 22:14:33 +02:00
pipe = os.popen(c, 'w')
2007-05-23 22:10:46 +02:00
val = pipe.write(str)
2007-05-23 22:14:33 +02:00
if pipe.close():
2007-05-23 23:49:35 +02:00
die('Command failed: %s' % c)
2007-05-23 22:10:46 +02:00
return val
2007-05-23 23:49:35 +02:00
def read_pipe(c, ignore_error=False):
if verbose:
2007-05-23 23:49:35 +02:00
sys.stderr.write('Reading pipe: %s\n' % c)
2007-05-23 23:20:53 +02:00
2007-05-23 22:14:33 +02:00
pipe = os.popen(c, 'rb')
2007-05-23 22:10:46 +02:00
val = pipe.read()
2007-05-23 23:49:35 +02:00
if pipe.close() and not ignore_error:
2007-05-23 23:49:35 +02:00
die('Command failed: %s' % c)
2007-05-23 22:10:46 +02:00
return val
2007-05-23 22:14:33 +02:00
def read_pipe_lines(c):
2007-05-23 23:49:35 +02:00
if verbose:
2007-05-23 23:49:35 +02:00
sys.stderr.write('Reading pipe: %s\n' % c)
2007-05-23 22:10:46 +02:00
## todo: check return status
2007-05-23 22:14:33 +02:00
pipe = os.popen(c, 'rb')
2007-05-23 22:10:46 +02:00
val = pipe.readlines()
2007-05-23 22:14:33 +02:00
if pipe.close():
2007-05-23 23:49:35 +02:00
die('Command failed: %s' % c)
2007-05-23 22:10:46 +02:00
return val
2007-05-15 14:57:57 +02:00
2007-05-23 22:41:50 +02:00
def system(cmd):
2007-05-23 23:49:35 +02:00
if verbose:
2007-05-23 23:49:35 +02:00
sys.stderr.write("executing %s\n" % cmd)
2007-05-23 22:41:50 +02:00
if os.system(cmd) != 0:
die("command failed: %s" % cmd)
2007-09-19 22:12:48 +02:00
def isP4Exec(kind):
"""Determine if a Perforce 'kind' should have execute permission
'p4 help filetypes' gives a list of the types. If it starts with 'x',
or x follows one of a few letters. Otherwise, if there is an 'x' after
a plus sign, it is also executable"""
return (re.search(r"(^[cku]?x)|\+.*x", kind) != None)
2007-11-02 04:43:14 +01:00
def setP4ExecBit(file, mode):
# Reopens an already open file and changes the execute bit to match
# the execute bit setting in the passed in mode.
p4Type = "+x"
if not isModeExec(mode):
p4Type = getP4OpenedType(file)
p4Type = re.sub('^([cku]?)x(.*)', '\\1\\2', p4Type)
p4Type = re.sub('(.*?\+.*?)x(.*?)', '\\1\\2', p4Type)
if p4Type[-1] == "+":
p4Type = p4Type[0:-1]
system("p4 reopen -t %s %s" % (p4Type, file))
def getP4OpenedType(file):
# Returns the perforce file type for the given file.
result = read_pipe("p4 opened %s" % file)
match = re.match(".*\((.+)\)$", result)
if match:
return match.group(1)
else:
die("Could not determine file type for %s" % file)
2007-11-02 04:43:13 +01:00
def diffTreePattern():
# This is a simple generator for the diff tree regex pattern. This could be
# a class variable if this and parseDiffTreeEntry were a part of a class.
pattern = re.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)')
while True:
yield pattern
def parseDiffTreeEntry(entry):
"""Parses a single diff tree entry into its component elements.
See git-diff-tree(1) manpage for details about the format of the diff
output. This method returns a dictionary with the following elements:
src_mode - The mode of the source file
dst_mode - The mode of the destination file
src_sha1 - The sha1 for the source file
dst_sha1 - The sha1 fr the destination file
status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc)
status_score - The score for the status (applicable for 'C' and 'R'
statuses). This is None if there is no score.
src - The path for the source file.
dst - The path for the destination file. This is only present for
copy or renames. If it is not present, this is None.
If the pattern is not matched, None is returned."""
match = diffTreePattern().next().match(entry)
if match:
return {
'src_mode': match.group(1),
'dst_mode': match.group(2),
'src_sha1': match.group(3),
'dst_sha1': match.group(4),
'status': match.group(5),
'status_score': match.group(6),
'src': match.group(7),
'dst': match.group(10)
}
return None
2007-11-02 04:43:14 +01:00
def isModeExec(mode):
# Returns True if the given git mode represents an executable file,
# otherwise False.
return mode[-3:] == "755"
def isModeExecChanged(src_mode, dst_mode):
return isModeExec(src_mode) != isModeExec(dst_mode)
2007-07-16 05:58:10 +02:00
def p4CmdList(cmd, stdin=None, stdin_mode='w+b'):
2007-03-19 20:59:12 +01:00
cmd = "p4 -G %s" % cmd
2007-05-23 23:49:35 +02:00
if verbose:
sys.stderr.write("Opening pipe: %s\n" % cmd)
2007-07-16 05:58:10 +02:00
# Use a temporary file to avoid deadlocks without
# subprocess.communicate(), which would put another copy
# of stdout into memory.
stdin_file = None
if stdin is not None:
stdin_file = tempfile.TemporaryFile(prefix='p4-stdin', mode=stdin_mode)
stdin_file.write(stdin)
stdin_file.flush()
stdin_file.seek(0)
p4 = subprocess.Popen(cmd, shell=True,
stdin=stdin_file,
stdout=subprocess.PIPE)
2007-03-19 20:59:12 +01:00
result = []
try:
while True:
2007-07-16 05:58:10 +02:00
entry = marshal.load(p4.stdout)
2007-03-19 20:59:12 +01:00
result.append(entry)
except EOFError:
pass
2007-07-16 05:58:10 +02:00
exitCode = p4.wait()
if exitCode != 0:
2007-05-23 23:32:32 +02:00
entry = {}
entry["p4ExitCode"] = exitCode
result.append(entry)
2007-03-19 20:59:12 +01:00
return result
def p4Cmd(cmd):
list = p4CmdList(cmd)
result = {}
for entry in list:
result.update(entry)
return result;
2007-03-24 09:15:11 +01:00
def p4Where(depotPath):
if not depotPath.endswith("/"):
depotPath += "/"
output = p4Cmd("where %s..." % depotPath)
2007-05-21 09:34:56 +02:00
if output["code"] == "error":
return ""
2007-03-24 09:15:11 +01:00
clientPath = ""
if "path" in output:
clientPath = output.get("path")
elif "data" in output:
data = output.get("data")
lastSpace = data.rfind(" ")
clientPath = data[lastSpace + 1:]
if clientPath.endswith("..."):
clientPath = clientPath[:-3]
return clientPath
2007-03-19 20:59:12 +01:00
def currentGitBranch():
2007-05-23 23:49:35 +02:00
return read_pipe("git name-rev HEAD").split(" ")[1].strip()
2007-03-19 20:59:12 +01:00
2007-03-19 22:25:17 +01:00
def isValidGitDir(path):
2007-05-23 23:49:35 +02:00
if (os.path.exists(path + "/HEAD")
and os.path.exists(path + "/refs") and os.path.exists(path + "/objects")):
2007-03-19 22:25:17 +01:00
return True;
return False
2007-05-17 09:13:54 +02:00
def parseRevision(ref):
2007-05-23 23:49:35 +02:00
return read_pipe("git rev-parse %s" % ref).strip()
2007-05-17 09:13:54 +02:00
2007-03-22 21:10:25 +01:00
def extractLogMessageFromGitCommit(commit):
logMessage = ""
2007-05-23 22:10:46 +02:00
## fixme: title is first line of commit, not 1st paragraph.
2007-03-22 21:10:25 +01:00
foundTitle = False
2007-05-23 22:10:46 +02:00
for log in read_pipe_lines("git cat-file commit %s" % commit):
2007-03-22 21:10:25 +01:00
if not foundTitle:
if len(log) == 1:
2007-05-01 23:15:48 +02:00
foundTitle = True
2007-03-22 21:10:25 +01:00
continue
logMessage += log
return logMessage
2007-05-23 23:49:35 +02:00
def extractSettingsGitLog(log):
2007-03-22 21:10:25 +01:00
values = {}
for line in log.split("\n"):
line = line.strip()
2007-05-23 23:49:35 +02:00
m = re.search (r"^ *\[git-p4: (.*)\]$", line)
if not m:
continue
assignments = m.group(1).split (':')
for a in assignments:
vals = a.split ('=')
key = vals[0].strip()
val = ('='.join (vals[1:])).strip()
if val.endswith ('\"') and val.startswith('"'):
val = val[1:-1]
values[key] = val
2007-06-07 09:19:34 +02:00
paths = values.get("depot-paths")
if not paths:
paths = values.get("depot-path")
2007-06-07 22:54:32 +02:00
if paths:
values['depot-paths'] = paths.split(',')
2007-05-23 23:49:35 +02:00
return values
2007-03-22 21:10:25 +01:00
2007-03-22 21:27:14 +01:00
def gitBranchExists(branch):
2007-05-23 23:49:35 +02:00
proc = subprocess.Popen(["git", "rev-parse", branch],
stderr=subprocess.PIPE, stdout=subprocess.PIPE);
2007-05-15 14:57:57 +02:00
return proc.wait() == 0;
2007-03-22 21:27:14 +01:00
2007-05-25 10:36:10 +02:00
def gitConfig(key):
2007-05-23 23:49:35 +02:00
return read_pipe("git config %s" % key, ignore_error=True).strip()
2007-05-25 10:36:10 +02:00
2007-07-18 10:56:31 +02:00
def p4BranchesInGit(branchesAreInRemotes = True):
branches = {}
cmdline = "git rev-parse --symbolic "
if branchesAreInRemotes:
cmdline += " --remotes"
else:
cmdline += " --branches"
for line in read_pipe_lines(cmdline):
line = line.strip()
## only import to p4/
if not line.startswith('p4/') or line == "p4/HEAD":
continue
branch = line
# strip off p4
branch = re.sub ("^p4/", "", line)
branches[branch] = parseRevision(line)
return branches
2007-06-22 00:01:57 +02:00
def findUpstreamBranchPoint(head = "HEAD"):
2007-07-18 12:40:12 +02:00
branches = p4BranchesInGit()
# map from depot-path to branch name
branchByDepotPath = {}
for branch in branches.keys():
tip = branches[branch]
log = extractLogMessageFromGitCommit(tip)
settings = extractSettingsGitLog(log)
if settings.has_key("depot-paths"):
paths = ",".join(settings["depot-paths"])
branchByDepotPath[paths] = "remotes/p4/" + branch
2007-06-12 14:31:59 +02:00
settings = None
parent = 0
while parent < 65535:
2007-06-22 00:01:57 +02:00
commit = head + "~%s" % parent
2007-06-12 14:31:59 +02:00
log = extractLogMessageFromGitCommit(commit)
settings = extractSettingsGitLog(log)
2007-07-18 12:40:12 +02:00
if settings.has_key("depot-paths"):
paths = ",".join(settings["depot-paths"])
if branchByDepotPath.has_key(paths):
return [branchByDepotPath[paths], settings]
2007-06-12 14:31:59 +02:00
2007-07-18 12:40:12 +02:00
parent = parent + 1
2007-06-12 14:31:59 +02:00
2007-07-18 12:40:12 +02:00
return ["", settings]
2007-06-12 14:31:59 +02:00
2007-08-24 17:44:16 +02:00
def createOrUpdateBranchesFromOrigin(localRefPrefix = "refs/remotes/p4/", silent=True):
if not silent:
print ("Creating/updating branch(es) in %s based on origin branch(es)"
% localRefPrefix)
originPrefix = "origin/p4/"
for line in read_pipe_lines("git rev-parse --symbolic --remotes"):
line = line.strip()
if (not line.startswith(originPrefix)) or line.endswith("HEAD"):
continue
headName = line[len(originPrefix):]
remoteHead = localRefPrefix + headName
originHead = line
original = extractSettingsGitLog(extractLogMessageFromGitCommit(originHead))
if (not original.has_key('depot-paths')
or not original.has_key('change')):
continue
update = False
if not gitBranchExists(remoteHead):
if verbose:
print "creating %s" % remoteHead
update = True
else:
settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead))
if settings.has_key('change') > 0:
if settings['depot-paths'] == original['depot-paths']:
originP4Change = int(original['change'])
p4Change = int(settings['change'])
if originP4Change > p4Change:
print ("%s (%s) is newer than %s (%s). "
"Updating p4 branch from origin."
% (originHead, originP4Change,
remoteHead, p4Change))
update = True
else:
print ("Ignoring: %s was imported from %s while "
"%s was imported from %s"
% (originHead, ','.join(original['depot-paths']),
remoteHead, ','.join(settings['depot-paths'])))
if update:
system("git update-ref %s %s" % (remoteHead, originHead))
def originP4BranchesExist():
return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
2007-08-26 15:56:36 +02:00
def p4ChangesForPaths(depotPaths, changeRange):
assert depotPaths
output = read_pipe_lines("p4 changes " + ' '.join (["%s...%s" % (p, changeRange)
for p in depotPaths]))
changes = []
for line in output:
changeNum = line.split(" ")[1]
changes.append(int(changeNum))
changes.sort()
return changes
2007-03-20 20:54:23 +01:00
class Command:
def __init__(self):
self.usage = "usage: %prog [options]"
2007-03-26 08:18:55 +02:00
self.needsGit = True
2007-03-20 20:54:23 +01:00
class P4Debug(Command):
2007-03-19 20:59:12 +01:00
def __init__(self):
2007-03-22 21:10:25 +01:00
Command.__init__(self)
2007-03-19 20:59:12 +01:00
self.options = [
2007-05-23 23:49:35 +02:00
optparse.make_option("--verbose", dest="verbose", action="store_true",
default=False),
2007-05-23 23:49:35 +02:00
]
2007-03-19 21:02:30 +01:00
self.description = "A tool to debug the output of p4 -G."
2007-03-26 08:18:55 +02:00
self.needsGit = False
2007-05-23 23:49:35 +02:00
self.verbose = False
2007-03-19 20:59:12 +01:00
def run(self, args):
2007-05-23 23:49:35 +02:00
j = 0
2007-03-19 20:59:12 +01:00
for output in p4CmdList(" ".join(args)):
2007-05-23 23:49:35 +02:00
print 'Element: %d' % j
j += 1
2007-03-19 20:59:12 +01:00
print output
2007-03-20 20:54:23 +01:00
return True
2007-03-19 20:59:12 +01:00
2007-05-21 22:57:06 +02:00
class P4RollBack(Command):
def __init__(self):
Command.__init__(self)
self.options = [
2007-05-23 20:07:57 +02:00
optparse.make_option("--verbose", dest="verbose", action="store_true"),
optparse.make_option("--local", dest="rollbackLocalBranches", action="store_true")
2007-05-21 22:57:06 +02:00
]
self.description = "A tool to debug the multi-branch import. Don't use :)"
2007-05-21 23:44:24 +02:00
self.verbose = False
2007-05-23 20:07:57 +02:00
self.rollbackLocalBranches = False
2007-05-21 22:57:06 +02:00
def run(self, args):
if len(args) != 1:
return False
maxChange = int(args[0])
2007-05-23 20:07:57 +02:00
2007-05-23 23:44:19 +02:00
if "p4ExitCode" in p4Cmd("changes -m 1"):
2007-05-23 23:40:48 +02:00
die("Problems executing p4");
2007-05-23 20:07:57 +02:00
if self.rollbackLocalBranches:
refPrefix = "refs/heads/"
2007-05-23 22:10:46 +02:00
lines = read_pipe_lines("git rev-parse --symbolic --branches")
2007-05-23 20:07:57 +02:00
else:
refPrefix = "refs/remotes/"
2007-05-23 22:10:46 +02:00
lines = read_pipe_lines("git rev-parse --symbolic --remotes")
2007-05-23 20:07:57 +02:00
for line in lines:
if self.rollbackLocalBranches or (line.startswith("p4/") and line != "p4/HEAD\n"):
2007-05-23 23:49:35 +02:00
line = line.strip()
ref = refPrefix + line
2007-05-21 22:57:06 +02:00
log = extractLogMessageFromGitCommit(ref)
2007-05-23 23:49:35 +02:00
settings = extractSettingsGitLog(log)
depotPaths = settings['depot-paths']
change = settings['change']
2007-05-21 22:57:06 +02:00
changed = False
2007-05-21 23:44:24 +02:00
2007-05-23 23:49:35 +02:00
if len(p4Cmd("changes -m 1 " + ' '.join (['%s...@%s' % (p, maxChange)
for p in depotPaths]))) == 0:
2007-05-21 23:44:24 +02:00
print "Branch %s did not exist at change %s, deleting." % (ref, maxChange)
system("git update-ref -d %s `git rev-parse %s`" % (ref, ref))
continue
2007-05-23 23:49:35 +02:00
while change and int(change) > maxChange:
2007-05-21 22:57:06 +02:00
changed = True
2007-05-21 23:44:24 +02:00
if self.verbose:
print "%s is at %s ; rewinding towards %s" % (ref, change, maxChange)
2007-05-21 22:57:06 +02:00
system("git update-ref %s \"%s^\"" % (ref, ref))
log = extractLogMessageFromGitCommit(ref)
2007-05-23 23:49:35 +02:00
settings = extractSettingsGitLog(log)
depotPaths = settings['depot-paths']
change = settings['change']
2007-05-21 22:57:06 +02:00
if changed:
2007-05-21 23:44:24 +02:00
print "%s rewound to %s" % (ref, change)
2007-05-21 22:57:06 +02:00
return True
2007-04-01 15:40:46 +02:00
class P4Submit(Command):
2007-03-19 22:25:17 +01:00
def __init__(self):
2007-03-20 20:54:23 +01:00
Command.__init__(self)
2007-03-19 22:25:17 +01:00
self.options = [
optparse.make_option("--continue", action="store_false", dest="firstTime"),
2007-05-23 23:49:35 +02:00
optparse.make_option("--verbose", dest="verbose", action="store_true"),
2007-03-19 22:25:17 +01:00
optparse.make_option("--origin", dest="origin"),
optparse.make_option("--reset", action="store_true", dest="reset"),
2007-10-16 07:15:06 +02:00
optparse.make_option("-M", dest="detectRename", action="store_true"),
2007-03-19 22:25:17 +01:00
]
self.description = "Submit changes from git to the perforce depot."
2007-03-29 19:15:24 +02:00
self.usage += " [name of git branch to submit into perforce depot]"
2007-03-19 22:25:17 +01:00
self.firstTime = True
self.reset = False
self.interactive = True
self.firstTime = True
2007-03-23 09:16:07 +01:00
self.origin = ""
2007-10-16 07:15:06 +02:00
self.detectRename = False
2007-06-07 13:09:14 +02:00
self.verbose = False
2007-06-07 14:07:01 +02:00
self.isWindows = (platform.system() == "Windows")
2007-03-19 22:25:17 +01:00
def check(self):
if len(p4CmdList("opened ...")) > 0:
die("You have files opened with perforce! Close them before starting the sync.")
def start(self):
if len(self.config) > 0 and not self.reset:
2007-05-23 21:53:11 +02:00
die("Cannot start sync. Previous sync config found at %s\n"
"If you want to start submitting again from scratch "
"maybe you want to call git-p4 submit --reset" % self.configFile)
2007-03-19 22:25:17 +01:00
commits = []
2008-02-19 09:33:08 +01:00
for line in read_pipe_lines("git rev-list --no-merges %s..%s" % (self.origin, self.master)):
commits.append(line.strip())
commits.reverse()
2007-03-19 22:25:17 +01:00
self.config["commits"] = commits
2008-02-19 09:29:06 +01:00
# replaces everything between 'Description:' and the next P4 submit template field with the
# commit message
2007-03-19 22:25:17 +01:00
def prepareLogMessage(self, template, message):
result = ""
2008-02-19 09:29:06 +01:00
inDescriptionSection = False
2007-03-19 22:25:17 +01:00
for line in template.split("\n"):
if line.startswith("#"):
result += line + "\n"
continue
2008-02-19 09:29:06 +01:00
if inDescriptionSection:
if line.startswith("Files:"):
inDescriptionSection = False
else:
continue
else:
if line.startswith("Description:"):
inDescriptionSection = True
line += "\n"
for messageLine in message.split("\n"):
line += "\t" + messageLine + "\n"
result += line + "\n"
2007-03-19 22:25:17 +01:00
return result
2007-08-08 17:06:55 +02:00
def prepareSubmitTemplate(self):
# remove lines in the Files section that show changes to files outside the depot path we're committing into
template = ""
inFilesSection = False
for line in read_pipe_lines("p4 change -o"):
if inFilesSection:
if line.startswith("\t"):
# path starts and ends with a tab
path = line[1:]
lastTab = path.rfind("\t")
if lastTab != -1:
path = path[:lastTab]
if not path.startswith(self.depotPath):
continue
else:
inFilesSection = False
else:
if line.startswith("Files:"):
inFilesSection = True
template += line
return template
2007-05-23 21:55:48 +02:00
def applyCommit(self, id):
2008-02-19 09:33:08 +01:00
print "Applying %s" % (read_pipe("git log --max-count=1 --pretty=oneline %s" % id))
diffOpts = ("", "-M")[self.detectRename]
diff = read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (diffOpts, id, id))
2007-03-19 22:25:17 +01:00
filesToAdd = set()
filesToDelete = set()
2007-05-16 09:41:26 +02:00
editedFiles = set()
2007-11-02 04:43:14 +01:00
filesToChangeExecBit = {}
2007-03-19 22:25:17 +01:00
for line in diff:
2007-11-02 04:43:13 +01:00
diff = parseDiffTreeEntry(line)
modifier = diff['status']
path = diff['src']
2007-03-19 22:25:17 +01:00
if modifier == "M":
2007-05-16 09:41:26 +02:00
system("p4 edit \"%s\"" % path)
2007-11-02 04:43:14 +01:00
if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
filesToChangeExecBit[path] = diff['dst_mode']
2007-05-16 09:41:26 +02:00
editedFiles.add(path)
2007-03-19 22:25:17 +01:00
elif modifier == "A":
filesToAdd.add(path)
2007-11-02 04:43:14 +01:00
filesToChangeExecBit[path] = diff['dst_mode']
2007-03-19 22:25:17 +01:00
if path in filesToDelete:
filesToDelete.remove(path)
elif modifier == "D":
filesToDelete.add(path)
if path in filesToAdd:
filesToAdd.remove(path)
2007-10-16 07:15:06 +02:00
elif modifier == "R":
2007-11-02 04:43:13 +01:00
src, dest = diff['src'], diff['dst']
2007-10-16 07:15:06 +02:00
system("p4 integrate -Dt \"%s\" \"%s\"" % (src, dest))
system("p4 edit \"%s\"" % (dest))
2007-11-02 04:43:14 +01:00
if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
filesToChangeExecBit[dest] = diff['dst_mode']
2007-10-16 07:15:06 +02:00
os.unlink(dest)
editedFiles.add(dest)
filesToDelete.add(src)
2007-03-19 22:25:17 +01:00
else:
die("unknown modifier %s for %s" % (modifier, path))
2008-02-19 09:33:08 +01:00
diffcmd = "git format-patch -k --stdout \"%s^\"..\"%s\"" % (id, id)
2007-05-20 16:33:21 +02:00
patchcmd = diffcmd + " | git apply "
2007-05-20 16:55:05 +02:00
tryPatchCmd = patchcmd + "--check -"
applyPatchCmd = patchcmd + "--check --apply -"
2007-04-15 09:59:56 +02:00
2007-05-20 16:33:21 +02:00
if os.system(tryPatchCmd) != 0:
2007-04-15 09:59:56 +02:00
print "Unfortunately applying the change failed!"
print "What do you want to do?"
response = "x"
while response != "s" and response != "a" and response != "w":
2007-05-23 21:53:11 +02:00
response = raw_input("[s]kip this patch / [a]pply the patch forcibly "
"and with .rej files / [w]rite the patch to a file (patch.txt) ")
2007-04-15 09:59:56 +02:00
if response == "s":
print "Skipping! Good luck with the next patches..."
2007-09-13 22:10:18 +02:00
for f in editedFiles:
system("p4 revert \"%s\"" % f);
for f in filesToAdd:
system("rm %s" %f)
2007-04-15 09:59:56 +02:00
return
elif response == "a":
2007-05-20 16:33:21 +02:00
os.system(applyPatchCmd)
2007-04-15 09:59:56 +02:00
if len(filesToAdd) > 0:
print "You may also want to call p4 add on the following files:"
print " ".join(filesToAdd)
if len(filesToDelete):
print "The following files should be scheduled for deletion with p4 delete:"
print " ".join(filesToDelete)
2007-05-23 21:53:11 +02:00
die("Please resolve and submit the conflict manually and "
+ "continue afterwards with git-p4 submit --continue")
2007-04-15 09:59:56 +02:00
elif response == "w":
system(diffcmd + " > patch.txt")
print "Patch saved to patch.txt in %s !" % self.clientPath
2007-05-23 21:53:11 +02:00
die("Please resolve and submit the conflict manually and "
"continue afterwards with git-p4 submit --continue")
2007-04-15 09:59:56 +02:00
2007-05-20 16:33:21 +02:00
system(applyPatchCmd)
2007-03-19 22:25:17 +01:00
for f in filesToAdd:
2007-06-11 23:40:25 +02:00
system("p4 add \"%s\"" % f)
2007-03-19 22:25:17 +01:00
for f in filesToDelete:
2007-06-11 23:40:25 +02:00
system("p4 revert \"%s\"" % f)
system("p4 delete \"%s\"" % f)
2007-03-19 22:25:17 +01:00
2007-11-02 04:43:14 +01:00
# Set/clear executable bits
for f in filesToChangeExecBit.keys():
mode = filesToChangeExecBit[f]
setP4ExecBit(f, mode)
2008-02-19 09:33:08 +01:00
logMessage = extractLogMessageFromGitCommit(id)
if self.isWindows:
logMessage = logMessage.replace("\n", "\r\n")
logMessage = logMessage.strip()
2007-03-19 22:25:17 +01:00
2007-08-08 17:06:55 +02:00
template = self.prepareSubmitTemplate()
2007-03-19 22:25:17 +01:00
if self.interactive:
submitTemplate = self.prepareLogMessage(template, logMessage)
2007-05-23 22:10:46 +02:00
diff = read_pipe("p4 diff -du ...")
2007-03-19 22:25:17 +01:00
for newFile in filesToAdd:
diff += "==== new file ====\n"
diff += "--- /dev/null\n"
diff += "+++ %s\n" % newFile
f = open(newFile, "r")
for line in f.readlines():
diff += "+" + line
f.close()
2007-05-15 15:15:39 +02:00
separatorLine = "######## everything below this line is just the diff #######"
if platform.system() == "Windows":
separatorLine += "\r"
separatorLine += "\n"
2007-03-19 22:25:17 +01:00
2008-01-04 14:27:55 +01:00
[handle, fileName] = tempfile.mkstemp()
tmpFile = os.fdopen(handle, "w+")
tmpFile.write(submitTemplate + separatorLine + diff)
tmpFile.close()
defaultEditor = "vi"
if platform.system() == "Windows":
defaultEditor = "notepad"
editor = os.environ.get("EDITOR", defaultEditor);
system(editor + " " + fileName)
tmpFile = open(fileName, "rb")
message = tmpFile.read()
tmpFile.close()
os.remove(fileName)
submitTemplate = message[:message.index(separatorLine)]
if self.isWindows:
submitTemplate = submitTemplate.replace("\r\n", "\n")
write_pipe("p4 submit -i", submitTemplate)
2007-03-19 22:25:17 +01:00
else:
fileName = "submit.txt"
file = open(fileName, "w+")
file.write(self.prepareLogMessage(template, logMessage))
file.close()
2007-05-23 21:53:11 +02:00
print ("Perforce submit template written as %s. "
+ "Please review/edit and then use p4 submit -i < %s to submit directly!"
% (fileName, fileName))
2007-03-19 22:25:17 +01:00
def run(self, args):
2007-03-29 19:15:24 +02:00
if len(args) == 0:
self.master = currentGitBranch()
2007-05-25 08:49:18 +02:00
if len(self.master) == 0 or not gitBranchExists("refs/heads/%s" % self.master):
2007-03-29 19:15:24 +02:00
die("Detecting current git branch failed!")
elif len(args) == 1:
self.master = args[0]
else:
return False
2007-06-12 14:31:59 +02:00
[upstream, settings] = findUpstreamBranchPoint()
2007-08-08 17:06:55 +02:00
self.depotPath = settings['depot-paths'][0]
2007-06-12 14:31:59 +02:00
if len(self.origin) == 0:
self.origin = upstream
2007-06-07 22:54:32 +02:00
if self.verbose:
print "Origin branch is " + self.origin
2007-03-23 09:16:07 +01:00
2007-08-08 17:06:55 +02:00
if len(self.depotPath) == 0:
2007-03-23 09:16:07 +01:00
print "Internal error: cannot locate perforce depot path from existing branches"
sys.exit(128)
2007-08-08 17:06:55 +02:00
self.clientPath = p4Where(self.depotPath)
2007-03-23 09:16:07 +01:00
2007-04-15 09:59:56 +02:00
if len(self.clientPath) == 0:
2007-08-08 17:06:55 +02:00
print "Error: Cannot locate perforce checkout of %s in client view" % self.depotPath
2007-03-23 09:16:07 +01:00
sys.exit(128)
2007-08-08 17:06:55 +02:00
print "Perforce checkout for depot path %s located at %s" % (self.depotPath, self.clientPath)
2007-05-21 11:04:26 +02:00
self.oldWorkingDirectory = os.getcwd()
2007-05-20 16:55:05 +02:00
2007-04-15 09:59:56 +02:00
os.chdir(self.clientPath)
2007-08-21 11:53:02 +02:00
print "Syncronizing p4 checkout..."
system("p4 sync ...")
2007-03-23 09:16:07 +01:00
2007-03-19 22:25:17 +01:00
if self.reset:
self.firstTime = True
self.check()
2007-05-23 23:49:35 +02:00
self.configFile = self.gitdir + "/p4-git-sync.cfg"
2007-03-19 22:25:17 +01:00
self.config = shelve.open(self.configFile, writeback=True)
if self.firstTime:
self.start()
commits = self.config.get("commits", [])
while len(commits) > 0:
self.firstTime = False
commit = commits[0]
commits = commits[1:]
self.config["commits"] = commits
2007-05-23 21:55:48 +02:00
self.applyCommit(commit)
2007-03-19 22:25:17 +01:00
if not self.interactive:
break
self.config.close()
if len(commits) == 0:
if self.firstTime:
print "No changes found to apply between %s and current HEAD" % self.origin
else:
print "All changes applied!"
2007-05-21 11:04:26 +02:00
os.chdir(self.oldWorkingDirectory)
2007-08-22 09:07:15 +02:00
sync = P4Sync()
sync.run([])
2008-01-04 14:27:55 +01:00
rebase = P4Rebase()
rebase.rebase()
2007-03-19 22:25:17 +01:00
os.remove(self.configFile)
2007-03-20 20:54:23 +01:00
return True
2007-04-01 15:40:46 +02:00
class P4Sync(Command):
2007-03-20 20:54:23 +01:00
def __init__(self):
Command.__init__(self)
self.options = [
optparse.make_option("--branch", dest="branch"),
optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"),
optparse.make_option("--changesfile", dest="changesFile"),
optparse.make_option("--silent", dest="silent", action="store_true"),
2007-05-17 22:17:49 +02:00
optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),
2007-05-23 00:03:08 +02:00
optparse.make_option("--verbose", dest="verbose", action="store_true"),
2007-05-23 23:49:35 +02:00
optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",
help="Import into refs/heads/ , not refs/remotes"),
2007-05-23 23:20:53 +02:00
optparse.make_option("--max-changes", dest="maxChanges"),
2007-05-23 23:49:35 +02:00
optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',
help="Keep entire BRANCH/DIR/SUBDIR prefix during import")
2007-03-20 20:54:23 +01:00
]
self.description = """Imports from Perforce into a git repository.\n
example:
//depot/my/project/ -- to import the current head
//depot/my/project/@all -- to import everything
//depot/my/project/@1,6 -- to import only from revision 1 to 6
(a ... is not needed in the path p4 specification, it's added implicitly)"""
self.usage += " //depot/path[@revRange]"
self.silent = False
self.createdBranches = Set()
self.committedChanges = Set()
2007-03-22 21:34:16 +01:00
self.branch = ""
2007-03-20 20:54:23 +01:00
self.detectBranches = False
2007-04-08 00:12:02 +02:00
self.detectLabels = False
2007-03-20 20:54:23 +01:00
self.changesFile = ""
2007-05-25 10:36:10 +02:00
self.syncWithOrigin = True
2007-05-18 21:45:23 +02:00
self.verbose = False
2007-05-23 00:03:08 +02:00
self.importIntoRemotes = True
2007-05-23 00:07:35 +02:00
self.maxChanges = ""
2007-05-24 14:07:55 +02:00
self.isWindows = (platform.system() == "Windows")
2007-05-23 23:20:53 +02:00
self.keepRepoPath = False
2007-05-23 23:49:35 +02:00
self.depotPaths = None
2007-06-16 13:09:21 +02:00
self.p4BranchesInGit = []
2008-02-03 19:38:51 +01:00
self.cloneExclude = []
2007-03-20 20:54:23 +01:00
2007-05-25 10:36:10 +02:00
if gitConfig("git-p4.syncFromOrigin") == "false":
self.syncWithOrigin = False
2007-03-20 20:54:23 +01:00
def extractFilesFromCommit(self, commit):
2008-02-03 19:38:51 +01:00
self.cloneExclude = [re.sub(r"\.\.\.$", "", path)
for path in self.cloneExclude]
2007-03-20 20:54:23 +01:00
files = []
fnum = 0
while commit.has_key("depotFile%s" % fnum):
path = commit["depotFile%s" % fnum]
2007-05-23 23:49:35 +02:00
2008-02-03 19:38:51 +01:00
if [p for p in self.cloneExclude
if path.startswith (p)]:
found = False
else:
found = [p for p in self.depotPaths
if path.startswith (p)]
2007-05-23 23:49:35 +02:00
if not found:
2007-03-20 20:54:23 +01:00
fnum = fnum + 1
continue
file = {}
file["path"] = path
file["rev"] = commit["rev%s" % fnum]
file["action"] = commit["action%s" % fnum]
file["type"] = commit["type%s" % fnum]
files.append(file)
fnum = fnum + 1
return files
2007-05-23 23:49:35 +02:00
def stripRepoPath(self, path, prefixes):
2007-05-23 23:20:53 +02:00
if self.keepRepoPath:
2007-05-23 23:49:35 +02:00
prefixes = [re.sub("^(//[^/]+/).*", r'\1', prefixes[0])]
for p in prefixes:
if path.startswith(p):
path = path[len(p):]
2007-05-23 23:20:53 +02:00
2007-05-23 23:49:35 +02:00
return path
2007-05-23 22:41:50 +02:00
2007-05-19 11:54:11 +02:00
def splitFilesIntoBranches(self, commit):
2007-05-19 11:07:32 +02:00
branches = {}
2007-05-19 11:54:11 +02:00
fnum = 0
while commit.has_key("depotFile%s" % fnum):
path = commit["depotFile%s" % fnum]
2007-05-23 23:49:35 +02:00
found = [p for p in self.depotPaths
if path.startswith (p)]
if not found:
2007-05-19 11:54:11 +02:00
fnum = fnum + 1
continue
file = {}
file["path"] = path
file["rev"] = commit["rev%s" % fnum]
file["action"] = commit["action%s" % fnum]
file["type"] = commit["type%s" % fnum]
fnum = fnum + 1
2007-05-23 23:49:35 +02:00
relPath = self.stripRepoPath(path, self.depotPaths)
2007-03-20 20:54:23 +01:00
2007-05-18 21:45:23 +02:00
for branch in self.knownBranches.keys():
2007-05-23 22:41:50 +02:00
# add a trailing slash so that a commit into qt/4.2foo doesn't end up in qt/4.2
if relPath.startswith(branch + "/"):
2007-05-19 11:07:32 +02:00
if branch not in branches:
branches[branch] = []
2007-05-19 11:54:11 +02:00
branches[branch].append(file)
2007-06-17 11:25:34 +02:00
break
2007-03-20 20:54:23 +01:00
return branches
2007-05-23 23:49:35 +02:00
## Should move this out, doesn't use SELF.
def readP4Files(self, files):
2007-05-23 23:49:35 +02:00
files = [f for f in files
2007-05-23 23:49:35 +02:00
if f['action'] != 'delete']
2007-05-23 23:49:35 +02:00
2007-05-23 23:49:35 +02:00
if not files:
2007-05-23 23:49:35 +02:00
return
2007-07-16 05:58:11 +02:00
filedata = p4CmdList('-x - print',
stdin='\n'.join(['%s#%s' % (f['path'], f['rev'])
for f in files]),
stdin_mode='w+')
if "p4ExitCode" in filedata[0]:
die("Problems executing p4. Error: [%d]."
% (filedata[0]['p4ExitCode']));
2007-05-23 23:49:35 +02:00
2007-05-23 23:49:35 +02:00
j = 0;
contents = {}
2007-05-23 23:49:35 +02:00
while j < len(filedata):
2007-05-23 23:49:35 +02:00
stat = filedata[j]
2007-05-23 23:49:35 +02:00
j += 1
text = ''
2007-12-05 18:16:56 +01:00
while j < len(filedata) and filedata[j]['code'] in ('text', 'unicode', 'binary'):
tmp = filedata[j]['data']
if stat['type'] in ('text+ko', 'unicode+ko', 'binary+ko'):
tmp = re.sub(r'(?i)\$(Id|Header):[^$]*\$',r'$\1$', tmp)
elif stat['type'] in ('text+k', 'ktext', 'kxtext', 'unicode+k', 'binary+k'):
tmp = re.sub(r'(?i)\$(Id|Header|Author|Date|DateTime|Change|File|Revision):[^$]*\$',r'$\1$', tmp)
text += tmp
2007-05-23 23:49:35 +02:00
j += 1
2007-05-23 23:49:35 +02:00
2007-05-23 23:49:35 +02:00
if not stat.has_key('depotFile'):
sys.stderr.write("p4 print fails with: %s\n" % repr(stat))
continue
2007-05-23 23:49:35 +02:00
contents[stat['depotFile']] = text
2007-05-23 23:49:35 +02:00
2007-05-23 23:49:35 +02:00
for f in files:
assert not f.has_key('data')
f['data'] = contents[f['path']]
2007-05-23 23:49:35 +02:00
2007-05-23 23:49:35 +02:00
def commit(self, details, files, branch, branchPrefixes, parent = ""):
2007-03-20 20:54:23 +01:00
epoch = details["time"]
author = details["user"]
2007-05-18 21:45:23 +02:00
if self.verbose:
print "commit into %s" % branch
2007-05-23 23:49:35 +02:00
# start with reading files; if that fails, we should not
# create a commit.
new_files = []
for f in files:
if [p for p in branchPrefixes if f['path'].startswith(p)]:
new_files.append (f)
else:
sys.stderr.write("Ignoring file outside of prefix: %s\n" % path)
files = new_files
self.readP4Files(files)
2007-03-20 20:54:23 +01:00
self.gitStream.write("commit %s\n" % branch)
2007-05-23 23:49:35 +02:00
# gitStream.write("mark :%s\n" % details["change"])
2007-03-20 20:54:23 +01:00
self.committedChanges.add(int(details["change"]))
committer = ""
2007-05-20 10:55:54 +02:00
if author not in self.users:
self.getUserMapFromPerforceServer()
2007-03-20 20:54:23 +01:00
if author in self.users:
2007-03-20 20:59:30 +01:00
committer = "%s %s %s" % (self.users[author], epoch, self.tz)
2007-03-20 20:54:23 +01:00
else:
2007-03-20 20:59:30 +01:00
committer = "%s <a@b> %s %s" % (author, epoch, self.tz)
2007-03-20 20:54:23 +01:00
self.gitStream.write("committer %s\n" % committer)
self.gitStream.write("data <<EOT\n")
self.gitStream.write(details["desc"])
2007-06-11 10:01:58 +02:00
self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s"
% (','.join (branchPrefixes), details["change"]))
if len(details['options']) > 0:
self.gitStream.write(": options = %s" % details['options'])
self.gitStream.write("]\nEOT\n\n")
2007-03-20 20:54:23 +01:00
if len(parent) > 0:
2007-05-18 21:45:23 +02:00
if self.verbose:
print "parent %s" % parent
2007-03-20 20:54:23 +01:00
self.gitStream.write("from %s\n" % parent)
2007-05-23 23:49:35 +02:00
for file in files:
2007-03-20 20:54:23 +01:00
if file["type"] == "apple":
2007-05-23 23:49:35 +02:00
print "\nfile %s is a strange apple file that forks. Ignoring!" % file['path']
2007-03-20 20:54:23 +01:00
continue
2007-05-23 23:49:35 +02:00
relPath = self.stripRepoPath(file['path'], branchPrefixes)
if file["action"] == "delete":
2007-03-20 20:54:23 +01:00
self.gitStream.write("D %s\n" % relPath)
else:
2007-05-23 23:49:35 +02:00
data = file['data']
2007-03-20 20:54:23 +01:00
2007-08-07 12:28:00 +02:00
mode = "644"
2007-09-19 22:12:48 +02:00
if isP4Exec(file["type"]):
2007-08-07 12:28:00 +02:00
mode = "755"
elif file["type"] == "symlink":
mode = "120000"
# p4 print on a symlink contains "target\n", so strip it off
data = data[:-1]
2007-05-24 14:07:55 +02:00
if self.isWindows and file["type"].endswith("text"):
data = data.replace("\r\n", "\n")
2007-08-07 12:28:00 +02:00
self.gitStream.write("M %s inline %s\n" % (mode, relPath))
2007-03-20 20:54:23 +01:00
self.gitStream.write("data %s\n" % len(data))
self.gitStream.write(data)
self.gitStream.write("\n")
self.gitStream.write("\n")
2007-03-26 22:34:34 +02:00
change = int(details["change"])
2007-05-19 12:05:40 +02:00
if self.labels.has_key(change):
2007-03-26 22:34:34 +02:00
label = self.labels[change]
labelDetails = label[0]
labelRevisions = label[1]
2007-05-19 11:54:11 +02:00
if self.verbose:
print "Change %s is labelled %s" % (change, labelDetails)
2007-03-26 22:34:34 +02:00
2007-05-23 23:49:35 +02:00
files = p4CmdList("files " + ' '.join (["%s...@%s" % (p, change)
for p in branchPrefixes]))
2007-03-26 22:34:34 +02:00
if len(files) == len(labelRevisions):
cleanedFiles = {}
for info in files:
if info["action"] == "delete":
continue
cleanedFiles[info["depotFile"]] = info["rev"]
if cleanedFiles == labelRevisions:
self.gitStream.write("tag tag_%s\n" % labelDetails["label"])
self.gitStream.write("from %s\n" % branch)
owner = labelDetails["Owner"]
tagger = ""
if author in self.users:
tagger = "%s %s %s" % (self.users[owner], epoch, self.tz)
else:
tagger = "%s <a@b> %s %s" % (owner, epoch, self.tz)
self.gitStream.write("tagger %s\n" % tagger)
self.gitStream.write("data <<EOT\n")
self.gitStream.write(labelDetails["Description"])
self.gitStream.write("EOT\n\n")
else:
2007-03-28 17:05:38 +02:00
if not self.silent:
2007-05-23 21:53:11 +02:00
print ("Tag %s does not match with change %s: files do not match."
% (labelDetails["label"], change))
2007-03-26 22:34:34 +02:00
else:
2007-03-28 17:05:38 +02:00
if not self.silent:
2007-05-23 21:53:11 +02:00
print ("Tag %s does not match with change %s: file count is different."
% (labelDetails["label"], change))
2007-03-20 20:54:23 +01:00
2007-05-23 23:49:35 +02:00
def getUserCacheFilename(self):
2007-07-25 09:31:38 +02:00
home = os.environ.get("HOME", os.environ.get("USERPROFILE"))
return home + "/.gitp4-usercache.txt"
2007-05-23 23:49:35 +02:00
2007-05-20 10:55:54 +02:00
def getUserMapFromPerforceServer(self):
2007-05-24 00:24:52 +02:00
if self.userMapFromPerforceServer:
return
2007-03-20 20:54:23 +01:00
self.users = {}
for output in p4CmdList("users"):
if not output.has_key("User"):
continue
self.users[output["User"]] = output["FullName"] + " <" + output["Email"] + ">"
2007-05-23 23:49:35 +02:00
s = ''
for (key, val) in self.users.items():
s += "%s\t%s\n" % (key, val)
open(self.getUserCacheFilename(), "wb").write(s)
2007-05-24 00:24:52 +02:00
self.userMapFromPerforceServer = True
2007-05-20 10:55:54 +02:00
def loadUserMapFromCache(self):
self.users = {}
2007-05-24 00:24:52 +02:00
self.userMapFromPerforceServer = False
2007-05-20 10:55:54 +02:00
try:
2007-05-23 23:49:35 +02:00
cache = open(self.getUserCacheFilename(), "rb")
2007-05-20 10:55:54 +02:00
lines = cache.readlines()
cache.close()
for line in lines:
2007-05-23 23:49:35 +02:00
entry = line.strip().split("\t")
2007-05-20 10:55:54 +02:00
self.users[entry[0]] = entry[1]
except IOError:
self.getUserMapFromPerforceServer()
2007-03-26 22:34:34 +02:00
def getLabels(self):
self.labels = {}
2007-05-23 23:49:35 +02:00
l = p4CmdList("labels %s..." % ' '.join (self.depotPaths))
2007-04-08 10:15:47 +02:00
if len(l) > 0 and not self.silent:
2007-11-21 04:01:19 +01:00
print "Finding files belonging to labels in %s" % `self.depotPaths`
2007-04-07 23:46:50 +02:00
for output in l:
2007-03-26 22:34:34 +02:00
label = output["label"]
revisions = {}
newestChange = 0
2007-05-19 11:54:11 +02:00
if self.verbose:
print "Querying files for label %s" % label
2007-05-23 23:49:35 +02:00
for file in p4CmdList("files "
+ ' '.join (["%s...@%s" % (p, label)
for p in self.depotPaths])):
2007-03-26 22:34:34 +02:00
revisions[file["depotFile"]] = file["rev"]
change = int(file["change"])
if change > newestChange:
newestChange = change
2007-05-19 12:05:40 +02:00
self.labels[newestChange] = [output, revisions]
if self.verbose:
print "Label changes: %s" % self.labels.keys()
2007-03-26 22:34:34 +02:00
2007-05-23 23:49:35 +02:00
def guessProjectName(self):
for p in self.depotPaths:
2007-06-11 08:50:57 +02:00
if p.endswith("/"):
p = p[:-1]
p = p[p.strip().rfind("/") + 1:]
if not p.endswith("/"):
p += "/"
return p
2007-05-23 23:49:35 +02:00
2007-05-18 21:45:23 +02:00
def getBranchMapping(self):
2007-06-17 11:25:34 +02:00
lostAndFoundBranches = set()
2007-05-18 21:45:23 +02:00
for info in p4CmdList("branches"):
details = p4Cmd("branch -o %s" % info["branch"])
viewIdx = 0
while details.has_key("View%s" % viewIdx):
paths = details["View%s" % viewIdx].split(" ")
viewIdx = viewIdx + 1
# require standard //depot/foo/... //depot/bar/... mapping
if len(paths) != 2 or not paths[0].endswith("/...") or not paths[1].endswith("/..."):
continue
source = paths[0]
destination = paths[1]
2007-06-07 09:41:53 +02:00
## HACK
if source.startswith(self.depotPaths[0]) and destination.startswith(self.depotPaths[0]):
source = source[len(self.depotPaths[0]):-4]
destination = destination[len(self.depotPaths[0]):-4]
2007-06-17 11:25:34 +02:00
2007-06-17 15:10:24 +02:00
if destination in self.knownBranches:
if not self.silent:
print "p4 branch %s defines a mapping from %s to %s" % (info["branch"], source, destination)
print "but there exists another mapping from %s to %s already!" % (self.knownBranches[destination], destination)
continue
2007-06-17 11:25:34 +02:00
self.knownBranches[destination] = source
lostAndFoundBranches.discard(destination)
2007-05-19 10:23:12 +02:00
if source not in self.knownBranches:
2007-06-17 11:25:34 +02:00
lostAndFoundBranches.add(source)
for branch in lostAndFoundBranches:
self.knownBranches[branch] = branch
2007-05-19 10:23:12 +02:00
2007-11-15 10:38:45 +01:00
def getBranchMappingFromGitBranches(self):
branches = p4BranchesInGit(self.importIntoRemotes)
for branch in branches.keys():
if branch == "master":
branch = "main"
else:
branch = branch[len(self.projectName):]
self.knownBranches[branch] = branch
2007-05-19 10:23:12 +02:00
def listExistingP4GitBranches(self):
2007-07-18 17:27:50 +02:00
# branches holds mapping from name to commit
branches = p4BranchesInGit(self.importIntoRemotes)
self.p4BranchesInGit = branches.keys()
for branch in branches.keys():
self.initialParents[self.refPrefix + branch] = branches[branch]
2007-05-18 21:45:23 +02:00
2007-05-23 23:49:35 +02:00
def updateOptionDict(self, d):
option_keys = {}
if self.keepRepoPath:
option_keys['keepRepoPath'] = 1
d["options"] = ' '.join(sorted(option_keys.keys()))
def readOptions(self, d):
self.keepRepoPath = (d.has_key('options')
and ('keepRepoPath' in d['options']))
2007-05-23 23:49:35 +02:00
2007-08-26 16:44:55 +02:00
def gitRefForBranch(self, branch):
if branch == "main":
return self.refPrefix + "master"
if len(branch) <= 0:
return branch
return self.refPrefix + self.projectName + branch
2007-08-26 17:36:55 +02:00
def gitCommitByP4Change(self, ref, change):
if self.verbose:
print "looking in ref " + ref + " for change %s using bisect..." % change
earliestCommit = ""
latestCommit = parseRevision(ref)
while True:
if self.verbose:
print "trying: earliest %s latest %s" % (earliestCommit, latestCommit)
next = read_pipe("git rev-list --bisect %s %s" % (latestCommit, earliestCommit)).strip()
if len(next) == 0:
if self.verbose:
print "argh"
return ""
log = extractLogMessageFromGitCommit(next)
settings = extractSettingsGitLog(log)
currentChange = int(settings['change'])
if self.verbose:
print "current change %s" % currentChange
if currentChange == change:
if self.verbose:
print "found %s" % next
return next
if currentChange < change:
earliestCommit = "^%s" % next
else:
latestCommit = "%s" % next
return ""
def importNewBranch(self, branch, maxChange):
# make fast-import flush all changes to disk and update the refs using the checkpoint
# command so that we can try to find the branch parent in the git history
self.gitStream.write("checkpoint\n\n");
self.gitStream.flush();
branchPrefix = self.depotPaths[0] + branch + "/"
range = "@1,%s" % maxChange
#print "prefix" + branchPrefix
changes = p4ChangesForPaths([branchPrefix], range)
if len(changes) <= 0:
return False
firstChange = changes[0]
#print "first change in branch: %s" % firstChange
sourceBranch = self.knownBranches[branch]
sourceDepotPath = self.depotPaths[0] + sourceBranch
sourceRef = self.gitRefForBranch(sourceBranch)
#print "source " + sourceBranch
branchParentChange = int(p4Cmd("changes -m 1 %s...@1,%s" % (sourceDepotPath, firstChange))["change"])
#print "branch parent: %s" % branchParentChange
gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)
if len(gitParent) > 0:
self.initialParents[self.gitRefForBranch(branch)] = gitParent
#print "parent git commit: %s" % gitParent
self.importChanges(changes)
return True
2007-08-26 16:00:52 +02:00
def importChanges(self, changes):
cnt = 1
for change in changes:
description = p4Cmd("describe %s" % change)
self.updateOptionDict(description)
if not self.silent:
sys.stdout.write("\rImporting revision %s (%s%%)" % (change, cnt * 100 / len(changes)))
sys.stdout.flush()
cnt = cnt + 1
try:
if self.detectBranches:
branches = self.splitFilesIntoBranches(description)
for branch in branches.keys():
## HACK --hwn
branchPrefix = self.depotPaths[0] + branch + "/"
parent = ""
filesForCommit = branches[branch]
if self.verbose:
print "branch is %s" % branch
self.updatedBranches.add(branch)
if branch not in self.createdBranches:
self.createdBranches.add(branch)
parent = self.knownBranches[branch]
if parent == branch:
parent = ""
2007-08-26 17:36:55 +02:00
else:
fullBranch = self.projectName + branch
if fullBranch not in self.p4BranchesInGit:
if not self.silent:
print("\n Importing new branch %s" % fullBranch);
if self.importNewBranch(branch, change - 1):
parent = ""
self.p4BranchesInGit.append(fullBranch)
if not self.silent:
print("\n Resuming with change %s" % change);
if self.verbose:
print "parent determined through known branches: %s" % parent
2007-08-26 16:00:52 +02:00
2007-08-26 16:44:55 +02:00
branch = self.gitRefForBranch(branch)
parent = self.gitRefForBranch(parent)
2007-08-26 16:00:52 +02:00
if self.verbose:
print "looking for initial parent for %s; current parent is %s" % (branch, parent)
if len(parent) == 0 and branch in self.initialParents:
parent = self.initialParents[branch]
del self.initialParents[branch]
self.commit(description, filesForCommit, branch, [branchPrefix], parent)
else:
files = self.extractFilesFromCommit(description)
self.commit(description, files, self.branch, self.depotPaths,
self.initialParent)
self.initialParent = ""
except IOError:
print self.gitError.read()
sys.exit(1)
2007-08-26 16:07:18 +02:00
def importHeadRevision(self, revision):
print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), revision, self.branch)
details = { "user" : "git perforce import user", "time" : int(time.time()) }
details["desc"] = ("Initial import of %s from the state at revision %s"
% (' '.join(self.depotPaths), revision))
details["change"] = revision
newestRevision = 0
fileCnt = 0
for info in p4CmdList("files "
+ ' '.join(["%s...%s"
% (p, revision)
for p in self.depotPaths])):
if info['code'] == 'error':
sys.stderr.write("p4 returned an error: %s\n"
% info['data'])
sys.exit(1)
change = int(info["change"])
if change > newestRevision:
newestRevision = change
if info["action"] == "delete":
# don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
#fileCnt = fileCnt + 1
continue
for prop in ["depotFile", "rev", "action", "type" ]:
details["%s%s" % (prop, fileCnt)] = info[prop]
fileCnt = fileCnt + 1
details["change"] = newestRevision
self.updateOptionDict(details)
try:
self.commit(details, self.extractFilesFromCommit(details), self.branch, self.depotPaths)
except IOError:
print "IO error with git fast-import. Is your git version recent enough?"
print self.gitError.read()
2007-03-20 20:54:23 +01:00
def run(self, args):
2007-05-23 23:49:35 +02:00
self.depotPaths = []
2007-03-22 22:17:42 +01:00
self.changeRange = ""
self.initialParent = ""
2007-05-23 23:49:35 +02:00
self.previousDepotPaths = []
2007-05-23 21:46:29 +02:00
2007-05-19 10:23:12 +02:00
# map from branch depot path to parent branch
self.knownBranches = {}
self.initialParents = {}
2007-08-24 17:44:16 +02:00
self.hasOrigin = originP4BranchesExist()
2007-06-11 09:59:27 +02:00
if not self.syncWithOrigin:
self.hasOrigin = False
2007-05-19 10:23:12 +02:00
2007-05-23 00:03:08 +02:00
if self.importIntoRemotes:
self.refPrefix = "refs/remotes/p4/"
else:
2007-06-07 15:13:59 +02:00
self.refPrefix = "refs/heads/p4/"
2007-05-23 00:03:08 +02:00
2007-05-23 21:53:11 +02:00
if self.syncWithOrigin and self.hasOrigin:
if not self.silent:
print "Syncing with origin first by calling git fetch origin"
system("git fetch origin")
2007-05-24 22:28:28 +02:00
2007-03-22 21:34:16 +01:00
if len(self.branch) == 0:
2007-06-07 15:13:59 +02:00
self.branch = self.refPrefix + "master"
2007-05-23 00:03:08 +02:00
if gitBranchExists("refs/heads/p4") and self.importIntoRemotes:
2007-05-17 21:18:53 +02:00
system("git update-ref %s refs/heads/p4" % self.branch)
system("git branch -D p4");
2007-05-21 10:05:30 +02:00
# create it /after/ importing, when master exists
2007-08-24 17:46:16 +02:00
if not gitBranchExists(self.refPrefix + "HEAD") and self.importIntoRemotes and gitBranchExists(self.branch):
2007-05-27 15:48:01 +02:00
system("git symbolic-ref %sHEAD %s" % (self.refPrefix, self.branch))
2007-03-23 09:30:41 +01:00
2007-05-23 23:49:35 +02:00
# TODO: should always look at previous commits,
# merge with previous imports, if possible.
if args == []:
2007-05-25 11:36:42 +02:00
if self.hasOrigin:
2007-08-24 17:44:16 +02:00
createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)
2007-05-24 22:25:36 +02:00
self.listExistingP4GitBranches()
if len(self.p4BranchesInGit) > 1:
if not self.silent:
print "Importing from/into multiple branches"
self.detectBranches = True
2007-03-23 09:30:41 +01:00
2007-05-19 10:23:12 +02:00
if self.verbose:
print "branches: %s" % self.p4BranchesInGit
p4Change = 0
for branch in self.p4BranchesInGit:
2007-05-23 21:53:11 +02:00
logMsg = extractLogMessageFromGitCommit(self.refPrefix + branch)
2007-05-23 23:49:35 +02:00
settings = extractSettingsGitLog(logMsg)
2007-05-19 10:23:12 +02:00
2007-05-23 23:49:35 +02:00
self.readOptions(settings)
if (settings.has_key('depot-paths')
and settings.has_key ('change')):
change = int(settings['change']) + 1
2007-05-19 10:23:12 +02:00
p4Change = max(p4Change, change)
2007-05-23 23:49:35 +02:00
depotPaths = sorted(settings['depot-paths'])
if self.previousDepotPaths == []:
2007-05-23 23:49:35 +02:00
self.previousDepotPaths = depotPaths
2007-05-19 10:23:12 +02:00
else:
2007-05-23 23:49:35 +02:00
paths = []
for (prev, cur) in zip(self.previousDepotPaths, depotPaths):
2007-06-07 09:37:13 +02:00
for i in range(0, min(len(cur), len(prev))):
2007-05-23 23:49:35 +02:00
if cur[i] <> prev[i]:
2007-06-07 09:37:13 +02:00
i = i - 1
2007-05-23 23:49:35 +02:00
break
2007-06-07 09:37:13 +02:00
paths.append (cur[:i + 1])
2007-05-23 23:49:35 +02:00
self.previousDepotPaths = paths
2007-05-19 10:23:12 +02:00
if p4Change > 0:
2007-05-23 23:49:35 +02:00
self.depotPaths = sorted(self.previousDepotPaths)
2007-05-19 11:07:32 +02:00
self.changeRange = "@%s,#head" % p4Change
2007-06-07 09:39:51 +02:00
if not self.detectBranches:
self.initialParent = parseRevision(self.branch)
2007-05-21 00:39:16 +02:00
if not self.silent and not self.detectBranches:
2007-03-23 09:30:41 +01:00
print "Performing incremental import into %s git branch" % self.branch
2007-03-22 21:34:16 +01:00
2007-05-17 09:02:45 +02:00
if not self.branch.startswith("refs/"):
self.branch = "refs/heads/" + self.branch
2007-03-22 22:17:42 +01:00
2007-05-23 23:49:35 +02:00
if len(args) == 0 and self.depotPaths:
2007-03-20 20:54:23 +01:00
if not self.silent:
2007-05-23 23:49:35 +02:00
print "Depot paths: %s" % ' '.join(self.depotPaths)
2007-03-20 20:54:23 +01:00
else:
2007-05-23 23:49:35 +02:00
if self.depotPaths and self.depotPaths != args:
2007-05-23 21:53:11 +02:00
print ("previous import used depot path %s and now %s was specified. "
2007-05-23 23:49:35 +02:00
"This doesn't work!" % (' '.join (self.depotPaths),
' '.join (args)))
2007-03-20 20:54:23 +01:00
sys.exit(1)
2007-05-23 23:49:35 +02:00
2007-05-23 23:49:35 +02:00
self.depotPaths = sorted(args)
2007-03-20 20:54:23 +01:00
2007-08-26 16:04:34 +02:00
revision = ""
2007-03-20 20:54:23 +01:00
self.users = {}
2007-05-23 23:49:35 +02:00
newPaths = []
for p in self.depotPaths:
if p.find("@") != -1:
atIdx = p.index("@")
self.changeRange = p[atIdx:]
if self.changeRange == "@all":
self.changeRange = ""
2007-05-23 23:49:35 +02:00
elif ',' not in self.changeRange:
2007-08-26 16:04:34 +02:00
revision = self.changeRange
2007-05-23 23:49:35 +02:00
self.changeRange = ""
2007-07-24 00:56:37 +02:00
p = p[:atIdx]
2007-05-23 23:49:35 +02:00
elif p.find("#") != -1:
hashIdx = p.index("#")
2007-08-26 16:04:34 +02:00
revision = p[hashIdx:]
2007-07-24 00:56:37 +02:00
p = p[:hashIdx]
2007-05-23 23:49:35 +02:00
elif self.previousDepotPaths == []:
2007-08-26 16:04:34 +02:00
revision = "#head"
2007-05-23 23:49:35 +02:00
p = re.sub ("\.\.\.$", "", p)
if not p.endswith("/"):
p += "/"
newPaths.append(p)
self.depotPaths = newPaths
2007-03-20 20:54:23 +01:00
2007-05-20 10:55:54 +02:00
self.loadUserMapFromCache()
2007-04-08 00:12:02 +02:00
self.labels = {}
if self.detectLabels:
self.getLabels();
2007-03-20 20:54:23 +01:00
2007-05-18 21:45:23 +02:00
if self.detectBranches:
2007-06-08 08:49:22 +02:00
## FIXME - what's a P4 projectName ?
self.projectName = self.guessProjectName()
2007-11-15 10:38:45 +01:00
if self.hasOrigin:
self.getBranchMappingFromGitBranches()
else:
self.getBranchMapping()
2007-05-19 10:23:12 +02:00
if self.verbose:
print "p4-git branches: %s" % self.p4BranchesInGit
print "initial parents: %s" % self.initialParents
for b in self.p4BranchesInGit:
if b != "master":
2007-05-23 23:49:35 +02:00
## FIXME
2007-05-19 10:23:12 +02:00
b = b[len(self.projectName):]
self.createdBranches.add(b)
2007-05-18 21:45:23 +02:00
2007-04-14 11:21:50 +02:00
self.tz = "%+03d%02d" % (- time.timezone / 3600, ((- time.timezone % 3600) / 60))
2007-03-20 20:54:23 +01:00
2007-05-23 21:53:11 +02:00
importProcess = subprocess.Popen(["git", "fast-import"],
2007-05-23 23:49:35 +02:00
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE);
2007-05-15 14:31:06 +02:00
self.gitOutput = importProcess.stdout
self.gitStream = importProcess.stdin
self.gitError = importProcess.stderr
2007-03-20 20:54:23 +01:00
2007-08-26 16:04:34 +02:00
if revision:
2007-08-26 16:07:18 +02:00
self.importHeadRevision(revision)
2007-03-20 20:54:23 +01:00
else:
changes = []
2007-03-20 20:59:30 +01:00
if len(self.changesFile) > 0:
2007-03-20 20:54:23 +01:00
output = open(self.changesFile).readlines()
changeSet = Set()
for line in output:
changeSet.add(int(line))
for change in changeSet:
changes.append(change)
changes.sort()
else:
2007-05-19 10:23:12 +02:00
if self.verbose:
2007-05-23 23:49:35 +02:00
print "Getting p4 changes for %s...%s" % (', '.join(self.depotPaths),
2007-05-23 23:49:35 +02:00
self.changeRange)
2007-08-26 15:56:36 +02:00
changes = p4ChangesForPaths(self.depotPaths, self.changeRange)
2007-03-20 20:54:23 +01:00
2007-05-23 00:07:35 +02:00
if len(self.maxChanges) > 0:
2007-07-24 00:56:37 +02:00
changes = changes[:min(int(self.maxChanges), len(changes))]
2007-05-23 00:07:35 +02:00
2007-03-20 20:54:23 +01:00
if len(changes) == 0:
2007-03-20 20:59:30 +01:00
if not self.silent:
2007-05-21 00:39:16 +02:00
print "No changes to import!"
2007-04-08 00:07:02 +02:00
return True
2007-03-20 20:54:23 +01:00
2007-06-11 23:28:03 +02:00
if not self.silent and not self.detectBranches:
print "Import destination: %s" % self.branch
2007-05-21 00:39:16 +02:00
self.updatedBranches = set()
2007-08-26 16:00:52 +02:00
self.importChanges(changes)
2007-03-20 20:54:23 +01:00
2007-05-21 00:39:16 +02:00
if not self.silent:
print ""
if len(self.updatedBranches) > 0:
sys.stdout.write("Updated branches: ")
for b in self.updatedBranches:
sys.stdout.write("%s " % b)
sys.stdout.write("\n")
2007-03-20 20:54:23 +01:00
self.gitStream.close()
2007-05-19 10:23:12 +02:00
if importProcess.wait() != 0:
die("fast-import failed: %s" % self.gitError.read())
2007-03-20 20:54:23 +01:00
self.gitOutput.close()
self.gitError.close()
return True
2007-04-07 23:46:50 +02:00
class P4Rebase(Command):
def __init__(self):
Command.__init__(self)
2007-05-25 10:36:10 +02:00
self.options = [ ]
2007-05-23 21:53:11 +02:00
self.description = ("Fetches the latest revision from perforce and "
+ "rebases the current work (branch) against it")
2007-06-07 12:51:03 +02:00
self.verbose = False
2007-04-07 23:46:50 +02:00
def run(self, args):
sync = P4Sync()
sync.run([])
2007-06-12 14:34:46 +02:00
2007-08-22 09:07:15 +02:00
return self.rebase()
def rebase(self):
2008-01-07 14:21:45 +01:00
if os.system("git update-index --refresh") != 0:
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.");
if len(read_pipe("git diff-index HEAD --")) > 0:
die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
2007-06-12 14:34:46 +02:00
[upstream, settings] = findUpstreamBranchPoint()
if len(upstream) == 0:
die("Cannot find upstream branchpoint for rebase")
# the branchpoint may be p4/foo~3, so strip off the parent
upstream = re.sub("~[0-9]+$", "", upstream)
print "Rebasing the current branch onto %s" % upstream
2007-05-23 23:49:35 +02:00
oldHead = read_pipe("git rev-parse HEAD").strip()
2007-06-12 14:34:46 +02:00
system("git rebase %s" % upstream)
2007-04-08 00:07:02 +02:00
system("git diff-tree --stat --summary -M %s HEAD" % oldHead)
2007-04-07 23:46:50 +02:00
return True
2007-04-08 10:08:26 +02:00
class P4Clone(P4Sync):
def __init__(self):
P4Sync.__init__(self)
self.description = "Creates a new git repository and imports from Perforce into it"
2007-05-23 23:49:35 +02:00
self.usage = "usage: %prog [options] //depot/path[@revRange]"
2008-02-03 19:38:51 +01:00
self.options += [
2007-05-23 23:49:35 +02:00
optparse.make_option("--destination", dest="cloneDestination",
action='store', default=None,
2008-02-03 19:38:51 +01:00
help="where to leave result of the clone"),
optparse.make_option("-/", dest="cloneExclude",
action="append", type="string",
help="exclude depot path")
]
2007-05-23 23:49:35 +02:00
self.cloneDestination = None
2007-04-08 10:08:26 +02:00
self.needsGit = False
2008-02-03 19:38:51 +01:00
# This is required for the "append" cloneExclude action
def ensure_value(self, attr, value):
if not hasattr(self, attr) or getattr(self, attr) is None:
setattr(self, attr, value)
return getattr(self, attr)
2007-05-23 23:49:35 +02:00
def defaultDestination(self, args):
## TODO: use common prefix of args?
depotPath = args[0]
depotDir = re.sub("(@[^@]*)$", "", depotPath)
depotDir = re.sub("(#[^#]*)$", "", depotDir)
2008-02-04 21:41:43 +01:00
depotDir = re.sub(r"\.\.\.$", "", depotDir)
2007-05-23 23:49:35 +02:00
depotDir = re.sub(r"/$", "", depotDir)
return os.path.split(depotDir)[1]
2007-04-08 10:08:26 +02:00
def run(self, args):
if len(args) < 1:
return False
2007-05-23 23:49:35 +02:00
if self.keepRepoPath and not self.cloneDestination:
sys.stderr.write("Must specify destination for --keep-path\n")
sys.exit(1)
2007-04-08 10:08:26 +02:00
2007-05-23 23:49:35 +02:00
depotPaths = args
2007-06-07 21:12:25 +02:00
if not self.cloneDestination and len(depotPaths) > 1:
self.cloneDestination = depotPaths[-1]
depotPaths = depotPaths[:-1]
2008-02-03 19:38:51 +01:00
self.cloneExclude = ["/"+p for p in self.cloneExclude]
2007-05-23 23:49:35 +02:00
for p in depotPaths:
if not p.startswith("//"):
return False
2007-04-08 10:08:26 +02:00
2007-05-23 23:49:35 +02:00
if not self.cloneDestination:
2007-06-07 15:08:33 +02:00
self.cloneDestination = self.defaultDestination(args)
2007-04-08 10:08:26 +02:00
2007-05-23 23:49:35 +02:00
print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
2007-06-11 22:48:07 +02:00
if not os.path.exists(self.cloneDestination):
os.makedirs(self.cloneDestination)
2007-05-23 23:49:35 +02:00
os.chdir(self.cloneDestination)
2007-04-08 10:08:26 +02:00
system("git init")
2007-05-23 23:49:35 +02:00
self.gitdir = os.getcwd() + "/.git"
2007-05-23 23:49:35 +02:00
if not P4Sync.run(self, depotPaths):
2007-04-08 10:08:26 +02:00
return False
if self.branch != "master":
2007-05-18 22:13:26 +02:00
if gitBranchExists("refs/remotes/p4/master"):
system("git branch master refs/remotes/p4/master")
system("git checkout -f")
else:
print "Could not detect main branch. No checkout/master branch created."
2007-05-23 23:49:35 +02:00
2007-04-08 10:08:26 +02:00
return True
2007-06-20 23:10:28 +02:00
class P4Branches(Command):
def __init__(self):
Command.__init__(self)
self.options = [ ]
self.description = ("Shows the git branches that hold imports and their "
+ "corresponding perforce depot paths")
self.verbose = False
def run(self, args):
2007-08-24 17:44:16 +02:00
if originP4BranchesExist():
createOrUpdateBranchesFromOrigin()
2007-06-20 23:10:28 +02:00
cmdline = "git rev-parse --symbolic "
cmdline += " --remotes"
for line in read_pipe_lines(cmdline):
line = line.strip()
if not line.startswith('p4/') or line == "p4/HEAD":
continue
branch = line
log = extractLogMessageFromGitCommit("refs/remotes/%s" % branch)
settings = extractSettingsGitLog(log)
print "%s <= %s (%s)" % (branch, ",".join(settings["depot-paths"]), settings["change"])
return True
2007-03-20 20:54:23 +01:00
class HelpFormatter(optparse.IndentedHelpFormatter):
def __init__(self):
optparse.IndentedHelpFormatter.__init__(self)
def format_description(self, description):
if description:
return description + "\n"
else:
return ""
2007-03-19 22:25:17 +01:00
2007-03-19 20:59:12 +01:00
def printUsage(commands):
print "usage: %s <command> [options]" % sys.argv[0]
print ""
print "valid commands: %s" % ", ".join(commands)
print ""
print "Try %s <command> --help for command specific help." % sys.argv[0]
print ""
commands = {
2007-05-23 23:49:35 +02:00
"debug" : P4Debug,
"submit" : P4Submit,
2007-10-09 16:16:09 +02:00
"commit" : P4Submit,
2007-05-23 23:49:35 +02:00
"sync" : P4Sync,
"rebase" : P4Rebase,
"clone" : P4Clone,
2007-06-20 23:10:28 +02:00
"rollback" : P4RollBack,
"branches" : P4Branches
2007-03-19 20:59:12 +01:00
}
2007-05-23 23:49:35 +02:00
def main():
if len(sys.argv[1:]) == 0:
printUsage(commands.keys())
sys.exit(2)
2007-03-19 22:25:17 +01:00
2007-05-23 23:49:35 +02:00
cmd = ""
cmdName = sys.argv[1]
try:
2007-05-23 23:49:35 +02:00
klass = commands[cmdName]
cmd = klass()
2007-05-23 23:49:35 +02:00
except KeyError:
print "unknown command %s" % cmdName
print ""
printUsage(commands.keys())
sys.exit(2)
options = cmd.options
2007-05-23 23:49:35 +02:00
cmd.gitdir = os.environ.get("GIT_DIR", None)
2007-05-23 23:49:35 +02:00
args = sys.argv[2:]
if len(options) > 0:
options.append(optparse.make_option("--git-dir", dest="gitdir"))
parser = optparse.OptionParser(cmd.usage.replace("%prog", "%prog " + cmdName),
options,
description = cmd.description,
formatter = HelpFormatter())
(cmd, args) = parser.parse_args(sys.argv[2:], cmd);
global verbose
verbose = cmd.verbose
if cmd.needsGit:
2007-05-23 23:49:35 +02:00
if cmd.gitdir == None:
cmd.gitdir = os.path.abspath(".git")
if not isValidGitDir(cmd.gitdir):
cmd.gitdir = read_pipe("git rev-parse --git-dir").strip()
if os.path.exists(cmd.gitdir):
2007-05-23 23:49:35 +02:00
cdup = read_pipe("git rev-parse --show-cdup").strip()
if len(cdup) > 0:
os.chdir(cdup);
2007-03-26 00:13:51 +02:00
2007-05-23 23:49:35 +02:00
if not isValidGitDir(cmd.gitdir):
if isValidGitDir(cmd.gitdir + "/.git"):
cmd.gitdir += "/.git"
2007-05-23 23:49:35 +02:00
else:
2007-05-23 23:49:35 +02:00
die("fatal: cannot locate git repository at %s" % cmd.gitdir)
2007-03-26 00:13:51 +02:00
2007-05-23 23:49:35 +02:00
os.environ["GIT_DIR"] = cmd.gitdir
2007-03-19 20:59:12 +01:00
2007-05-23 23:49:35 +02:00
if not cmd.run(args):
parser.print_help()
2007-03-19 22:25:17 +01:00
2007-05-23 23:49:35 +02:00
if __name__ == '__main__':
main()