from sets import Set;
-gitdir = os.environ.get("GIT_DIR", "")
verbose = False
+def die(msg):
+ if verbose:
+ raise Exception(msg)
+ else:
+ sys.stderr.write(msg + "\n")
+ sys.exit(1)
+
def write_pipe(c, str):
if verbose:
- sys.stderr.write('writing pipe: %s\n' % c)
+ sys.stderr.write('Writing pipe: %s\n' % c)
pipe = os.popen(c, 'w')
val = pipe.write(str)
if pipe.close():
- sys.stderr.write('Command failed: %s' % c)
- sys.exit(1)
+ die('Command failed: %s' % c)
return val
def read_pipe(c, ignore_error=False):
if verbose:
- sys.stderr.write('reading pipe: %s\n' % c)
+ sys.stderr.write('Reading pipe: %s\n' % c)
pipe = os.popen(c, 'rb')
val = pipe.read()
if pipe.close() and not ignore_error:
- sys.stderr.write('Command failed: %s\n' % c)
- sys.exit(1)
+ die('Command failed: %s' % c)
return val
def read_pipe_lines(c):
if verbose:
- sys.stderr.write('reading pipe: %s\n' % c)
+ sys.stderr.write('Reading pipe: %s\n' % c)
## todo: check return status
pipe = os.popen(c, 'rb')
val = pipe.readlines()
if pipe.close():
- sys.stderr.write('Command failed: %s\n' % c)
- sys.exit(1)
+ die('Command failed: %s' % c)
return val
if os.system(cmd) != 0:
die("command failed: %s" % cmd)
-def p4CmdList(cmd):
+def p4CmdList(cmd, stdin=None, stdin_mode='w+b'):
cmd = "p4 -G %s" % cmd
- pipe = os.popen(cmd, "rb")
+ if verbose:
+ sys.stderr.write("Opening pipe: %s\n" % cmd)
+
+ # 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)
result = []
try:
while True:
- entry = marshal.load(pipe)
+ entry = marshal.load(p4.stdout)
result.append(entry)
except EOFError:
pass
- exitCode = pipe.close()
- if exitCode != None:
+ exitCode = p4.wait()
+ if exitCode != 0:
entry = {}
entry["p4ExitCode"] = exitCode
result.append(entry)
clientPath = clientPath[:-3]
return clientPath
-def die(msg):
- sys.stderr.write(msg + "\n")
- sys.exit(1)
-
def currentGitBranch():
return read_pipe("git name-rev HEAD").split(" ")[1].strip()
values[key] = val
- values['depot-paths'] = values.get("depot-paths").split(',')
+ paths = values.get("depot-paths")
+ if not paths:
+ paths = values.get("depot-path")
+ if paths:
+ values['depot-paths'] = paths.split(',')
return values
def gitBranchExists(branch):
def gitConfig(key):
return read_pipe("git config %s" % key, ignore_error=True).strip()
+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
+
+def findUpstreamBranchPoint(head = "HEAD"):
+ 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
+
+ settings = None
+ parent = 0
+ while parent < 65535:
+ commit = head + "~%s" % parent
+ log = extractLogMessageFromGitCommit(commit)
+ settings = extractSettingsGitLog(log)
+ if settings.has_key("depot-paths"):
+ paths = ",".join(settings["depot-paths"])
+ if branchByDepotPath.has_key(paths):
+ return [branchByDepotPath[paths], settings]
+
+ parent = parent + 1
+
+ return ["", settings]
+
class Command:
def __init__(self):
self.usage = "usage: %prog [options]"
def __init__(self):
Command.__init__(self)
self.options = [
- optparse.make_option("--verbose", dest="verbose", action="store_true"),
+ optparse.make_option("--verbose", dest="verbose", action="store_true",
+ default=False),
]
self.description = "A tool to debug the output of p4 -G."
self.needsGit = False
+ self.verbose = False
def run(self, args):
+ j = 0
for output in p4CmdList(" ".join(args)):
+ print 'Element: %d' % j
+ j += 1
print output
return True
self.origin = ""
self.directSubmit = False
self.trustMeLikeAFool = False
+ self.verbose = False
+ self.isWindows = (platform.system() == "Windows")
self.logSubstitutions = {}
self.logSubstitutions["<enter description here>"] = "%log%"
return result
+ 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
+
def applyCommit(self, id):
if self.directSubmit:
print "Applying local change in working directory/index"
system(applyPatchCmd)
for f in filesToAdd:
- system("p4 add %s" % f)
+ system("p4 add \"%s\"" % f)
for f in filesToDelete:
- system("p4 revert %s" % f)
- system("p4 delete %s" % f)
+ system("p4 revert \"%s\"" % f)
+ system("p4 delete \"%s\"" % f)
logMessage = ""
if not self.directSubmit:
logMessage = extractLogMessageFromGitCommit(id)
logMessage = logMessage.replace("\n", "\n\t")
+ if self.isWindows:
+ logMessage = logMessage.replace("\n", "\r\n")
logMessage = logMessage.strip()
- template = read_pipe("p4 change -o")
+ template = self.prepareSubmitTemplate()
if self.interactive:
submitTemplate = self.prepareLogMessage(template, logMessage)
tmpFile.close()
os.remove(fileName)
submitTemplate = message[:message.index(separatorLine)]
+ if self.isWindows:
+ submitTemplate = submitTemplate.replace("\r\n", "\n")
if response == "y" or response == "yes":
if self.dryRun:
% (fileName, fileName))
def run(self, args):
- global gitdir
- # make gitdir absolute so we can cd out into the perforce checkout
- gitdir = os.path.abspath(gitdir)
- os.environ["GIT_DIR"] = gitdir
-
if len(args) == 0:
self.master = currentGitBranch()
if len(self.master) == 0 or not gitBranchExists("refs/heads/%s" % self.master):
else:
return False
- depotPath = ""
- settings = None
- if gitBranchExists("p4"):
- settings = extractSettingsGitLog(extractLogMessageFromGitCommit("p4"))
- if len(depotPath) == 0 and gitBranchExists("origin"):
- settings = extractSettingsGitLog(extractLogMessageFromGitCommit("origin"))
- depotPaths = settings['depot-paths']
+ [upstream, settings] = findUpstreamBranchPoint()
+ self.depotPath = settings['depot-paths'][0]
+ if len(self.origin) == 0:
+ self.origin = upstream
- if len(depotPath) == 0:
+ if self.verbose:
+ print "Origin branch is " + self.origin
+
+ if len(self.depotPath) == 0:
print "Internal error: cannot locate perforce depot path from existing branches"
sys.exit(128)
- self.clientPath = p4Where(depotPath)
+ self.clientPath = p4Where(self.depotPath)
if len(self.clientPath) == 0:
- print "Error: Cannot locate perforce checkout of %s in client view" % depotPath
+ print "Error: Cannot locate perforce checkout of %s in client view" % self.depotPath
sys.exit(128)
- print "Perforce checkout for depot path %s located at %s" % (depotPath, self.clientPath)
+ print "Perforce checkout for depot path %s located at %s" % (self.depotPath, self.clientPath)
self.oldWorkingDirectory = os.getcwd()
if self.directSubmit:
print "No changes in working directory to submit."
return True
patch = read_pipe("git diff -p --binary --diff-filter=ACMRTUXB HEAD")
- self.diffFile = gitdir + "/p4-git-diff"
+ self.diffFile = self.gitdir + "/p4-git-diff"
f = open(self.diffFile, "wb")
f.write(patch)
f.close();
if response == "y" or response == "yes":
system("p4 sync ...")
- if len(self.origin) == 0:
- if gitBranchExists("p4"):
- self.origin = "p4"
- else:
- self.origin = "origin"
-
if self.reset:
self.firstTime = True
self.logSubstitutions[tokens[0]] = tokens[1]
self.check()
- self.configFile = gitdir + "/p4-git-sync.cfg"
+ self.configFile = self.gitdir + "/p4-git-sync.cfg"
self.config = shelve.open(self.configFile, writeback=True)
if self.firstTime:
optparse.make_option("--silent", dest="silent", action="store_true"),
optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),
optparse.make_option("--verbose", dest="verbose", action="store_true"),
- optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false"),
+ optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",
+ help="Import into refs/heads/ , not refs/remotes"),
optparse.make_option("--max-changes", dest="maxChanges"),
- optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true')
+ optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',
+ help="Keep entire BRANCH/DIR/SUBDIR prefix during import")
]
self.description = """Imports from Perforce into a git repository.\n
example:
self.isWindows = (platform.system() == "Windows")
self.keepRepoPath = False
self.depotPaths = None
+ self.p4BranchesInGit = []
if gitConfig("git-p4.syncFromOrigin") == "false":
self.syncWithOrigin = False
- def p4File(self, depotPath):
- return read_pipe("p4 print -q \"%s\"" % depotPath)
-
def extractFilesFromCommit(self, commit):
files = []
fnum = 0
if branch not in branches:
branches[branch] = []
branches[branch].append(file)
+ break
return branches
+ ## Should move this out, doesn't use SELF.
+ def readP4Files(self, files):
+ files = [f for f in files
+ if f['action'] != 'delete']
+
+ if not files:
+ return
+
+ 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']));
+
+ j = 0;
+ contents = {}
+ while j < len(filedata):
+ stat = filedata[j]
+ j += 1
+ text = ''
+ while j < len(filedata) and filedata[j]['code'] in ('text',
+ 'binary'):
+ text += filedata[j]['data']
+ j += 1
+
+
+ if not stat.has_key('depotFile'):
+ sys.stderr.write("p4 print fails with: %s\n" % repr(stat))
+ continue
+
+ contents[stat['depotFile']] = text
+
+ for f in files:
+ assert not f.has_key('data')
+ f['data'] = contents[f['path']]
+
def commit(self, details, files, branch, branchPrefixes, parent = ""):
epoch = details["time"]
author = details["user"]
if self.verbose:
print "commit into %s" % branch
+ # 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)
+
+
+
+
self.gitStream.write("commit %s\n" % branch)
- # gitStream.write("mark :%s\n" % details["change"])
+# gitStream.write("mark :%s\n" % details["change"])
self.committedChanges.add(int(details["change"]))
committer = ""
if author not in self.users:
self.gitStream.write("data <<EOT\n")
self.gitStream.write(details["desc"])
- self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s: "
- "options = %s]\n"
- % (','.join (branchPrefixes), details["change"],
- details['options']
- ))
- self.gitStream.write("EOT\n\n")
+ 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")
if len(parent) > 0:
if self.verbose:
self.gitStream.write("from %s\n" % parent)
for file in files:
- path = file["path"]
-
-
- if not [p for p in branchPrefixes if path.startswith(p)]:
- continue
- rev = file["rev"]
- depotPath = path + "#" + rev
- relPath = self.stripRepoPath(path, branchPrefixes)
- action = file["action"]
-
if file["type"] == "apple":
- print "\nfile %s is a strange apple file that forks. Ignoring!" % path
+ print "\nfile %s is a strange apple file that forks. Ignoring!" % file['path']
continue
- if action == "delete":
+ relPath = self.stripRepoPath(file['path'], branchPrefixes)
+ if file["action"] == "delete":
self.gitStream.write("D %s\n" % relPath)
else:
- mode = 644
- if file["type"].startswith("x"):
- mode = 755
+ data = file['data']
- data = self.p4File(depotPath)
+ mode = "644"
+ if file["type"].startswith("x"):
+ mode = "755"
+ elif file["type"] == "symlink":
+ mode = "120000"
+ # p4 print on a symlink contains "target\n", so strip it off
+ data = data[:-1]
if self.isWindows and file["type"].endswith("text"):
data = data.replace("\r\n", "\n")
print ("Tag %s does not match with change %s: file count is different."
% (labelDetails["label"], change))
+ def getUserCacheFilename(self):
+ home = os.environ.get("HOME", os.environ.get("USERPROFILE"))
+ return home + "/.gitp4-usercache.txt"
+
def getUserMapFromPerforceServer(self):
if self.userMapFromPerforceServer:
return
continue
self.users[output["User"]] = output["FullName"] + " <" + output["Email"] + ">"
- cache = open(gitdir + "/p4-usercache.txt", "wb")
- for user in self.users.keys():
- cache.write("%s\t%s\n" % (user, self.users[user]))
- cache.close();
+
+ s = ''
+ for (key, val) in self.users.items():
+ s += "%s\t%s\n" % (key, val)
+
+ open(self.getUserCacheFilename(), "wb").write(s)
self.userMapFromPerforceServer = True
def loadUserMapFromCache(self):
self.users = {}
self.userMapFromPerforceServer = False
try:
- cache = open(gitdir + "/p4-usercache.txt", "rb")
+ cache = open(self.getUserCacheFilename(), "rb")
lines = cache.readlines()
cache.close()
for line in lines:
if self.verbose:
print "Label changes: %s" % self.labels.keys()
- def getBranchMapping(self):
+ def guessProjectName(self):
+ for p in self.depotPaths:
+ if p.endswith("/"):
+ p = p[:-1]
+ p = p[p.strip().rfind("/") + 1:]
+ if not p.endswith("/"):
+ p += "/"
+ return p
- ## FIXME - what's a P4 projectName ?
- self.projectName = self.depotPath[self.depotPath.strip().rfind("/") + 1:]
+ def getBranchMapping(self):
+ lostAndFoundBranches = set()
for info in p4CmdList("branches"):
details = p4Cmd("branch -o %s" % info["branch"])
continue
source = paths[0]
destination = paths[1]
- if source.startswith(self.depotPath) and destination.startswith(self.depotPath):
- source = source[len(self.depotPath):-4]
- destination = destination[len(self.depotPath):-4]
- if destination not in self.knownBranches:
- self.knownBranches[destination] = source
- if source not in self.knownBranches:
- self.knownBranches[source] = source
+ ## 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]
+
+ 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
- def listExistingP4GitBranches(self):
- self.p4BranchesInGit = []
+ self.knownBranches[destination] = source
- cmdline = "git rev-parse --symbolic "
- if self.importIntoRemotes:
- cmdline += " --remotes"
- else:
- cmdline += " --branches"
+ lostAndFoundBranches.discard(destination)
- for line in read_pipe_lines(cmdline):
- line = line.strip()
- if self.importIntoRemotes and ((not line.startswith("p4/")) or line == "p4/HEAD"):
- continue
+ if source not in self.knownBranches:
+ lostAndFoundBranches.add(source)
- if self.importIntoRemotes:
- # strip off p4
- branch = re.sub ("^p4/", "", line)
- self.p4BranchesInGit.append(branch)
- self.initialParents[self.refPrefix + branch] = parseRevision(line)
+ for branch in lostAndFoundBranches:
+ self.knownBranches[branch] = branch
+
+ def listExistingP4GitBranches(self):
+ # 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]
def createOrUpdateBranchesFromOrigin(self):
if not self.silent:
- print "Creating/updating branch(es) in %s based on origin branch(es)" % self.refPrefix
+ print ("Creating/updating branch(es) in %s based on origin branch(es)"
+ % self.refPrefix)
+
+ originPrefix = "origin/p4/"
for line in read_pipe_lines("git rev-parse --symbolic --remotes"):
line = line.strip()
- if (not line.startswith("origin/")) or line.endswith("HEAD\n"):
+ if (not line.startswith(originPrefix)) or line.endswith("HEAD"):
continue
- headName = line[len("origin/"):]
+ headName = line[len(originPrefix):]
remoteHead = self.refPrefix + headName
- originHead = "origin/" + headName
+ originHead = line
original = extractSettingsGitLog(extractLogMessageFromGitCommit(originHead))
if (not original.has_key('depot-paths')
print "creating %s" % remoteHead
update = True
else:
- settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead))
+ settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead))
if settings.has_key('change') > 0:
if settings['depot-paths'] == original['depot-paths']:
originP4Change = int(original['change'])
# map from branch depot path to parent branch
self.knownBranches = {}
self.initialParents = {}
- self.hasOrigin = gitBranchExists("origin")
+ self.hasOrigin = gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
+ if not self.syncWithOrigin:
+ self.hasOrigin = False
if self.importIntoRemotes:
self.refPrefix = "refs/remotes/p4/"
else:
- self.refPrefix = "refs/heads/"
+ self.refPrefix = "refs/heads/p4/"
if self.syncWithOrigin and self.hasOrigin:
if not self.silent:
if not gitBranchExists(self.refPrefix + "HEAD") and self.importIntoRemotes:
system("git symbolic-ref %sHEAD %s" % (self.refPrefix, self.branch))
- ### FIXME
- if 1:
+ # TODO: should always look at previous commits,
+ # merge with previous imports, if possible.
+ if args == []:
if self.hasOrigin:
self.createOrUpdateBranchesFromOrigin()
self.listExistingP4GitBranches()
settings = extractSettingsGitLog(logMsg)
- if self.verbose:
- print "path %s change %s" % (','.join(depotPaths), change)
-
self.readOptions(settings)
if (settings.has_key('depot-paths')
and settings.has_key ('change')):
else:
paths = []
for (prev, cur) in zip(self.previousDepotPaths, depotPaths):
- for i in range(0, max(len(cur), len(prev))):
+ for i in range(0, min(len(cur), len(prev))):
if cur[i] <> prev[i]:
+ i = i - 1
break
- paths.append (cur[:i])
+ paths.append (cur[:i + 1])
self.previousDepotPaths = paths
if p4Change > 0:
self.depotPaths = sorted(self.previousDepotPaths)
self.changeRange = "@%s,#head" % p4Change
- self.initialParent = parseRevision(self.branch)
+ if not self.detectBranches:
+ self.initialParent = parseRevision(self.branch)
if not self.silent and not self.detectBranches:
print "Performing incremental import into %s git branch" % self.branch
self.changeRange = p[atIdx:]
if self.changeRange == "@all":
self.changeRange = ""
- elif self.changeRange.find(",") == -1:
+ elif ',' not in self.changeRange:
self.revision = self.changeRange
self.changeRange = ""
- p = p[0:atIdx]
+ p = p[:atIdx]
elif p.find("#") != -1:
hashIdx = p.index("#")
self.revision = p[hashIdx:]
- p = p[0:hashIdx]
+ p = p[:hashIdx]
elif self.previousDepotPaths == []:
self.revision = "#head"
self.getLabels();
if self.detectBranches:
- self.getBranchMapping();
+ ## FIXME - what's a P4 projectName ?
+ self.projectName = self.guessProjectName()
+
+ if not self.hasOrigin:
+ self.getBranchMapping();
if self.verbose:
print "p4-git branches: %s" % self.p4BranchesInGit
print "initial parents: %s" % self.initialParents
self.gitStream = importProcess.stdin
self.gitError = importProcess.stderr
- if len(self.revision) > 0:
- print "Doing initial import of %s from revision %s" % (' '.join(self.depotPaths), self.revision)
+ if self.revision:
+ print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), self.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(["%s...%s"
% (p, self.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
#fileCnt = fileCnt + 1
continue
- for prop in [ "depotFile", "rev", "action", "type" ]:
+ for prop in ["depotFile", "rev", "action", "type" ]:
details["%s%s" % (prop, fileCnt)] = info[prop]
fileCnt = fileCnt + 1
changes.sort()
else:
if self.verbose:
- print "Getting p4 changes for %s...%s" % (`self.depotPaths`,
+ print "Getting p4 changes for %s...%s" % (', '.join(self.depotPaths),
self.changeRange)
assert self.depotPaths
output = read_pipe_lines("p4 changes " + ' '.join (["%s...%s" % (p, self.changeRange)
for line in output:
changeNum = line.split(" ")[1]
- changes.append(changeNum)
+ changes.append(int(changeNum))
- changes.reverse()
+ changes.sort()
if len(self.maxChanges) > 0:
- changes = changes[0:min(int(self.maxChanges), len(changes))]
+ changes = changes[:min(int(self.maxChanges), len(changes))]
if len(changes) == 0:
if not self.silent:
print "No changes to import!"
return True
+ if not self.silent and not self.detectBranches:
+ print "Import destination: %s" % self.branch
+
self.updatedBranches = set()
cnt = 1
parent = self.initialParents[branch]
del self.initialParents[branch]
- self.commit(description, filesForCommit, branch, branchPrefix, parent)
+ self.commit(description, filesForCommit, branch, [branchPrefix], parent)
else:
files = self.extractFilesFromCommit(description)
self.commit(description, files, self.branch, self.depotPaths,
self.options = [ ]
self.description = ("Fetches the latest revision from perforce and "
+ "rebases the current work (branch) against it")
+ self.verbose = False
def run(self, args):
sync = P4Sync()
sync.run([])
- print "Rebasing the current branch"
+
+ [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
oldHead = read_pipe("git rev-parse HEAD").strip()
- system("git rebase p4")
+ system("git rebase %s" % upstream)
system("git diff-tree --stat --summary -M %s HEAD" % oldHead)
return True
self.cloneDestination = None
self.needsGit = False
- def run(self, args):
- global gitdir
+ def defaultDestination(self, args):
+ ## TODO: use common prefix of args?
+ depotPath = args[0]
+ depotDir = re.sub("(@[^@]*)$", "", depotPath)
+ depotDir = re.sub("(#[^#]*)$", "", depotDir)
+ depotDir = re.sub(r"\.\.\.$,", "", depotDir)
+ depotDir = re.sub(r"/$", "", depotDir)
+ return os.path.split(depotDir)[1]
+ def run(self, args):
if len(args) < 1:
return False
sys.exit(1)
depotPaths = args
+
+ if not self.cloneDestination and len(depotPaths) > 1:
+ self.cloneDestination = depotPaths[-1]
+ depotPaths = depotPaths[:-1]
+
for p in depotPaths:
if not p.startswith("//"):
return False
if not self.cloneDestination:
- depotPath = args[0]
- depotDir = re.sub("(@[^@]*)$", "", depotPath)
- depotDir = re.sub("(#[^#]*)$", "", depotDir)
- depotDir = re.sub(r"\.\.\.$,", "", depotDir)
- depotDir = re.sub(r"/$", "", depotDir)
+ self.cloneDestination = self.defaultDestination(args)
- self.cloneDestination = os.path.split(depotDir)[1]
-
- print "Importing from %s into %s" % (`depotPaths`, self.cloneDestination)
- os.makedirs(self.cloneDestination)
+ print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
+ if not os.path.exists(self.cloneDestination):
+ os.makedirs(self.cloneDestination)
os.chdir(self.cloneDestination)
system("git init")
- gitdir = os.getcwd() + "/.git"
+ self.gitdir = os.getcwd() + "/.git"
if not P4Sync.run(self, depotPaths):
return False
if self.branch != "master":
system("git checkout -f")
else:
print "Could not detect main branch. No checkout/master branch created."
+
+ return True
+
+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):
+ 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
class HelpFormatter(optparse.IndentedHelpFormatter):
print ""
commands = {
- "debug" : P4Debug(),
- "submit" : P4Submit(),
- "sync" : P4Sync(),
- "rebase" : P4Rebase(),
- "clone" : P4Clone(),
- "rollback" : P4RollBack()
+ "debug" : P4Debug,
+ "submit" : P4Submit,
+ "sync" : P4Sync,
+ "rebase" : P4Rebase,
+ "clone" : P4Clone,
+ "rollback" : P4RollBack,
+ "branches" : P4Branches
}
cmd = ""
cmdName = sys.argv[1]
try:
- cmd = commands[cmdName]
+ klass = commands[cmdName]
+ cmd = klass()
except KeyError:
print "unknown command %s" % cmdName
print ""
sys.exit(2)
options = cmd.options
- cmd.gitdir = gitdir
+ cmd.gitdir = os.environ.get("GIT_DIR", None)
args = sys.argv[2:]
global verbose
verbose = cmd.verbose
if cmd.needsGit:
- gitdir = cmd.gitdir
- if len(gitdir) == 0:
- gitdir = ".git"
- if not isValidGitDir(gitdir):
- gitdir = read_pipe("git rev-parse --git-dir").strip()
- if os.path.exists(gitdir):
+ 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):
cdup = read_pipe("git rev-parse --show-cdup").strip()
if len(cdup) > 0:
os.chdir(cdup);
- if not isValidGitDir(gitdir):
- if isValidGitDir(gitdir + "/.git"):
- gitdir += "/.git"
+ if not isValidGitDir(cmd.gitdir):
+ if isValidGitDir(cmd.gitdir + "/.git"):
+ cmd.gitdir += "/.git"
else:
- die("fatal: cannot locate git repository at %s" % gitdir)
+ die("fatal: cannot locate git repository at %s" % cmd.gitdir)
- os.environ["GIT_DIR"] = gitdir
+ os.environ["GIT_DIR"] = cmd.gitdir
if not cmd.run(args):
parser.print_help()