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
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()
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
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:
## Should move this out, doesn't use SELF.
def readP4Files(self, files):
- specs = [(f['path'] + "#" + f['rev'], f) for f in files]
+ files = [f for f in files
+ if f['action'] != 'delete']
- data = read_pipe('p4 print %s' % ' '.join(['"%s"' % spec
- for (spec, info) in specs]))
+ if not files:
+ return
- idx = 0
- for j in range(0, len(specs)):
- filespec, info = specs[j]
+ filedata = p4CmdList('print %s' % ' '.join(['"%s#%s"' % (f['path'],
+ f['rev'])
+ for f in files]))
- assert idx < len(data)
- if data[idx:idx + len(filespec)] != filespec:
- assert False
- idx = data.find ('\n', idx)
- assert idx > 0
- idx += 1
+ 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
- start = idx
- end = -1
- if j < len(specs)-1:
- next_spec, next_info = specs[j+1]
- end = data.find(next_spec, start)
+ if not stat.has_key('depotFile'):
+ sys.stderr.write("p4 print fails with: %s\n" % repr(stat))
+ continue
- assert end >= 0
- else:
- end = len(data)
+ contents[stat['depotFile']] = text
- info['data'] = data[start:end]
- idx = end
- assert idx == len(data)
+ 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"]
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"])
self.committedChanges.add(int(details["change"]))
print "parent %s" % parent
self.gitStream.write("from %s\n" % parent)
-
- 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)
for file in files:
if file["type"] == "apple":
print "\nfile %s is a strange apple file that forks. Ignoring!" % file['path']
if self.isWindows and file["type"].endswith("text"):
data = data.replace("\r\n", "\n")
- self.gitStream.write("M %s inline %s\n" % (mode, relPath))
+ self.gitStream.write("M %d inline %s\n" % (mode, relPath))
self.gitStream.write("data %s\n" % len(data))
self.gitStream.write(data)
self.gitStream.write("\n")
print ("Tag %s does not match with change %s: file count is different."
% (labelDetails["label"], change))
+ def getUserCacheFilename(self):
+ return os.environ["HOME"] + "/.gitp4-usercache.txt"
+
def getUserMapFromPerforceServer(self):
if self.userMapFromPerforceServer:
return
continue
self.users[output["User"]] = output["FullName"] + " <" + output["Email"] + ">"
- cache = open(self.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(self.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 guessProjectName(self):
+ for p in self.depotPaths:
+ return p [p.strip().rfind("/") + 1:]
+
def getBranchMapping(self):
## FIXME - what's a P4 projectName ?
- self.projectName = self.depotPath[self.depotPath.strip().rfind("/") + 1:]
+ self.projectName = self.guessProjectName()
for info in p4CmdList("branches"):
details = p4Cmd("branch -o %s" % info["branch"])
for line in read_pipe_lines(cmdline):
line = line.strip()
- if self.importIntoRemotes and ((not line.startswith("p4/")) or line == "p4/HEAD"):
- continue
+ ## only import to p4/
+ if not line.startswith('p4/'):
+ continue
+ branch = line
if self.importIntoRemotes:
# strip off p4
branch = re.sub ("^p4/", "", line)
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)
for line in read_pipe_lines("git rev-parse --symbolic --remotes"):
line = line.strip()
system("git fetch origin")
if len(self.branch) == 0:
- self.branch = self.refPrefix + "master"
+ self.branch = self.refPrefix + "p4/master"
if gitBranchExists("refs/heads/p4") and self.importIntoRemotes:
system("git update-ref %s refs/heads/p4" % self.branch)
system("git branch -D p4");
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')):
self.gitStream = importProcess.stdin
self.gitError = importProcess.stderr
- if len(self.revision) > 0:
+ if self.revision:
print "Doing initial import of %s from revision %s" % (' '.join(self.depotPaths), self.revision)
details = { "user" : "git perforce import user", "time" : int(time.time()) }
+ ' '.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)
if not self.cloneDestination:
self.cloneDestination = self.defaultDestination()
- print "Importing from %s into %s" % (`depotPaths`, self.cloneDestination)
+ print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
os.makedirs(self.cloneDestination)
os.chdir(self.cloneDestination)
system("git init")
system("git checkout -f")
else:
print "Could not detect main branch. No checkout/master branch created."
+
return True
class HelpFormatter(optparse.IndentedHelpFormatter):