git.oblomov.eu Git - git/blob - contrib/fast-import/git-p4

   1 #!/usr/bin/env python
   2 #
   3 # git-p4.py -- A tool for bidirectional operation between a Perforce depot and git.
   4 #
   5 # Author: Simon Hausmann <simon@lst.de>
   6 # Copyright: 2007 Simon Hausmann <simon@lst.de>
   7 #            2007 Trolltech ASA
   8 # License: MIT <http://www.opensource.org/licenses/mit-license.php>
   9 #
  10
  11 import optparse, sys, os, marshal, popen2, subprocess, shelve
  12 import tempfile, getopt, sha, os.path, time, platform
  13 import re
  14
  15 from sets import Set;
  16
  17 verbose = False
  18
  19 def die(msg):
  20     if verbose:
  21         raise Exception(msg)
  22     else:
  23         sys.stderr.write(msg + "\n")
  24         sys.exit(1)
  25
  26 def write_pipe(c, str):
  27     if verbose:
  28         sys.stderr.write('Writing pipe: %s\n' % c)
  29
  30     pipe = os.popen(c, 'w')
  31     val = pipe.write(str)
  32     if pipe.close():
  33         die('Command failed: %s' % c)
  34
  35     return val
  36
  37 def read_pipe(c, ignore_error=False):
  38     if verbose:
  39         sys.stderr.write('Reading pipe: %s\n' % c)
  40
  41     pipe = os.popen(c, 'rb')
  42     val = pipe.read()
  43     if pipe.close() and not ignore_error:
  44         die('Command failed: %s' % c)
  45
  46     return val
  47
  48
  49 def read_pipe_lines(c):
  50     if verbose:
  51         sys.stderr.write('Reading pipe: %s\n' % c)
  52     ## todo: check return status
  53     pipe = os.popen(c, 'rb')
  54     val = pipe.readlines()
  55     if pipe.close():
  56         die('Command failed: %s' % c)
  57
  58     return val
  59
  60 def system(cmd):
  61     if verbose:
  62         sys.stderr.write("executing %s\n" % cmd)
  63     if os.system(cmd) != 0:
  64         die("command failed: %s" % cmd)
  65
  66 def isP4Exec(kind):
  67     """Determine if a Perforce 'kind' should have execute permission
  68
  69     'p4 help filetypes' gives a list of the types.  If it starts with 'x',
  70     or x follows one of a few letters.  Otherwise, if there is an 'x' after
  71     a plus sign, it is also executable"""
  72     return (re.search(r"(^[cku]?x)|\+.*x", kind) != None)
  73
  74 def setP4ExecBit(file, mode):
  75     # Reopens an already open file and changes the execute bit to match
  76     # the execute bit setting in the passed in mode.
  77
  78     p4Type = "+x"
  79
  80     if not isModeExec(mode):
  81         p4Type = getP4OpenedType(file)
  82         p4Type = re.sub('^([cku]?)x(.*)', '\\1\\2', p4Type)
  83         p4Type = re.sub('(.*?\+.*?)x(.*?)', '\\1\\2', p4Type)
  84         if p4Type[-1] == "+":
  85             p4Type = p4Type[0:-1]
  86
  87     system("p4 reopen -t %s %s" % (p4Type, file))
  88
  89 def getP4OpenedType(file):
  90     # Returns the perforce file type for the given file.
  91
  92     result = read_pipe("p4 opened %s" % file)
  93     match = re.match(".*\((.+)\)$", result)
  94     if match:
  95         return match.group(1)
  96     else:
  97         die("Could not determine file type for %s" % file)
  98
  99 def diffTreePattern():
 100     # This is a simple generator for the diff tree regex pattern. This could be
 101     # a class variable if this and parseDiffTreeEntry were a part of a class.
 102     pattern = re.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)')
 103     while True:
 104         yield pattern
 105
 106 def parseDiffTreeEntry(entry):
 107     """Parses a single diff tree entry into its component elements.
 108
 109     See git-diff-tree(1) manpage for details about the format of the diff
 110     output. This method returns a dictionary with the following elements:
 111
 112     src_mode - The mode of the source file
 113     dst_mode - The mode of the destination file
 114     src_sha1 - The sha1 for the source file
 115     dst_sha1 - The sha1 fr the destination file
 116     status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc)
 117     status_score - The score for the status (applicable for 'C' and 'R'
 118                    statuses). This is None if there is no score.
 119     src - The path for the source file.
 120     dst - The path for the destination file. This is only present for
 121           copy or renames. If it is not present, this is None.
 122
 123     If the pattern is not matched, None is returned."""
 124
 125     match = diffTreePattern().next().match(entry)
 126     if match:
 127         return {
 128             'src_mode': match.group(1),
 129             'dst_mode': match.group(2),
 130             'src_sha1': match.group(3),
 131             'dst_sha1': match.group(4),
 132             'status': match.group(5),
 133             'status_score': match.group(6),
 134             'src': match.group(7),
 135             'dst': match.group(10)
 136         }
 137     return None
 138
 139 def isModeExec(mode):
 140     # Returns True if the given git mode represents an executable file,
 141     # otherwise False.
 142     return mode[-3:] == "755"
 143
 144 def isModeExecChanged(src_mode, dst_mode):
 145     return isModeExec(src_mode) != isModeExec(dst_mode)
 146
 147 def p4CmdList(cmd, stdin=None, stdin_mode='w+b'):
 148     cmd = "p4 -G %s" % cmd
 149     if verbose:
 150         sys.stderr.write("Opening pipe: %s\n" % cmd)
 151
 152     # Use a temporary file to avoid deadlocks without
 153     # subprocess.communicate(), which would put another copy
 154     # of stdout into memory.
 155     stdin_file = None
 156     if stdin is not None:
 157         stdin_file = tempfile.TemporaryFile(prefix='p4-stdin', mode=stdin_mode)
 158         stdin_file.write(stdin)
 159         stdin_file.flush()
 160         stdin_file.seek(0)
 161
 162     p4 = subprocess.Popen(cmd, shell=True,
 163                           stdin=stdin_file,
 164                           stdout=subprocess.PIPE)
 165
 166     result = []
 167     try:
 168         while True:
 169             entry = marshal.load(p4.stdout)
 170             result.append(entry)
 171     except EOFError:
 172         pass
 173     exitCode = p4.wait()
 174     if exitCode != 0:
 175         entry = {}
 176         entry["p4ExitCode"] = exitCode
 177         result.append(entry)
 178
 179     return result
 180
 181 def p4Cmd(cmd):
 182     list = p4CmdList(cmd)
 183     result = {}
 184     for entry in list:
 185         result.update(entry)
 186     return result;
 187
 188 def p4Where(depotPath):
 189     if not depotPath.endswith("/"):
 190         depotPath += "/"
 191     output = p4Cmd("where %s..." % depotPath)
 192     if output["code"] == "error":
 193         return ""
 194     clientPath = ""
 195     if "path" in output:
 196         clientPath = output.get("path")
 197     elif "data" in output:
 198         data = output.get("data")
 199         lastSpace = data.rfind(" ")
 200         clientPath = data[lastSpace + 1:]
 201
 202     if clientPath.endswith("..."):
 203         clientPath = clientPath[:-3]
 204     return clientPath
 205
 206 def currentGitBranch():
 207     return read_pipe("git name-rev HEAD").split(" ")[1].strip()
 208
 209 def isValidGitDir(path):
 210     if (os.path.exists(path + "/HEAD")
 211         and os.path.exists(path + "/refs") and os.path.exists(path + "/objects")):
 212         return True;
 213     return False
 214
 215 def parseRevision(ref):
 216     return read_pipe("git rev-parse %s" % ref).strip()
 217
 218 def extractLogMessageFromGitCommit(commit):
 219     logMessage = ""
 220
 221     ## fixme: title is first line of commit, not 1st paragraph.
 222     foundTitle = False
 223     for log in read_pipe_lines("git cat-file commit %s" % commit):
 224        if not foundTitle:
 225            if len(log) == 1:
 226                foundTitle = True
 227            continue
 228
 229        logMessage += log
 230     return logMessage
 231
 232 def extractSettingsGitLog(log):
 233     values = {}
 234     for line in log.split("\n"):
 235         line = line.strip()
 236         m = re.search (r"^ *\[git-p4: (.*)\]$", line)
 237         if not m:
 238             continue
 239
 240         assignments = m.group(1).split (':')
 241         for a in assignments:
 242             vals = a.split ('=')
 243             key = vals[0].strip()
 244             val = ('='.join (vals[1:])).strip()
 245             if val.endswith ('\"') and val.startswith('"'):
 246                 val = val[1:-1]
 247
 248             values[key] = val
 249
 250     paths = values.get("depot-paths")
 251     if not paths:
 252         paths = values.get("depot-path")
 253     if paths:
 254         values['depot-paths'] = paths.split(',')
 255     return values
 256
 257 def gitBranchExists(branch):
 258     proc = subprocess.Popen(["git", "rev-parse", branch],
 259                             stderr=subprocess.PIPE, stdout=subprocess.PIPE);
 260     return proc.wait() == 0;
 261
 262 def gitConfig(key):
 263     return read_pipe("git config %s" % key, ignore_error=True).strip()
 264
 265 def p4BranchesInGit(branchesAreInRemotes = True):
 266     branches = {}
 267
 268     cmdline = "git rev-parse --symbolic "
 269     if branchesAreInRemotes:
 270         cmdline += " --remotes"
 271     else:
 272         cmdline += " --branches"
 273
 274     for line in read_pipe_lines(cmdline):
 275         line = line.strip()
 276
 277         ## only import to p4/
 278         if not line.startswith('p4/') or line == "p4/HEAD":
 279             continue
 280         branch = line
 281
 282         # strip off p4
 283         branch = re.sub ("^p4/", "", line)
 284
 285         branches[branch] = parseRevision(line)
 286     return branches
 287
 288 def findUpstreamBranchPoint(head = "HEAD"):
 289     branches = p4BranchesInGit()
 290     # map from depot-path to branch name
 291     branchByDepotPath = {}
 292     for branch in branches.keys():
 293         tip = branches[branch]
 294         log = extractLogMessageFromGitCommit(tip)
 295         settings = extractSettingsGitLog(log)
 296         if settings.has_key("depot-paths"):
 297             paths = ",".join(settings["depot-paths"])
 298             branchByDepotPath[paths] = "remotes/p4/" + branch
 299
 300     settings = None
 301     parent = 0
 302     while parent < 65535:
 303         commit = head + "~%s" % parent
 304         log = extractLogMessageFromGitCommit(commit)
 305         settings = extractSettingsGitLog(log)
 306         if settings.has_key("depot-paths"):
 307             paths = ",".join(settings["depot-paths"])
 308             if branchByDepotPath.has_key(paths):
 309                 return [branchByDepotPath[paths], settings]
 310
 311         parent = parent + 1
 312
 313     return ["", settings]
 314
 315 def createOrUpdateBranchesFromOrigin(localRefPrefix = "refs/remotes/p4/", silent=True):
 316     if not silent:
 317         print ("Creating/updating branch(es) in %s based on origin branch(es)"
 318                % localRefPrefix)
 319
 320     originPrefix = "origin/p4/"
 321
 322     for line in read_pipe_lines("git rev-parse --symbolic --remotes"):
 323         line = line.strip()
 324         if (not line.startswith(originPrefix)) or line.endswith("HEAD"):
 325             continue
 326
 327         headName = line[len(originPrefix):]
 328         remoteHead = localRefPrefix + headName
 329         originHead = line
 330
 331         original = extractSettingsGitLog(extractLogMessageFromGitCommit(originHead))
 332         if (not original.has_key('depot-paths')
 333             or not original.has_key('change')):
 334             continue
 335
 336         update = False
 337         if not gitBranchExists(remoteHead):
 338             if verbose:
 339                 print "creating %s" % remoteHead
 340             update = True
 341         else:
 342             settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead))
 343             if settings.has_key('change') > 0:
 344                 if settings['depot-paths'] == original['depot-paths']:
 345                     originP4Change = int(original['change'])
 346                     p4Change = int(settings['change'])
 347                     if originP4Change > p4Change:
 348                         print ("%s (%s) is newer than %s (%s). "
 349                                "Updating p4 branch from origin."
 350                                % (originHead, originP4Change,
 351                                   remoteHead, p4Change))
 352                         update = True
 353                 else:
 354                     print ("Ignoring: %s was imported from %s while "
 355                            "%s was imported from %s"
 356                            % (originHead, ','.join(original['depot-paths']),
 357                               remoteHead, ','.join(settings['depot-paths'])))
 358
 359         if update:
 360             system("git update-ref %s %s" % (remoteHead, originHead))
 361
 362 def originP4BranchesExist():
 363         return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
 364
 365 def p4ChangesForPaths(depotPaths, changeRange):
 366     assert depotPaths
 367     output = read_pipe_lines("p4 changes " + ' '.join (["%s...%s" % (p, changeRange)
 368                                                         for p in depotPaths]))
 369
 370     changes = []
 371     for line in output:
 372         changeNum = line.split(" ")[1]
 373         changes.append(int(changeNum))
 374
 375     changes.sort()
 376     return changes
 377
 378 class Command:
 379     def __init__(self):
 380         self.usage = "usage: %prog [options]"
 381         self.needsGit = True
 382
 383 class P4Debug(Command):
 384     def __init__(self):
 385         Command.__init__(self)
 386         self.options = [
 387             optparse.make_option("--verbose", dest="verbose", action="store_true",
 388                                  default=False),
 389             ]
 390         self.description = "A tool to debug the output of p4 -G."
 391         self.needsGit = False
 392         self.verbose = False
 393
 394     def run(self, args):
 395         j = 0
 396         for output in p4CmdList(" ".join(args)):
 397             print 'Element: %d' % j
 398             j += 1
 399             print output
 400         return True
 401
 402 class P4RollBack(Command):
 403     def __init__(self):
 404         Command.__init__(self)
 405         self.options = [
 406             optparse.make_option("--verbose", dest="verbose", action="store_true"),
 407             optparse.make_option("--local", dest="rollbackLocalBranches", action="store_true")
 408         ]
 409         self.description = "A tool to debug the multi-branch import. Don't use :)"
 410         self.verbose = False
 411         self.rollbackLocalBranches = False
 412
 413     def run(self, args):
 414         if len(args) != 1:
 415             return False
 416         maxChange = int(args[0])
 417
 418         if "p4ExitCode" in p4Cmd("changes -m 1"):
 419             die("Problems executing p4");
 420
 421         if self.rollbackLocalBranches:
 422             refPrefix = "refs/heads/"
 423             lines = read_pipe_lines("git rev-parse --symbolic --branches")
 424         else:
 425             refPrefix = "refs/remotes/"
 426             lines = read_pipe_lines("git rev-parse --symbolic --remotes")
 427
 428         for line in lines:
 429             if self.rollbackLocalBranches or (line.startswith("p4/") and line != "p4/HEAD\n"):
 430                 line = line.strip()
 431                 ref = refPrefix + line
 432                 log = extractLogMessageFromGitCommit(ref)
 433                 settings = extractSettingsGitLog(log)
 434
 435                 depotPaths = settings['depot-paths']
 436                 change = settings['change']
 437
 438                 changed = False
 439
 440                 if len(p4Cmd("changes -m 1 "  + ' '.join (['%s...@%s' % (p, maxChange)
 441                                                            for p in depotPaths]))) == 0:
 442                     print "Branch %s did not exist at change %s, deleting." % (ref, maxChange)
 443                     system("git update-ref -d %s `git rev-parse %s`" % (ref, ref))
 444                     continue
 445
 446                 while change and int(change) > maxChange:
 447                     changed = True
 448                     if self.verbose:
 449                         print "%s is at %s ; rewinding towards %s" % (ref, change, maxChange)
 450                     system("git update-ref %s \"%s^\"" % (ref, ref))
 451                     log = extractLogMessageFromGitCommit(ref)
 452                     settings =  extractSettingsGitLog(log)
 453
 454
 455                     depotPaths = settings['depot-paths']
 456                     change = settings['change']
 457
 458                 if changed:
 459                     print "%s rewound to %s" % (ref, change)
 460
 461         return True
 462
 463 class P4Submit(Command):
 464     def __init__(self):
 465         Command.__init__(self)
 466         self.options = [
 467                 optparse.make_option("--continue", action="store_false", dest="firstTime"),
 468                 optparse.make_option("--verbose", dest="verbose", action="store_true"),
 469                 optparse.make_option("--origin", dest="origin"),
 470                 optparse.make_option("--reset", action="store_true", dest="reset"),
 471                 optparse.make_option("--log-substitutions", dest="substFile"),
 472                 optparse.make_option("--direct", dest="directSubmit", action="store_true"),
 473                 optparse.make_option("-M", dest="detectRename", action="store_true"),
 474         ]
 475         self.description = "Submit changes from git to the perforce depot."
 476         self.usage += " [name of git branch to submit into perforce depot]"
 477         self.firstTime = True
 478         self.reset = False
 479         self.interactive = True
 480         self.substFile = ""
 481         self.firstTime = True
 482         self.origin = ""
 483         self.directSubmit = False
 484         self.detectRename = False
 485         self.verbose = False
 486         self.isWindows = (platform.system() == "Windows")
 487
 488         self.logSubstitutions = {}
 489         self.logSubstitutions["<enter description here>"] = "%log%"
 490         self.logSubstitutions["\tDetails:"] = "\tDetails:  %log%"
 491
 492     def check(self):
 493         if len(p4CmdList("opened ...")) > 0:
 494             die("You have files opened with perforce! Close them before starting the sync.")
 495
 496     def start(self):
 497         if len(self.config) > 0 and not self.reset:
 498             die("Cannot start sync. Previous sync config found at %s\n"
 499                 "If you want to start submitting again from scratch "
 500                 "maybe you want to call git-p4 submit --reset" % self.configFile)
 501
 502         commits = []
 503         if self.directSubmit:
 504             commits.append("0")
 505         else:
 506             for line in read_pipe_lines("git rev-list --no-merges %s..%s" % (self.origin, self.master)):
 507                 commits.append(line.strip())
 508             commits.reverse()
 509
 510         self.config["commits"] = commits
 511
 512     def prepareLogMessage(self, template, message):
 513         result = ""
 514
 515         for line in template.split("\n"):
 516             if line.startswith("#"):
 517                 result += line + "\n"
 518                 continue
 519
 520             substituted = False
 521             for key in self.logSubstitutions.keys():
 522                 if line.find(key) != -1:
 523                     value = self.logSubstitutions[key]
 524                     value = value.replace("%log%", message)
 525                     if value != "@remove@":
 526                         result += line.replace(key, value) + "\n"
 527                     substituted = True
 528                     break
 529
 530             if not substituted:
 531                 result += line + "\n"
 532
 533         return result
 534
 535     def prepareSubmitTemplate(self):
 536         # remove lines in the Files section that show changes to files outside the depot path we're committing into
 537         template = ""
 538         inFilesSection = False
 539         for line in read_pipe_lines("p4 change -o"):
 540             if inFilesSection:
 541                 if line.startswith("\t"):
 542                     # path starts and ends with a tab
 543                     path = line[1:]
 544                     lastTab = path.rfind("\t")
 545                     if lastTab != -1:
 546                         path = path[:lastTab]
 547                         if not path.startswith(self.depotPath):
 548                             continue
 549                 else:
 550                     inFilesSection = False
 551             else:
 552                 if line.startswith("Files:"):
 553                     inFilesSection = True
 554
 555             template += line
 556
 557         return template
 558
 559     def applyCommit(self, id):
 560         if self.directSubmit:
 561             print "Applying local change in working directory/index"
 562             diff = self.diffStatus
 563         else:
 564             print "Applying %s" % (read_pipe("git log --max-count=1 --pretty=oneline %s" % id))
 565             diffOpts = ("", "-M")[self.detectRename]
 566             diff = read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (diffOpts, id, id))
 567         filesToAdd = set()
 568         filesToDelete = set()
 569         editedFiles = set()
 570         filesToChangeExecBit = {}
 571         for line in diff:
 572             diff = parseDiffTreeEntry(line)
 573             modifier = diff['status']
 574             path = diff['src']
 575             if modifier == "M":
 576                 system("p4 edit \"%s\"" % path)
 577                 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
 578                     filesToChangeExecBit[path] = diff['dst_mode']
 579                 editedFiles.add(path)
 580             elif modifier == "A":
 581                 filesToAdd.add(path)
 582                 filesToChangeExecBit[path] = diff['dst_mode']
 583                 if path in filesToDelete:
 584                     filesToDelete.remove(path)
 585             elif modifier == "D":
 586                 filesToDelete.add(path)
 587                 if path in filesToAdd:
 588                     filesToAdd.remove(path)
 589             elif modifier == "R":
 590                 src, dest = diff['src'], diff['dst']
 591                 system("p4 integrate -Dt \"%s\" \"%s\"" % (src, dest))
 592                 system("p4 edit \"%s\"" % (dest))
 593                 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
 594                     filesToChangeExecBit[dest] = diff['dst_mode']
 595                 os.unlink(dest)
 596                 editedFiles.add(dest)
 597                 filesToDelete.add(src)
 598             else:
 599                 die("unknown modifier %s for %s" % (modifier, path))
 600
 601         if self.directSubmit:
 602             diffcmd = "cat \"%s\"" % self.diffFile
 603         else:
 604             diffcmd = "git format-patch -k --stdout \"%s^\"..\"%s\"" % (id, id)
 605         patchcmd = diffcmd + " | git apply "
 606         tryPatchCmd = patchcmd + "--check -"
 607         applyPatchCmd = patchcmd + "--check --apply -"
 608
 609         if os.system(tryPatchCmd) != 0:
 610             print "Unfortunately applying the change failed!"
 611             print "What do you want to do?"
 612             response = "x"
 613             while response != "s" and response != "a" and response != "w":
 614                 response = raw_input("[s]kip this patch / [a]pply the patch forcibly "
 615                                      "and with .rej files / [w]rite the patch to a file (patch.txt) ")
 616             if response == "s":
 617                 print "Skipping! Good luck with the next patches..."
 618                 for f in editedFiles:
 619                     system("p4 revert \"%s\"" % f);
 620                 for f in filesToAdd:
 621                     system("rm %s" %f)
 622                 return
 623             elif response == "a":
 624                 os.system(applyPatchCmd)
 625                 if len(filesToAdd) > 0:
 626                     print "You may also want to call p4 add on the following files:"
 627                     print " ".join(filesToAdd)
 628                 if len(filesToDelete):
 629                     print "The following files should be scheduled for deletion with p4 delete:"
 630                     print " ".join(filesToDelete)
 631                 die("Please resolve and submit the conflict manually and "
 632                     + "continue afterwards with git-p4 submit --continue")
 633             elif response == "w":
 634                 system(diffcmd + " > patch.txt")
 635                 print "Patch saved to patch.txt in %s !" % self.clientPath
 636                 die("Please resolve and submit the conflict manually and "
 637                     "continue afterwards with git-p4 submit --continue")
 638
 639         system(applyPatchCmd)
 640
 641         for f in filesToAdd:
 642             system("p4 add \"%s\"" % f)
 643         for f in filesToDelete:
 644             system("p4 revert \"%s\"" % f)
 645             system("p4 delete \"%s\"" % f)
 646
 647         # Set/clear executable bits
 648         for f in filesToChangeExecBit.keys():
 649             mode = filesToChangeExecBit[f]
 650             setP4ExecBit(f, mode)
 651
 652         logMessage = ""
 653         if not self.directSubmit:
 654             logMessage = extractLogMessageFromGitCommit(id)
 655             logMessage = logMessage.replace("\n", "\n\t")
 656             if self.isWindows:
 657                 logMessage = logMessage.replace("\n", "\r\n")
 658             logMessage = logMessage.strip()
 659
 660         template = self.prepareSubmitTemplate()
 661
 662         if self.interactive:
 663             submitTemplate = self.prepareLogMessage(template, logMessage)
 664             diff = read_pipe("p4 diff -du ...")
 665
 666             for newFile in filesToAdd:
 667                 diff += "==== new file ====\n"
 668                 diff += "--- /dev/null\n"
 669                 diff += "+++ %s\n" % newFile
 670                 f = open(newFile, "r")
 671                 for line in f.readlines():
 672                     diff += "+" + line
 673                 f.close()
 674
 675             separatorLine = "######## everything below this line is just the diff #######"
 676             if platform.system() == "Windows":
 677                 separatorLine += "\r"
 678             separatorLine += "\n"
 679
 680             [handle, fileName] = tempfile.mkstemp()
 681             tmpFile = os.fdopen(handle, "w+")
 682             tmpFile.write(submitTemplate + separatorLine + diff)
 683             tmpFile.close()
 684             defaultEditor = "vi"
 685             if platform.system() == "Windows":
 686                 defaultEditor = "notepad"
 687             editor = os.environ.get("EDITOR", defaultEditor);
 688             system(editor + " " + fileName)
 689             tmpFile = open(fileName, "rb")
 690             message = tmpFile.read()
 691             tmpFile.close()
 692             os.remove(fileName)
 693             submitTemplate = message[:message.index(separatorLine)]
 694             if self.isWindows:
 695                 submitTemplate = submitTemplate.replace("\r\n", "\n")
 696
 697             if self.directSubmit:
 698                 print "Submitting to git first"
 699                 os.chdir(self.oldWorkingDirectory)
 700                 write_pipe("git commit -a -F -", submitTemplate)
 701                 os.chdir(self.clientPath)
 702
 703             write_pipe("p4 submit -i", submitTemplate)
 704         else:
 705             fileName = "submit.txt"
 706             file = open(fileName, "w+")
 707             file.write(self.prepareLogMessage(template, logMessage))
 708             file.close()
 709             print ("Perforce submit template written as %s. "
 710                    + "Please review/edit and then use p4 submit -i < %s to submit directly!"
 711                    % (fileName, fileName))
 712
 713     def run(self, args):
 714         if len(args) == 0:
 715             self.master = currentGitBranch()
 716             if len(self.master) == 0 or not gitBranchExists("refs/heads/%s" % self.master):
 717                 die("Detecting current git branch failed!")
 718         elif len(args) == 1:
 719             self.master = args[0]
 720         else:
 721             return False
 722
 723         [upstream, settings] = findUpstreamBranchPoint()
 724         self.depotPath = settings['depot-paths'][0]
 725         if len(self.origin) == 0:
 726             self.origin = upstream
 727
 728         if self.verbose:
 729             print "Origin branch is " + self.origin
 730
 731         if len(self.depotPath) == 0:
 732             print "Internal error: cannot locate perforce depot path from existing branches"
 733             sys.exit(128)
 734
 735         self.clientPath = p4Where(self.depotPath)
 736
 737         if len(self.clientPath) == 0:
 738             print "Error: Cannot locate perforce checkout of %s in client view" % self.depotPath
 739             sys.exit(128)
 740
 741         print "Perforce checkout for depot path %s located at %s" % (self.depotPath, self.clientPath)
 742         self.oldWorkingDirectory = os.getcwd()
 743
 744         if self.directSubmit:
 745             self.diffStatus = read_pipe_lines("git diff -r --name-status HEAD")
 746             if len(self.diffStatus) == 0:
 747                 print "No changes in working directory to submit."
 748                 return True
 749             patch = read_pipe("git diff -p --binary --diff-filter=ACMRTUXB HEAD")
 750             self.diffFile = self.gitdir + "/p4-git-diff"
 751             f = open(self.diffFile, "wb")
 752             f.write(patch)
 753             f.close();
 754
 755         os.chdir(self.clientPath)
 756         print "Syncronizing p4 checkout..."
 757         system("p4 sync ...")
 758
 759         if self.reset:
 760             self.firstTime = True
 761
 762         if len(self.substFile) > 0:
 763             for line in open(self.substFile, "r").readlines():
 764                 tokens = line.strip().split("=")
 765                 self.logSubstitutions[tokens[0]] = tokens[1]
 766
 767         self.check()
 768         self.configFile = self.gitdir + "/p4-git-sync.cfg"
 769         self.config = shelve.open(self.configFile, writeback=True)
 770
 771         if self.firstTime:
 772             self.start()
 773
 774         commits = self.config.get("commits", [])
 775
 776         while len(commits) > 0:
 777             self.firstTime = False
 778             commit = commits[0]
 779             commits = commits[1:]
 780             self.config["commits"] = commits
 781             self.applyCommit(commit)
 782             if not self.interactive:
 783                 break
 784
 785         self.config.close()
 786
 787         if self.directSubmit:
 788             os.remove(self.diffFile)
 789
 790         if len(commits) == 0:
 791             if self.firstTime:
 792                 print "No changes found to apply between %s and current HEAD" % self.origin
 793             else:
 794                 print "All changes applied!"
 795                 os.chdir(self.oldWorkingDirectory)
 796
 797                 sync = P4Sync()
 798                 sync.run([])
 799
 800                 rebase = P4Rebase()
 801                 rebase.rebase()
 802             os.remove(self.configFile)
 803
 804         return True
 805
 806 class P4Sync(Command):
 807     def __init__(self):
 808         Command.__init__(self)
 809         self.options = [
 810                 optparse.make_option("--branch", dest="branch"),
 811                 optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"),
 812                 optparse.make_option("--changesfile", dest="changesFile"),
 813                 optparse.make_option("--silent", dest="silent", action="store_true"),
 814                 optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),
 815                 optparse.make_option("--verbose", dest="verbose", action="store_true"),
 816                 optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",
 817                                      help="Import into refs/heads/ , not refs/remotes"),
 818                 optparse.make_option("--max-changes", dest="maxChanges"),
 819                 optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',
 820                                      help="Keep entire BRANCH/DIR/SUBDIR prefix during import")
 821         ]
 822         self.description = """Imports from Perforce into a git repository.\n
 823     example:
 824     //depot/my/project/ -- to import the current head
 825     //depot/my/project/@all -- to import everything
 826     //depot/my/project/@1,6 -- to import only from revision 1 to 6
 827
 828     (a ... is not needed in the path p4 specification, it's added implicitly)"""
 829
 830         self.usage += " //depot/path[@revRange]"
 831         self.silent = False
 832         self.createdBranches = Set()
 833         self.committedChanges = Set()
 834         self.branch = ""
 835         self.detectBranches = False
 836         self.detectLabels = False
 837         self.changesFile = ""
 838         self.syncWithOrigin = True
 839         self.verbose = False
 840         self.importIntoRemotes = True
 841         self.maxChanges = ""
 842         self.isWindows = (platform.system() == "Windows")
 843         self.keepRepoPath = False
 844         self.depotPaths = None
 845         self.p4BranchesInGit = []
 846
 847         if gitConfig("git-p4.syncFromOrigin") == "false":
 848             self.syncWithOrigin = False
 849
 850     def extractFilesFromCommit(self, commit):
 851         files = []
 852         fnum = 0
 853         while commit.has_key("depotFile%s" % fnum):
 854             path =  commit["depotFile%s" % fnum]
 855
 856             found = [p for p in self.depotPaths
 857                      if path.startswith (p)]
 858             if not found:
 859                 fnum = fnum + 1
 860                 continue
 861
 862             file = {}
 863             file["path"] = path
 864             file["rev"] = commit["rev%s" % fnum]
 865             file["action"] = commit["action%s" % fnum]
 866             file["type"] = commit["type%s" % fnum]
 867             files.append(file)
 868             fnum = fnum + 1
 869         return files
 870
 871     def stripRepoPath(self, path, prefixes):
 872         if self.keepRepoPath:
 873             prefixes = [re.sub("^(//[^/]+/).*", r'\1', prefixes[0])]
 874
 875         for p in prefixes:
 876             if path.startswith(p):
 877                 path = path[len(p):]
 878
 879         return path
 880
 881     def splitFilesIntoBranches(self, commit):
 882         branches = {}
 883         fnum = 0
 884         while commit.has_key("depotFile%s" % fnum):
 885             path =  commit["depotFile%s" % fnum]
 886             found = [p for p in self.depotPaths
 887                      if path.startswith (p)]
 888             if not found:
 889                 fnum = fnum + 1
 890                 continue
 891
 892             file = {}
 893             file["path"] = path
 894             file["rev"] = commit["rev%s" % fnum]
 895             file["action"] = commit["action%s" % fnum]
 896             file["type"] = commit["type%s" % fnum]
 897             fnum = fnum + 1
 898
 899             relPath = self.stripRepoPath(path, self.depotPaths)
 900
 901             for branch in self.knownBranches.keys():
 902
 903                 # add a trailing slash so that a commit into qt/4.2foo doesn't end up in qt/4.2
 904                 if relPath.startswith(branch + "/"):
 905                     if branch not in branches:
 906                         branches[branch] = []
 907                     branches[branch].append(file)
 908                     break
 909
 910         return branches
 911
 912     ## Should move this out, doesn't use SELF.
 913     def readP4Files(self, files):
 914         files = [f for f in files
 915                  if f['action'] != 'delete']
 916
 917         if not files:
 918             return
 919
 920         filedata = p4CmdList('-x - print',
 921                              stdin='\n'.join(['%s#%s' % (f['path'], f['rev'])
 922                                               for f in files]),
 923                              stdin_mode='w+')
 924         if "p4ExitCode" in filedata[0]:
 925             die("Problems executing p4. Error: [%d]."
 926                 % (filedata[0]['p4ExitCode']));
 927
 928         j = 0;
 929         contents = {}
 930         while j < len(filedata):
 931             stat = filedata[j]
 932             j += 1
 933             text = ''
 934             while j < len(filedata) and filedata[j]['code'] in ('text', 'unicode', 'binary'):
 935                 tmp = filedata[j]['data']
 936                 if stat['type'] in ('text+ko', 'unicode+ko', 'binary+ko'):
 937                     tmp = re.sub(r'(?i)\$(Id|Header):[^$]*\$',r'$\1$', tmp)
 938                 elif stat['type'] in ('text+k', 'ktext', 'kxtext', 'unicode+k', 'binary+k'):
 939                     tmp = re.sub(r'(?i)\$(Id|Header|Author|Date|DateTime|Change|File|Revision):[^$]*\$',r'$\1$', tmp)
 940                 text += tmp
 941                 j += 1
 942
 943
 944             if not stat.has_key('depotFile'):
 945                 sys.stderr.write("p4 print fails with: %s\n" % repr(stat))
 946                 continue
 947
 948             contents[stat['depotFile']] = text
 949
 950         for f in files:
 951             assert not f.has_key('data')
 952             f['data'] = contents[f['path']]
 953
 954     def commit(self, details, files, branch, branchPrefixes, parent = ""):
 955         epoch = details["time"]
 956         author = details["user"]
 957
 958         if self.verbose:
 959             print "commit into %s" % branch
 960
 961         # start with reading files; if that fails, we should not
 962         # create a commit.
 963         new_files = []
 964         for f in files:
 965             if [p for p in branchPrefixes if f['path'].startswith(p)]:
 966                 new_files.append (f)
 967             else:
 968                 sys.stderr.write("Ignoring file outside of prefix: %s\n" % path)
 969         files = new_files
 970         self.readP4Files(files)
 971
 972
 973
 974
 975         self.gitStream.write("commit %s\n" % branch)
 976 #        gitStream.write("mark :%s\n" % details["change"])
 977         self.committedChanges.add(int(details["change"]))
 978         committer = ""
 979         if author not in self.users:
 980             self.getUserMapFromPerforceServer()
 981         if author in self.users:
 982             committer = "%s %s %s" % (self.users[author], epoch, self.tz)
 983         else:
 984             committer = "%s <a@b> %s %s" % (author, epoch, self.tz)
 985
 986         self.gitStream.write("committer %s\n" % committer)
 987
 988         self.gitStream.write("data <<EOT\n")
 989         self.gitStream.write(details["desc"])
 990         self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s"
 991                              % (','.join (branchPrefixes), details["change"]))
 992         if len(details['options']) > 0:
 993             self.gitStream.write(": options = %s" % details['options'])
 994         self.gitStream.write("]\nEOT\n\n")
 995
 996         if len(parent) > 0:
 997             if self.verbose:
 998                 print "parent %s" % parent
 999             self.gitStream.write("from %s\n" % parent)
1000
1001         for file in files:
1002             if file["type"] == "apple":
1003                 print "\nfile %s is a strange apple file that forks. Ignoring!" % file['path']
1004                 continue
1005
1006             relPath = self.stripRepoPath(file['path'], branchPrefixes)
1007             if file["action"] == "delete":
1008                 self.gitStream.write("D %s\n" % relPath)
1009             else:
1010                 data = file['data']
1011
1012                 mode = "644"
1013                 if isP4Exec(file["type"]):
1014                     mode = "755"
1015                 elif file["type"] == "symlink":
1016                     mode = "120000"
1017                     # p4 print on a symlink contains "target\n", so strip it off
1018                     data = data[:-1]
1019
1020                 if self.isWindows and file["type"].endswith("text"):
1021                     data = data.replace("\r\n", "\n")
1022
1023                 self.gitStream.write("M %s inline %s\n" % (mode, relPath))
1024                 self.gitStream.write("data %s\n" % len(data))
1025                 self.gitStream.write(data)
1026                 self.gitStream.write("\n")
1027
1028         self.gitStream.write("\n")
1029
1030         change = int(details["change"])
1031
1032         if self.labels.has_key(change):
1033             label = self.labels[change]
1034             labelDetails = label[0]
1035             labelRevisions = label[1]
1036             if self.verbose:
1037                 print "Change %s is labelled %s" % (change, labelDetails)
1038
1039             files = p4CmdList("files " + ' '.join (["%s...@%s" % (p, change)
1040                                                     for p in branchPrefixes]))
1041
1042             if len(files) == len(labelRevisions):
1043
1044                 cleanedFiles = {}
1045                 for info in files:
1046                     if info["action"] == "delete":
1047                         continue
1048                     cleanedFiles[info["depotFile"]] = info["rev"]
1049
1050                 if cleanedFiles == labelRevisions:
1051                     self.gitStream.write("tag tag_%s\n" % labelDetails["label"])
1052                     self.gitStream.write("from %s\n" % branch)
1053
1054                     owner = labelDetails["Owner"]
1055                     tagger = ""
1056                     if author in self.users:
1057                         tagger = "%s %s %s" % (self.users[owner], epoch, self.tz)
1058                     else:
1059                         tagger = "%s <a@b> %s %s" % (owner, epoch, self.tz)
1060                     self.gitStream.write("tagger %s\n" % tagger)
1061                     self.gitStream.write("data <<EOT\n")
1062                     self.gitStream.write(labelDetails["Description"])
1063                     self.gitStream.write("EOT\n\n")
1064
1065                 else:
1066                     if not self.silent:
1067                         print ("Tag %s does not match with change %s: files do not match."
1068                                % (labelDetails["label"], change))
1069
1070             else:
1071                 if not self.silent:
1072                     print ("Tag %s does not match with change %s: file count is different."
1073                            % (labelDetails["label"], change))
1074
1075     def getUserCacheFilename(self):
1076         home = os.environ.get("HOME", os.environ.get("USERPROFILE"))
1077         return home + "/.gitp4-usercache.txt"
1078
1079     def getUserMapFromPerforceServer(self):
1080         if self.userMapFromPerforceServer:
1081             return
1082         self.users = {}
1083
1084         for output in p4CmdList("users"):
1085             if not output.has_key("User"):
1086                 continue
1087             self.users[output["User"]] = output["FullName"] + " <" + output["Email"] + ">"
1088
1089
1090         s = ''
1091         for (key, val) in self.users.items():
1092             s += "%s\t%s\n" % (key, val)
1093
1094         open(self.getUserCacheFilename(), "wb").write(s)
1095         self.userMapFromPerforceServer = True
1096
1097     def loadUserMapFromCache(self):
1098         self.users = {}
1099         self.userMapFromPerforceServer = False
1100         try:
1101             cache = open(self.getUserCacheFilename(), "rb")
1102             lines = cache.readlines()
1103             cache.close()
1104             for line in lines:
1105                 entry = line.strip().split("\t")
1106                 self.users[entry[0]] = entry[1]
1107         except IOError:
1108             self.getUserMapFromPerforceServer()
1109
1110     def getLabels(self):
1111         self.labels = {}
1112
1113         l = p4CmdList("labels %s..." % ' '.join (self.depotPaths))
1114         if len(l) > 0 and not self.silent:
1115             print "Finding files belonging to labels in %s" % `self.depotPaths`
1116
1117         for output in l:
1118             label = output["label"]
1119             revisions = {}
1120             newestChange = 0
1121             if self.verbose:
1122                 print "Querying files for label %s" % label
1123             for file in p4CmdList("files "
1124                                   +  ' '.join (["%s...@%s" % (p, label)
1125                                                 for p in self.depotPaths])):
1126                 revisions[file["depotFile"]] = file["rev"]
1127                 change = int(file["change"])
1128                 if change > newestChange:
1129                     newestChange = change
1130
1131             self.labels[newestChange] = [output, revisions]
1132
1133         if self.verbose:
1134             print "Label changes: %s" % self.labels.keys()
1135
1136     def guessProjectName(self):
1137         for p in self.depotPaths:
1138             if p.endswith("/"):
1139                 p = p[:-1]
1140             p = p[p.strip().rfind("/") + 1:]
1141             if not p.endswith("/"):
1142                p += "/"
1143             return p
1144
1145     def getBranchMapping(self):
1146         lostAndFoundBranches = set()
1147
1148         for info in p4CmdList("branches"):
1149             details = p4Cmd("branch -o %s" % info["branch"])
1150             viewIdx = 0
1151             while details.has_key("View%s" % viewIdx):
1152                 paths = details["View%s" % viewIdx].split(" ")
1153                 viewIdx = viewIdx + 1
1154                 # require standard //depot/foo/... //depot/bar/... mapping
1155                 if len(paths) != 2 or not paths[0].endswith("/...") or not paths[1].endswith("/..."):
1156                     continue
1157                 source = paths[0]
1158                 destination = paths[1]
1159                 ## HACK
1160                 if source.startswith(self.depotPaths[0]) and destination.startswith(self.depotPaths[0]):
1161                     source = source[len(self.depotPaths[0]):-4]
1162                     destination = destination[len(self.depotPaths[0]):-4]
1163
1164                     if destination in self.knownBranches:
1165                         if not self.silent:
1166                             print "p4 branch %s defines a mapping from %s to %s" % (info["branch"], source, destination)
1167                             print "but there exists another mapping from %s to %s already!" % (self.knownBranches[destination], destination)
1168                         continue
1169
1170                     self.knownBranches[destination] = source
1171
1172                     lostAndFoundBranches.discard(destination)
1173
1174                     if source not in self.knownBranches:
1175                         lostAndFoundBranches.add(source)
1176
1177
1178         for branch in lostAndFoundBranches:
1179             self.knownBranches[branch] = branch
1180
1181     def getBranchMappingFromGitBranches(self):
1182         branches = p4BranchesInGit(self.importIntoRemotes)
1183         for branch in branches.keys():
1184             if branch == "master":
1185                 branch = "main"
1186             else:
1187                 branch = branch[len(self.projectName):]
1188             self.knownBranches[branch] = branch
1189
1190     def listExistingP4GitBranches(self):
1191         # branches holds mapping from name to commit
1192         branches = p4BranchesInGit(self.importIntoRemotes)
1193         self.p4BranchesInGit = branches.keys()
1194         for branch in branches.keys():
1195             self.initialParents[self.refPrefix + branch] = branches[branch]
1196
1197     def updateOptionDict(self, d):
1198         option_keys = {}
1199         if self.keepRepoPath:
1200             option_keys['keepRepoPath'] = 1
1201
1202         d["options"] = ' '.join(sorted(option_keys.keys()))
1203
1204     def readOptions(self, d):
1205         self.keepRepoPath = (d.has_key('options')
1206                              and ('keepRepoPath' in d['options']))
1207
1208     def gitRefForBranch(self, branch):
1209         if branch == "main":
1210             return self.refPrefix + "master"
1211
1212         if len(branch) <= 0:
1213             return branch
1214
1215         return self.refPrefix + self.projectName + branch
1216
1217     def gitCommitByP4Change(self, ref, change):
1218         if self.verbose:
1219             print "looking in ref " + ref + " for change %s using bisect..." % change
1220
1221         earliestCommit = ""
1222         latestCommit = parseRevision(ref)
1223
1224         while True:
1225             if self.verbose:
1226                 print "trying: earliest %s latest %s" % (earliestCommit, latestCommit)
1227             next = read_pipe("git rev-list --bisect %s %s" % (latestCommit, earliestCommit)).strip()
1228             if len(next) == 0:
1229                 if self.verbose:
1230                     print "argh"
1231                 return ""
1232             log = extractLogMessageFromGitCommit(next)
1233             settings = extractSettingsGitLog(log)
1234             currentChange = int(settings['change'])
1235             if self.verbose:
1236                 print "current change %s" % currentChange
1237
1238             if currentChange == change:
1239                 if self.verbose:
1240                     print "found %s" % next
1241                 return next
1242
1243             if currentChange < change:
1244                 earliestCommit = "^%s" % next
1245             else:
1246                 latestCommit = "%s" % next
1247
1248         return ""
1249
1250     def importNewBranch(self, branch, maxChange):
1251         # make fast-import flush all changes to disk and update the refs using the checkpoint
1252         # command so that we can try to find the branch parent in the git history
1253         self.gitStream.write("checkpoint\n\n");
1254         self.gitStream.flush();
1255         branchPrefix = self.depotPaths[0] + branch + "/"
1256         range = "@1,%s" % maxChange
1257         #print "prefix" + branchPrefix
1258         changes = p4ChangesForPaths([branchPrefix], range)
1259         if len(changes) <= 0:
1260             return False
1261         firstChange = changes[0]
1262         #print "first change in branch: %s" % firstChange
1263         sourceBranch = self.knownBranches[branch]
1264         sourceDepotPath = self.depotPaths[0] + sourceBranch
1265         sourceRef = self.gitRefForBranch(sourceBranch)
1266         #print "source " + sourceBranch
1267
1268         branchParentChange = int(p4Cmd("changes -m 1 %s...@1,%s" % (sourceDepotPath, firstChange))["change"])
1269         #print "branch parent: %s" % branchParentChange
1270         gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)
1271         if len(gitParent) > 0:
1272             self.initialParents[self.gitRefForBranch(branch)] = gitParent
1273             #print "parent git commit: %s" % gitParent
1274
1275         self.importChanges(changes)
1276         return True
1277
1278     def importChanges(self, changes):
1279         cnt = 1
1280         for change in changes:
1281             description = p4Cmd("describe %s" % change)
1282             self.updateOptionDict(description)
1283
1284             if not self.silent:
1285                 sys.stdout.write("\rImporting revision %s (%s%%)" % (change, cnt * 100 / len(changes)))
1286                 sys.stdout.flush()
1287             cnt = cnt + 1
1288
1289             try:
1290                 if self.detectBranches:
1291                     branches = self.splitFilesIntoBranches(description)
1292                     for branch in branches.keys():
1293                         ## HACK  --hwn
1294                         branchPrefix = self.depotPaths[0] + branch + "/"
1295
1296                         parent = ""
1297
1298                         filesForCommit = branches[branch]
1299
1300                         if self.verbose:
1301                             print "branch is %s" % branch
1302
1303                         self.updatedBranches.add(branch)
1304
1305                         if branch not in self.createdBranches:
1306                             self.createdBranches.add(branch)
1307                             parent = self.knownBranches[branch]
1308                             if parent == branch:
1309                                 parent = ""
1310                             else:
1311                                 fullBranch = self.projectName + branch
1312                                 if fullBranch not in self.p4BranchesInGit:
1313                                     if not self.silent:
1314                                         print("\n    Importing new branch %s" % fullBranch);
1315                                     if self.importNewBranch(branch, change - 1):
1316                                         parent = ""
1317                                         self.p4BranchesInGit.append(fullBranch)
1318                                     if not self.silent:
1319                                         print("\n    Resuming with change %s" % change);
1320
1321                                 if self.verbose:
1322                                     print "parent determined through known branches: %s" % parent
1323
1324                         branch = self.gitRefForBranch(branch)
1325                         parent = self.gitRefForBranch(parent)
1326
1327                         if self.verbose:
1328                             print "looking for initial parent for %s; current parent is %s" % (branch, parent)
1329
1330                         if len(parent) == 0 and branch in self.initialParents:
1331                             parent = self.initialParents[branch]
1332                             del self.initialParents[branch]
1333
1334                         self.commit(description, filesForCommit, branch, [branchPrefix], parent)
1335                 else:
1336                     files = self.extractFilesFromCommit(description)
1337                     self.commit(description, files, self.branch, self.depotPaths,
1338                                 self.initialParent)
1339                     self.initialParent = ""
1340             except IOError:
1341                 print self.gitError.read()
1342                 sys.exit(1)
1343
1344     def importHeadRevision(self, revision):
1345         print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), revision, self.branch)
1346
1347         details = { "user" : "git perforce import user", "time" : int(time.time()) }
1348         details["desc"] = ("Initial import of %s from the state at revision %s"
1349                            % (' '.join(self.depotPaths), revision))
1350         details["change"] = revision
1351         newestRevision = 0
1352
1353         fileCnt = 0
1354         for info in p4CmdList("files "
1355                               +  ' '.join(["%s...%s"
1356                                            % (p, revision)
1357                                            for p in self.depotPaths])):
1358
1359             if info['code'] == 'error':
1360                 sys.stderr.write("p4 returned an error: %s\n"
1361                                  % info['data'])
1362                 sys.exit(1)
1363
1364
1365             change = int(info["change"])
1366             if change > newestRevision:
1367                 newestRevision = change
1368
1369             if info["action"] == "delete":
1370                 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
1371                 #fileCnt = fileCnt + 1
1372                 continue
1373
1374             for prop in ["depotFile", "rev", "action", "type" ]:
1375                 details["%s%s" % (prop, fileCnt)] = info[prop]
1376
1377             fileCnt = fileCnt + 1
1378
1379         details["change"] = newestRevision
1380         self.updateOptionDict(details)
1381         try:
1382             self.commit(details, self.extractFilesFromCommit(details), self.branch, self.depotPaths)
1383         except IOError:
1384             print "IO error with git fast-import. Is your git version recent enough?"
1385             print self.gitError.read()
1386
1387
1388     def run(self, args):
1389         self.depotPaths = []
1390         self.changeRange = ""
1391         self.initialParent = ""
1392         self.previousDepotPaths = []
1393
1394         # map from branch depot path to parent branch
1395         self.knownBranches = {}
1396         self.initialParents = {}
1397         self.hasOrigin = originP4BranchesExist()
1398         if not self.syncWithOrigin:
1399             self.hasOrigin = False
1400
1401         if self.importIntoRemotes:
1402             self.refPrefix = "refs/remotes/p4/"
1403         else:
1404             self.refPrefix = "refs/heads/p4/"
1405
1406         if self.syncWithOrigin and self.hasOrigin:
1407             if not self.silent:
1408                 print "Syncing with origin first by calling git fetch origin"
1409             system("git fetch origin")
1410
1411         if len(self.branch) == 0:
1412             self.branch = self.refPrefix + "master"
1413             if gitBranchExists("refs/heads/p4") and self.importIntoRemotes:
1414                 system("git update-ref %s refs/heads/p4" % self.branch)
1415                 system("git branch -D p4");
1416             # create it /after/ importing, when master exists
1417             if not gitBranchExists(self.refPrefix + "HEAD") and self.importIntoRemotes and gitBranchExists(self.branch):
1418                 system("git symbolic-ref %sHEAD %s" % (self.refPrefix, self.branch))
1419
1420         # TODO: should always look at previous commits,
1421         # merge with previous imports, if possible.
1422         if args == []:
1423             if self.hasOrigin:
1424                 createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)
1425             self.listExistingP4GitBranches()
1426
1427             if len(self.p4BranchesInGit) > 1:
1428                 if not self.silent:
1429                     print "Importing from/into multiple branches"
1430                 self.detectBranches = True
1431
1432             if self.verbose:
1433                 print "branches: %s" % self.p4BranchesInGit
1434
1435             p4Change = 0
1436             for branch in self.p4BranchesInGit:
1437                 logMsg =  extractLogMessageFromGitCommit(self.refPrefix + branch)
1438
1439                 settings = extractSettingsGitLog(logMsg)
1440
1441                 self.readOptions(settings)
1442                 if (settings.has_key('depot-paths')
1443                     and settings.has_key ('change')):
1444                     change = int(settings['change']) + 1
1445                     p4Change = max(p4Change, change)
1446
1447                     depotPaths = sorted(settings['depot-paths'])
1448                     if self.previousDepotPaths == []:
1449                         self.previousDepotPaths = depotPaths
1450                     else:
1451                         paths = []
1452                         for (prev, cur) in zip(self.previousDepotPaths, depotPaths):
1453                             for i in range(0, min(len(cur), len(prev))):
1454                                 if cur[i] <> prev[i]:
1455                                     i = i - 1
1456                                     break
1457
1458                             paths.append (cur[:i + 1])
1459
1460                         self.previousDepotPaths = paths
1461
1462             if p4Change > 0:
1463                 self.depotPaths = sorted(self.previousDepotPaths)
1464                 self.changeRange = "@%s,#head" % p4Change
1465                 if not self.detectBranches:
1466                     self.initialParent = parseRevision(self.branch)
1467                 if not self.silent and not self.detectBranches:
1468                     print "Performing incremental import into %s git branch" % self.branch
1469
1470         if not self.branch.startswith("refs/"):
1471             self.branch = "refs/heads/" + self.branch
1472
1473         if len(args) == 0 and self.depotPaths:
1474             if not self.silent:
1475                 print "Depot paths: %s" % ' '.join(self.depotPaths)
1476         else:
1477             if self.depotPaths and self.depotPaths != args:
1478                 print ("previous import used depot path %s and now %s was specified. "
1479                        "This doesn't work!" % (' '.join (self.depotPaths),
1480                                                ' '.join (args)))
1481                 sys.exit(1)
1482
1483             self.depotPaths = sorted(args)
1484
1485         revision = ""
1486         self.users = {}
1487
1488         newPaths = []
1489         for p in self.depotPaths:
1490             if p.find("@") != -1:
1491                 atIdx = p.index("@")
1492                 self.changeRange = p[atIdx:]
1493                 if self.changeRange == "@all":
1494                     self.changeRange = ""
1495                 elif ',' not in self.changeRange:
1496                     revision = self.changeRange
1497                     self.changeRange = ""
1498                 p = p[:atIdx]
1499             elif p.find("#") != -1:
1500                 hashIdx = p.index("#")
1501                 revision = p[hashIdx:]
1502                 p = p[:hashIdx]
1503             elif self.previousDepotPaths == []:
1504                 revision = "#head"
1505
1506             p = re.sub ("\.\.\.$", "", p)
1507             if not p.endswith("/"):
1508                 p += "/"
1509
1510             newPaths.append(p)
1511
1512         self.depotPaths = newPaths
1513
1514
1515         self.loadUserMapFromCache()
1516         self.labels = {}
1517         if self.detectLabels:
1518             self.getLabels();
1519
1520         if self.detectBranches:
1521             ## FIXME - what's a P4 projectName ?
1522             self.projectName = self.guessProjectName()
1523
1524             if self.hasOrigin:
1525                 self.getBranchMappingFromGitBranches()
1526             else:
1527                 self.getBranchMapping()
1528             if self.verbose:
1529                 print "p4-git branches: %s" % self.p4BranchesInGit
1530                 print "initial parents: %s" % self.initialParents
1531             for b in self.p4BranchesInGit:
1532                 if b != "master":
1533
1534                     ## FIXME
1535                     b = b[len(self.projectName):]
1536                 self.createdBranches.add(b)
1537
1538         self.tz = "%+03d%02d" % (- time.timezone / 3600, ((- time.timezone % 3600) / 60))
1539
1540         importProcess = subprocess.Popen(["git", "fast-import"],
1541                                          stdin=subprocess.PIPE, stdout=subprocess.PIPE,
1542                                          stderr=subprocess.PIPE);
1543         self.gitOutput = importProcess.stdout
1544         self.gitStream = importProcess.stdin
1545         self.gitError = importProcess.stderr
1546
1547         if revision:
1548             self.importHeadRevision(revision)
1549         else:
1550             changes = []
1551
1552             if len(self.changesFile) > 0:
1553                 output = open(self.changesFile).readlines()
1554                 changeSet = Set()
1555                 for line in output:
1556                     changeSet.add(int(line))
1557
1558                 for change in changeSet:
1559                     changes.append(change)
1560
1561                 changes.sort()
1562             else:
1563                 if self.verbose:
1564                     print "Getting p4 changes for %s...%s" % (', '.join(self.depotPaths),
1565                                                               self.changeRange)
1566                 changes = p4ChangesForPaths(self.depotPaths, self.changeRange)
1567
1568                 if len(self.maxChanges) > 0:
1569                     changes = changes[:min(int(self.maxChanges), len(changes))]
1570
1571             if len(changes) == 0:
1572                 if not self.silent:
1573                     print "No changes to import!"
1574                 return True
1575
1576             if not self.silent and not self.detectBranches:
1577                 print "Import destination: %s" % self.branch
1578
1579             self.updatedBranches = set()
1580
1581             self.importChanges(changes)
1582
1583             if not self.silent:
1584                 print ""
1585                 if len(self.updatedBranches) > 0:
1586                     sys.stdout.write("Updated branches: ")
1587                     for b in self.updatedBranches:
1588                         sys.stdout.write("%s " % b)
1589                     sys.stdout.write("\n")
1590
1591         self.gitStream.close()
1592         if importProcess.wait() != 0:
1593             die("fast-import failed: %s" % self.gitError.read())
1594         self.gitOutput.close()
1595         self.gitError.close()
1596
1597         return True
1598
1599 class P4Rebase(Command):
1600     def __init__(self):
1601         Command.__init__(self)
1602         self.options = [ ]
1603         self.description = ("Fetches the latest revision from perforce and "
1604                             + "rebases the current work (branch) against it")
1605         self.verbose = False
1606
1607     def run(self, args):
1608         sync = P4Sync()
1609         sync.run([])
1610
1611         return self.rebase()
1612
1613     def rebase(self):
1614         if os.system("git update-index --refresh") != 0:
1615             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.");
1616         if len(read_pipe("git diff-index HEAD --")) > 0:
1617             die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
1618
1619         [upstream, settings] = findUpstreamBranchPoint()
1620         if len(upstream) == 0:
1621             die("Cannot find upstream branchpoint for rebase")
1622
1623         # the branchpoint may be p4/foo~3, so strip off the parent
1624         upstream = re.sub("~[0-9]+$", "", upstream)
1625
1626         print "Rebasing the current branch onto %s" % upstream
1627         oldHead = read_pipe("git rev-parse HEAD").strip()
1628         system("git rebase %s" % upstream)
1629         system("git diff-tree --stat --summary -M %s HEAD" % oldHead)
1630         return True
1631
1632 class P4Clone(P4Sync):
1633     def __init__(self):
1634         P4Sync.__init__(self)
1635         self.description = "Creates a new git repository and imports from Perforce into it"
1636         self.usage = "usage: %prog [options] //depot/path[@revRange]"
1637         self.options.append(
1638             optparse.make_option("--destination", dest="cloneDestination",
1639                                  action='store', default=None,
1640                                  help="where to leave result of the clone"))
1641         self.cloneDestination = None
1642         self.needsGit = False
1643
1644     def defaultDestination(self, args):
1645         ## TODO: use common prefix of args?
1646         depotPath = args[0]
1647         depotDir = re.sub("(@[^@]*)$", "", depotPath)
1648         depotDir = re.sub("(#[^#]*)$", "", depotDir)
1649         depotDir = re.sub(r"\.\.\.$", "", depotDir)
1650         depotDir = re.sub(r"/$", "", depotDir)
1651         return os.path.split(depotDir)[1]
1652
1653     def run(self, args):
1654         if len(args) < 1:
1655             return False
1656
1657         if self.keepRepoPath and not self.cloneDestination:
1658             sys.stderr.write("Must specify destination for --keep-path\n")
1659             sys.exit(1)
1660
1661         depotPaths = args
1662
1663         if not self.cloneDestination and len(depotPaths) > 1:
1664             self.cloneDestination = depotPaths[-1]
1665             depotPaths = depotPaths[:-1]
1666
1667         for p in depotPaths:
1668             if not p.startswith("//"):
1669                 return False
1670
1671         if not self.cloneDestination:
1672             self.cloneDestination = self.defaultDestination(args)
1673
1674         print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
1675         if not os.path.exists(self.cloneDestination):
1676             os.makedirs(self.cloneDestination)
1677         os.chdir(self.cloneDestination)
1678         system("git init")
1679         self.gitdir = os.getcwd() + "/.git"
1680         if not P4Sync.run(self, depotPaths):
1681             return False
1682         if self.branch != "master":
1683             if gitBranchExists("refs/remotes/p4/master"):
1684                 system("git branch master refs/remotes/p4/master")
1685                 system("git checkout -f")
1686             else:
1687                 print "Could not detect main branch. No checkout/master branch created."
1688
1689         return True
1690
1691 class P4Branches(Command):
1692     def __init__(self):
1693         Command.__init__(self)
1694         self.options = [ ]
1695         self.description = ("Shows the git branches that hold imports and their "
1696                             + "corresponding perforce depot paths")
1697         self.verbose = False
1698
1699     def run(self, args):
1700         if originP4BranchesExist():
1701             createOrUpdateBranchesFromOrigin()
1702
1703         cmdline = "git rev-parse --symbolic "
1704         cmdline += " --remotes"
1705
1706         for line in read_pipe_lines(cmdline):
1707             line = line.strip()
1708
1709             if not line.startswith('p4/') or line == "p4/HEAD":
1710                 continue
1711             branch = line
1712
1713             log = extractLogMessageFromGitCommit("refs/remotes/%s" % branch)
1714             settings = extractSettingsGitLog(log)
1715
1716             print "%s <= %s (%s)" % (branch, ",".join(settings["depot-paths"]), settings["change"])
1717         return True
1718
1719 class HelpFormatter(optparse.IndentedHelpFormatter):
1720     def __init__(self):
1721         optparse.IndentedHelpFormatter.__init__(self)
1722
1723     def format_description(self, description):
1724         if description:
1725             return description + "\n"
1726         else:
1727             return ""
1728
1729 def printUsage(commands):
1730     print "usage: %s <command> [options]" % sys.argv[0]
1731     print ""
1732     print "valid commands: %s" % ", ".join(commands)
1733     print ""
1734     print "Try %s <command> --help for command specific help." % sys.argv[0]
1735     print ""
1736
1737 commands = {
1738     "debug" : P4Debug,
1739     "submit" : P4Submit,
1740     "commit" : P4Submit,
1741     "sync" : P4Sync,
1742     "rebase" : P4Rebase,
1743     "clone" : P4Clone,
1744     "rollback" : P4RollBack,
1745     "branches" : P4Branches
1746 }
1747
1748
1749 def main():
1750     if len(sys.argv[1:]) == 0:
1751         printUsage(commands.keys())
1752         sys.exit(2)
1753
1754     cmd = ""
1755     cmdName = sys.argv[1]
1756     try:
1757         klass = commands[cmdName]
1758         cmd = klass()
1759     except KeyError:
1760         print "unknown command %s" % cmdName
1761         print ""
1762         printUsage(commands.keys())
1763         sys.exit(2)
1764
1765     options = cmd.options
1766     cmd.gitdir = os.environ.get("GIT_DIR", None)
1767
1768     args = sys.argv[2:]
1769
1770     if len(options) > 0:
1771         options.append(optparse.make_option("--git-dir", dest="gitdir"))
1772
1773         parser = optparse.OptionParser(cmd.usage.replace("%prog", "%prog " + cmdName),
1774                                        options,
1775                                        description = cmd.description,
1776                                        formatter = HelpFormatter())
1777
1778         (cmd, args) = parser.parse_args(sys.argv[2:], cmd);
1779     global verbose
1780     verbose = cmd.verbose
1781     if cmd.needsGit:
1782         if cmd.gitdir == None:
1783             cmd.gitdir = os.path.abspath(".git")
1784             if not isValidGitDir(cmd.gitdir):
1785                 cmd.gitdir = read_pipe("git rev-parse --git-dir").strip()
1786                 if os.path.exists(cmd.gitdir):
1787                     cdup = read_pipe("git rev-parse --show-cdup").strip()
1788                     if len(cdup) > 0:
1789                         os.chdir(cdup);
1790
1791         if not isValidGitDir(cmd.gitdir):
1792             if isValidGitDir(cmd.gitdir + "/.git"):
1793                 cmd.gitdir += "/.git"
1794             else:
1795                 die("fatal: cannot locate git repository at %s" % cmd.gitdir)
1796
1797         os.environ["GIT_DIR"] = cmd.gitdir
1798
1799     if not cmd.run(args):
1800         parser.print_help()
1801
1802
1803 if __name__ == '__main__':
1804     main()