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