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