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# 10import sys 11if sys.hexversion <0x02040000: 12# The limiter is the subprocess module 13 sys.stderr.write("git-p4: requires Python 2.4 or later.\n") 14 sys.exit(1) 15import os 16import optparse 17import marshal 18import subprocess 19import tempfile 20import time 21import platform 22import re 23import shutil 24import stat 25 26try: 27from subprocess import CalledProcessError 28exceptImportError: 29# from python2.7:subprocess.py 30# Exception classes used by this module. 31classCalledProcessError(Exception): 32"""This exception is raised when a process run by check_call() returns 33 a non-zero exit status. The exit status will be stored in the 34 returncode attribute.""" 35def__init__(self, returncode, cmd): 36 self.returncode = returncode 37 self.cmd = cmd 38def__str__(self): 39return"Command '%s' returned non-zero exit status%d"% (self.cmd, self.returncode) 40 41verbose =False 42 43# Only labels/tags matching this will be imported/exported 44defaultLabelRegexp = r'[a-zA-Z0-9_\-.]+$' 45 46# Grab changes in blocks of this many revisions, unless otherwise requested 47defaultBlockSize =512 48 49defp4_build_cmd(cmd): 50"""Build a suitable p4 command line. 51 52 This consolidates building and returning a p4 command line into one 53 location. It means that hooking into the environment, or other configuration 54 can be done more easily. 55 """ 56 real_cmd = ["p4"] 57 58 user =gitConfig("git-p4.user") 59iflen(user) >0: 60 real_cmd += ["-u",user] 61 62 password =gitConfig("git-p4.password") 63iflen(password) >0: 64 real_cmd += ["-P", password] 65 66 port =gitConfig("git-p4.port") 67iflen(port) >0: 68 real_cmd += ["-p", port] 69 70 host =gitConfig("git-p4.host") 71iflen(host) >0: 72 real_cmd += ["-H", host] 73 74 client =gitConfig("git-p4.client") 75iflen(client) >0: 76 real_cmd += ["-c", client] 77 78 79ifisinstance(cmd,basestring): 80 real_cmd =' '.join(real_cmd) +' '+ cmd 81else: 82 real_cmd += cmd 83return real_cmd 84 85defchdir(path, is_client_path=False): 86"""Do chdir to the given path, and set the PWD environment 87 variable for use by P4. It does not look at getcwd() output. 88 Since we're not using the shell, it is necessary to set the 89 PWD environment variable explicitly. 90 91 Normally, expand the path to force it to be absolute. This 92 addresses the use of relative path names inside P4 settings, 93 e.g. P4CONFIG=.p4config. P4 does not simply open the filename 94 as given; it looks for .p4config using PWD. 95 96 If is_client_path, the path was handed to us directly by p4, 97 and may be a symbolic link. Do not call os.getcwd() in this 98 case, because it will cause p4 to think that PWD is not inside 99 the client path. 100 """ 101 102 os.chdir(path) 103if not is_client_path: 104 path = os.getcwd() 105 os.environ['PWD'] = path 106 107defdie(msg): 108if verbose: 109raiseException(msg) 110else: 111 sys.stderr.write(msg +"\n") 112 sys.exit(1) 113 114defwrite_pipe(c, stdin): 115if verbose: 116 sys.stderr.write('Writing pipe:%s\n'%str(c)) 117 118 expand =isinstance(c,basestring) 119 p = subprocess.Popen(c, stdin=subprocess.PIPE, shell=expand) 120 pipe = p.stdin 121 val = pipe.write(stdin) 122 pipe.close() 123if p.wait(): 124die('Command failed:%s'%str(c)) 125 126return val 127 128defp4_write_pipe(c, stdin): 129 real_cmd =p4_build_cmd(c) 130returnwrite_pipe(real_cmd, stdin) 131 132defread_pipe(c, ignore_error=False): 133if verbose: 134 sys.stderr.write('Reading pipe:%s\n'%str(c)) 135 136 expand =isinstance(c,basestring) 137 p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand) 138 pipe = p.stdout 139 val = pipe.read() 140if p.wait()and not ignore_error: 141die('Command failed:%s'%str(c)) 142 143return val 144 145defp4_read_pipe(c, ignore_error=False): 146 real_cmd =p4_build_cmd(c) 147returnread_pipe(real_cmd, ignore_error) 148 149defread_pipe_lines(c): 150if verbose: 151 sys.stderr.write('Reading pipe:%s\n'%str(c)) 152 153 expand =isinstance(c, basestring) 154 p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand) 155 pipe = p.stdout 156 val = pipe.readlines() 157if pipe.close()or p.wait(): 158die('Command failed:%s'%str(c)) 159 160return val 161 162defp4_read_pipe_lines(c): 163"""Specifically invoke p4 on the command supplied. """ 164 real_cmd =p4_build_cmd(c) 165returnread_pipe_lines(real_cmd) 166 167defp4_has_command(cmd): 168"""Ask p4 for help on this command. If it returns an error, the 169 command does not exist in this version of p4.""" 170 real_cmd =p4_build_cmd(["help", cmd]) 171 p = subprocess.Popen(real_cmd, stdout=subprocess.PIPE, 172 stderr=subprocess.PIPE) 173 p.communicate() 174return p.returncode ==0 175 176defp4_has_move_command(): 177"""See if the move command exists, that it supports -k, and that 178 it has not been administratively disabled. The arguments 179 must be correct, but the filenames do not have to exist. Use 180 ones with wildcards so even if they exist, it will fail.""" 181 182if notp4_has_command("move"): 183return False 184 cmd =p4_build_cmd(["move","-k","@from","@to"]) 185 p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) 186(out, err) = p.communicate() 187# return code will be 1 in either case 188if err.find("Invalid option") >=0: 189return False 190if err.find("disabled") >=0: 191return False 192# assume it failed because @... was invalid changelist 193return True 194 195defsystem(cmd): 196 expand =isinstance(cmd,basestring) 197if verbose: 198 sys.stderr.write("executing%s\n"%str(cmd)) 199 retcode = subprocess.call(cmd, shell=expand) 200if retcode: 201raiseCalledProcessError(retcode, cmd) 202 203defp4_system(cmd): 204"""Specifically invoke p4 as the system command. """ 205 real_cmd =p4_build_cmd(cmd) 206 expand =isinstance(real_cmd, basestring) 207 retcode = subprocess.call(real_cmd, shell=expand) 208if retcode: 209raiseCalledProcessError(retcode, real_cmd) 210 211_p4_version_string =None 212defp4_version_string(): 213"""Read the version string, showing just the last line, which 214 hopefully is the interesting version bit. 215 216 $ p4 -V 217 Perforce - The Fast Software Configuration Management System. 218 Copyright 1995-2011 Perforce Software. All rights reserved. 219 Rev. P4/NTX86/2011.1/393975 (2011/12/16). 220 """ 221global _p4_version_string 222if not _p4_version_string: 223 a =p4_read_pipe_lines(["-V"]) 224 _p4_version_string = a[-1].rstrip() 225return _p4_version_string 226 227defp4_integrate(src, dest): 228p4_system(["integrate","-Dt",wildcard_encode(src),wildcard_encode(dest)]) 229 230defp4_sync(f, *options): 231p4_system(["sync"] +list(options) + [wildcard_encode(f)]) 232 233defp4_add(f): 234# forcibly add file names with wildcards 235ifwildcard_present(f): 236p4_system(["add","-f", f]) 237else: 238p4_system(["add", f]) 239 240defp4_delete(f): 241p4_system(["delete",wildcard_encode(f)]) 242 243defp4_edit(f): 244p4_system(["edit",wildcard_encode(f)]) 245 246defp4_revert(f): 247p4_system(["revert",wildcard_encode(f)]) 248 249defp4_reopen(type, f): 250p4_system(["reopen","-t",type,wildcard_encode(f)]) 251 252defp4_move(src, dest): 253p4_system(["move","-k",wildcard_encode(src),wildcard_encode(dest)]) 254 255defp4_last_change(): 256 results =p4CmdList(["changes","-m","1"]) 257returnint(results[0]['change']) 258 259defp4_describe(change): 260"""Make sure it returns a valid result by checking for 261 the presence of field "time". Return a dict of the 262 results.""" 263 264 ds =p4CmdList(["describe","-s",str(change)]) 265iflen(ds) !=1: 266die("p4 describe -s%ddid not return 1 result:%s"% (change,str(ds))) 267 268 d = ds[0] 269 270if"p4ExitCode"in d: 271die("p4 describe -s%dexited with%d:%s"% (change, d["p4ExitCode"], 272str(d))) 273if"code"in d: 274if d["code"] =="error": 275die("p4 describe -s%dreturned error code:%s"% (change,str(d))) 276 277if"time"not in d: 278die("p4 describe -s%dreturned no\"time\":%s"% (change,str(d))) 279 280return d 281 282# 283# Canonicalize the p4 type and return a tuple of the 284# base type, plus any modifiers. See "p4 help filetypes" 285# for a list and explanation. 286# 287defsplit_p4_type(p4type): 288 289 p4_filetypes_historical = { 290"ctempobj":"binary+Sw", 291"ctext":"text+C", 292"cxtext":"text+Cx", 293"ktext":"text+k", 294"kxtext":"text+kx", 295"ltext":"text+F", 296"tempobj":"binary+FSw", 297"ubinary":"binary+F", 298"uresource":"resource+F", 299"uxbinary":"binary+Fx", 300"xbinary":"binary+x", 301"xltext":"text+Fx", 302"xtempobj":"binary+Swx", 303"xtext":"text+x", 304"xunicode":"unicode+x", 305"xutf16":"utf16+x", 306} 307if p4type in p4_filetypes_historical: 308 p4type = p4_filetypes_historical[p4type] 309 mods ="" 310 s = p4type.split("+") 311 base = s[0] 312 mods ="" 313iflen(s) >1: 314 mods = s[1] 315return(base, mods) 316 317# 318# return the raw p4 type of a file (text, text+ko, etc) 319# 320defp4_type(f): 321 results =p4CmdList(["fstat","-T","headType",wildcard_encode(f)]) 322return results[0]['headType'] 323 324# 325# Given a type base and modifier, return a regexp matching 326# the keywords that can be expanded in the file 327# 328defp4_keywords_regexp_for_type(base, type_mods): 329if base in("text","unicode","binary"): 330 kwords =None 331if"ko"in type_mods: 332 kwords ='Id|Header' 333elif"k"in type_mods: 334 kwords ='Id|Header|Author|Date|DateTime|Change|File|Revision' 335else: 336return None 337 pattern = r""" 338 \$ # Starts with a dollar, followed by... 339 (%s) # one of the keywords, followed by... 340 (:[^$\n]+)? # possibly an old expansion, followed by... 341 \$ # another dollar 342 """% kwords 343return pattern 344else: 345return None 346 347# 348# Given a file, return a regexp matching the possible 349# RCS keywords that will be expanded, or None for files 350# with kw expansion turned off. 351# 352defp4_keywords_regexp_for_file(file): 353if not os.path.exists(file): 354return None 355else: 356(type_base, type_mods) =split_p4_type(p4_type(file)) 357returnp4_keywords_regexp_for_type(type_base, type_mods) 358 359defsetP4ExecBit(file, mode): 360# Reopens an already open file and changes the execute bit to match 361# the execute bit setting in the passed in mode. 362 363 p4Type ="+x" 364 365if notisModeExec(mode): 366 p4Type =getP4OpenedType(file) 367 p4Type = re.sub('^([cku]?)x(.*)','\\1\\2', p4Type) 368 p4Type = re.sub('(.*?\+.*?)x(.*?)','\\1\\2', p4Type) 369if p4Type[-1] =="+": 370 p4Type = p4Type[0:-1] 371 372p4_reopen(p4Type,file) 373 374defgetP4OpenedType(file): 375# Returns the perforce file type for the given file. 376 377 result =p4_read_pipe(["opened",wildcard_encode(file)]) 378 match = re.match(".*\((.+)\)( \*exclusive\*)?\r?$", result) 379if match: 380return match.group(1) 381else: 382die("Could not determine file type for%s(result: '%s')"% (file, result)) 383 384# Return the set of all p4 labels 385defgetP4Labels(depotPaths): 386 labels =set() 387ifisinstance(depotPaths,basestring): 388 depotPaths = [depotPaths] 389 390for l inp4CmdList(["labels"] + ["%s..."% p for p in depotPaths]): 391 label = l['label'] 392 labels.add(label) 393 394return labels 395 396# Return the set of all git tags 397defgetGitTags(): 398 gitTags =set() 399for line inread_pipe_lines(["git","tag"]): 400 tag = line.strip() 401 gitTags.add(tag) 402return gitTags 403 404defdiffTreePattern(): 405# This is a simple generator for the diff tree regex pattern. This could be 406# a class variable if this and parseDiffTreeEntry were a part of a class. 407 pattern = re.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)') 408while True: 409yield pattern 410 411defparseDiffTreeEntry(entry): 412"""Parses a single diff tree entry into its component elements. 413 414 See git-diff-tree(1) manpage for details about the format of the diff 415 output. This method returns a dictionary with the following elements: 416 417 src_mode - The mode of the source file 418 dst_mode - The mode of the destination file 419 src_sha1 - The sha1 for the source file 420 dst_sha1 - The sha1 fr the destination file 421 status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc) 422 status_score - The score for the status (applicable for 'C' and 'R' 423 statuses). This is None if there is no score. 424 src - The path for the source file. 425 dst - The path for the destination file. This is only present for 426 copy or renames. If it is not present, this is None. 427 428 If the pattern is not matched, None is returned.""" 429 430 match =diffTreePattern().next().match(entry) 431if match: 432return{ 433'src_mode': match.group(1), 434'dst_mode': match.group(2), 435'src_sha1': match.group(3), 436'dst_sha1': match.group(4), 437'status': match.group(5), 438'status_score': match.group(6), 439'src': match.group(7), 440'dst': match.group(10) 441} 442return None 443 444defisModeExec(mode): 445# Returns True if the given git mode represents an executable file, 446# otherwise False. 447return mode[-3:] =="755" 448 449defisModeExecChanged(src_mode, dst_mode): 450returnisModeExec(src_mode) !=isModeExec(dst_mode) 451 452defp4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None): 453 454ifisinstance(cmd,basestring): 455 cmd ="-G "+ cmd 456 expand =True 457else: 458 cmd = ["-G"] + cmd 459 expand =False 460 461 cmd =p4_build_cmd(cmd) 462if verbose: 463 sys.stderr.write("Opening pipe:%s\n"%str(cmd)) 464 465# Use a temporary file to avoid deadlocks without 466# subprocess.communicate(), which would put another copy 467# of stdout into memory. 468 stdin_file =None 469if stdin is not None: 470 stdin_file = tempfile.TemporaryFile(prefix='p4-stdin', mode=stdin_mode) 471ifisinstance(stdin,basestring): 472 stdin_file.write(stdin) 473else: 474for i in stdin: 475 stdin_file.write(i +'\n') 476 stdin_file.flush() 477 stdin_file.seek(0) 478 479 p4 = subprocess.Popen(cmd, 480 shell=expand, 481 stdin=stdin_file, 482 stdout=subprocess.PIPE) 483 484 result = [] 485try: 486while True: 487 entry = marshal.load(p4.stdout) 488if cb is not None: 489cb(entry) 490else: 491 result.append(entry) 492exceptEOFError: 493pass 494 exitCode = p4.wait() 495if exitCode !=0: 496 entry = {} 497 entry["p4ExitCode"] = exitCode 498 result.append(entry) 499 500return result 501 502defp4Cmd(cmd): 503list=p4CmdList(cmd) 504 result = {} 505for entry inlist: 506 result.update(entry) 507return result; 508 509defp4Where(depotPath): 510if not depotPath.endswith("/"): 511 depotPath +="/" 512 depotPathLong = depotPath +"..." 513 outputList =p4CmdList(["where", depotPathLong]) 514 output =None 515for entry in outputList: 516if"depotFile"in entry: 517# Search for the base client side depot path, as long as it starts with the branch's P4 path. 518# The base path always ends with "/...". 519if entry["depotFile"].find(depotPath) ==0and entry["depotFile"][-4:] =="/...": 520 output = entry 521break 522elif"data"in entry: 523 data = entry.get("data") 524 space = data.find(" ") 525if data[:space] == depotPath: 526 output = entry 527break 528if output ==None: 529return"" 530if output["code"] =="error": 531return"" 532 clientPath ="" 533if"path"in output: 534 clientPath = output.get("path") 535elif"data"in output: 536 data = output.get("data") 537 lastSpace = data.rfind(" ") 538 clientPath = data[lastSpace +1:] 539 540if clientPath.endswith("..."): 541 clientPath = clientPath[:-3] 542return clientPath 543 544defcurrentGitBranch(): 545returnread_pipe("git name-rev HEAD").split(" ")[1].strip() 546 547defisValidGitDir(path): 548if(os.path.exists(path +"/HEAD") 549and os.path.exists(path +"/refs")and os.path.exists(path +"/objects")): 550return True; 551return False 552 553defparseRevision(ref): 554returnread_pipe("git rev-parse%s"% ref).strip() 555 556defbranchExists(ref): 557 rev =read_pipe(["git","rev-parse","-q","--verify", ref], 558 ignore_error=True) 559returnlen(rev) >0 560 561defextractLogMessageFromGitCommit(commit): 562 logMessage ="" 563 564## fixme: title is first line of commit, not 1st paragraph. 565 foundTitle =False 566for log inread_pipe_lines("git cat-file commit%s"% commit): 567if not foundTitle: 568iflen(log) ==1: 569 foundTitle =True 570continue 571 572 logMessage += log 573return logMessage 574 575defextractSettingsGitLog(log): 576 values = {} 577for line in log.split("\n"): 578 line = line.strip() 579 m = re.search(r"^ *\[git-p4: (.*)\]$", line) 580if not m: 581continue 582 583 assignments = m.group(1).split(':') 584for a in assignments: 585 vals = a.split('=') 586 key = vals[0].strip() 587 val = ('='.join(vals[1:])).strip() 588if val.endswith('\"')and val.startswith('"'): 589 val = val[1:-1] 590 591 values[key] = val 592 593 paths = values.get("depot-paths") 594if not paths: 595 paths = values.get("depot-path") 596if paths: 597 values['depot-paths'] = paths.split(',') 598return values 599 600defgitBranchExists(branch): 601 proc = subprocess.Popen(["git","rev-parse", branch], 602 stderr=subprocess.PIPE, stdout=subprocess.PIPE); 603return proc.wait() ==0; 604 605_gitConfig = {} 606 607defgitConfig(key): 608if not _gitConfig.has_key(key): 609 cmd = ["git","config", key ] 610 s =read_pipe(cmd, ignore_error=True) 611 _gitConfig[key] = s.strip() 612return _gitConfig[key] 613 614defgitConfigBool(key): 615"""Return a bool, using git config --bool. It is True only if the 616 variable is set to true, and False if set to false or not present 617 in the config.""" 618 619if not _gitConfig.has_key(key): 620 cmd = ["git","config","--bool", key ] 621 s =read_pipe(cmd, ignore_error=True) 622 v = s.strip() 623 _gitConfig[key] = v =="true" 624return _gitConfig[key] 625 626defgitConfigList(key): 627if not _gitConfig.has_key(key): 628 s =read_pipe(["git","config","--get-all", key], ignore_error=True) 629 _gitConfig[key] = s.strip().split(os.linesep) 630return _gitConfig[key] 631 632defp4BranchesInGit(branchesAreInRemotes=True): 633"""Find all the branches whose names start with "p4/", looking 634 in remotes or heads as specified by the argument. Return 635 a dictionary of{ branch: revision }for each one found. 636 The branch names are the short names, without any 637 "p4/" prefix.""" 638 639 branches = {} 640 641 cmdline ="git rev-parse --symbolic " 642if branchesAreInRemotes: 643 cmdline +="--remotes" 644else: 645 cmdline +="--branches" 646 647for line inread_pipe_lines(cmdline): 648 line = line.strip() 649 650# only import to p4/ 651if not line.startswith('p4/'): 652continue 653# special symbolic ref to p4/master 654if line =="p4/HEAD": 655continue 656 657# strip off p4/ prefix 658 branch = line[len("p4/"):] 659 660 branches[branch] =parseRevision(line) 661 662return branches 663 664defbranch_exists(branch): 665"""Make sure that the given ref name really exists.""" 666 667 cmd = ["git","rev-parse","--symbolic","--verify", branch ] 668 p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) 669 out, _ = p.communicate() 670if p.returncode: 671return False 672# expect exactly one line of output: the branch name 673return out.rstrip() == branch 674 675deffindUpstreamBranchPoint(head ="HEAD"): 676 branches =p4BranchesInGit() 677# map from depot-path to branch name 678 branchByDepotPath = {} 679for branch in branches.keys(): 680 tip = branches[branch] 681 log =extractLogMessageFromGitCommit(tip) 682 settings =extractSettingsGitLog(log) 683if settings.has_key("depot-paths"): 684 paths =",".join(settings["depot-paths"]) 685 branchByDepotPath[paths] ="remotes/p4/"+ branch 686 687 settings =None 688 parent =0 689while parent <65535: 690 commit = head +"~%s"% parent 691 log =extractLogMessageFromGitCommit(commit) 692 settings =extractSettingsGitLog(log) 693if settings.has_key("depot-paths"): 694 paths =",".join(settings["depot-paths"]) 695if branchByDepotPath.has_key(paths): 696return[branchByDepotPath[paths], settings] 697 698 parent = parent +1 699 700return["", settings] 701 702defcreateOrUpdateBranchesFromOrigin(localRefPrefix ="refs/remotes/p4/", silent=True): 703if not silent: 704print("Creating/updating branch(es) in%sbased on origin branch(es)" 705% localRefPrefix) 706 707 originPrefix ="origin/p4/" 708 709for line inread_pipe_lines("git rev-parse --symbolic --remotes"): 710 line = line.strip() 711if(not line.startswith(originPrefix))or line.endswith("HEAD"): 712continue 713 714 headName = line[len(originPrefix):] 715 remoteHead = localRefPrefix + headName 716 originHead = line 717 718 original =extractSettingsGitLog(extractLogMessageFromGitCommit(originHead)) 719if(not original.has_key('depot-paths') 720or not original.has_key('change')): 721continue 722 723 update =False 724if notgitBranchExists(remoteHead): 725if verbose: 726print"creating%s"% remoteHead 727 update =True 728else: 729 settings =extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead)) 730if settings.has_key('change') >0: 731if settings['depot-paths'] == original['depot-paths']: 732 originP4Change =int(original['change']) 733 p4Change =int(settings['change']) 734if originP4Change > p4Change: 735print("%s(%s) is newer than%s(%s). " 736"Updating p4 branch from origin." 737% (originHead, originP4Change, 738 remoteHead, p4Change)) 739 update =True 740else: 741print("Ignoring:%swas imported from%swhile " 742"%swas imported from%s" 743% (originHead,','.join(original['depot-paths']), 744 remoteHead,','.join(settings['depot-paths']))) 745 746if update: 747system("git update-ref%s %s"% (remoteHead, originHead)) 748 749deforiginP4BranchesExist(): 750returngitBranchExists("origin")orgitBranchExists("origin/p4")orgitBranchExists("origin/p4/master") 751 752 753defp4ParseNumericChangeRange(parts): 754 changeStart =int(parts[0][1:]) 755if parts[1] =='#head': 756 changeEnd =p4_last_change() 757else: 758 changeEnd =int(parts[1]) 759 760return(changeStart, changeEnd) 761 762defchooseBlockSize(blockSize): 763if blockSize: 764return blockSize 765else: 766return defaultBlockSize 767 768defp4ChangesForPaths(depotPaths, changeRange, requestedBlockSize): 769assert depotPaths 770 771# Parse the change range into start and end. Try to find integer 772# revision ranges as these can be broken up into blocks to avoid 773# hitting server-side limits (maxrows, maxscanresults). But if 774# that doesn't work, fall back to using the raw revision specifier 775# strings, without using block mode. 776 777if changeRange is None or changeRange =='': 778 changeStart =1 779 changeEnd =p4_last_change() 780 block_size =chooseBlockSize(requestedBlockSize) 781else: 782 parts = changeRange.split(',') 783assertlen(parts) ==2 784try: 785(changeStart, changeEnd) =p4ParseNumericChangeRange(parts) 786 block_size =chooseBlockSize(requestedBlockSize) 787except: 788 changeStart = parts[0][1:] 789 changeEnd = parts[1] 790if requestedBlockSize: 791die("cannot use --changes-block-size with non-numeric revisions") 792 block_size =None 793 794# Accumulate change numbers in a dictionary to avoid duplicates 795 changes = {} 796 797for p in depotPaths: 798# Retrieve changes a block at a time, to prevent running 799# into a MaxResults/MaxScanRows error from the server. 800 801while True: 802 cmd = ['changes'] 803 804if block_size: 805 end =min(changeEnd, changeStart + block_size) 806 revisionRange ="%d,%d"% (changeStart, end) 807else: 808 revisionRange ="%s,%s"% (changeStart, changeEnd) 809 810 cmd += ["%s...@%s"% (p, revisionRange)] 811 812for line inp4_read_pipe_lines(cmd): 813 changeNum =int(line.split(" ")[1]) 814 changes[changeNum] =True 815 816if not block_size: 817break 818 819if end >= changeEnd: 820break 821 822 changeStart = end +1 823 824 changelist = changes.keys() 825 changelist.sort() 826return changelist 827 828defp4PathStartsWith(path, prefix): 829# This method tries to remedy a potential mixed-case issue: 830# 831# If UserA adds //depot/DirA/file1 832# and UserB adds //depot/dira/file2 833# 834# we may or may not have a problem. If you have core.ignorecase=true, 835# we treat DirA and dira as the same directory 836ifgitConfigBool("core.ignorecase"): 837return path.lower().startswith(prefix.lower()) 838return path.startswith(prefix) 839 840defgetClientSpec(): 841"""Look at the p4 client spec, create a View() object that contains 842 all the mappings, and return it.""" 843 844 specList =p4CmdList("client -o") 845iflen(specList) !=1: 846die('Output from "client -o" is%dlines, expecting 1'% 847len(specList)) 848 849# dictionary of all client parameters 850 entry = specList[0] 851 852# the //client/ name 853 client_name = entry["Client"] 854 855# just the keys that start with "View" 856 view_keys = [ k for k in entry.keys()if k.startswith("View") ] 857 858# hold this new View 859 view =View(client_name) 860 861# append the lines, in order, to the view 862for view_num inrange(len(view_keys)): 863 k ="View%d"% view_num 864if k not in view_keys: 865die("Expected view key%smissing"% k) 866 view.append(entry[k]) 867 868return view 869 870defgetClientRoot(): 871"""Grab the client directory.""" 872 873 output =p4CmdList("client -o") 874iflen(output) !=1: 875die('Output from "client -o" is%dlines, expecting 1'%len(output)) 876 877 entry = output[0] 878if"Root"not in entry: 879die('Client has no "Root"') 880 881return entry["Root"] 882 883# 884# P4 wildcards are not allowed in filenames. P4 complains 885# if you simply add them, but you can force it with "-f", in 886# which case it translates them into %xx encoding internally. 887# 888defwildcard_decode(path): 889# Search for and fix just these four characters. Do % last so 890# that fixing it does not inadvertently create new %-escapes. 891# Cannot have * in a filename in windows; untested as to 892# what p4 would do in such a case. 893if not platform.system() =="Windows": 894 path = path.replace("%2A","*") 895 path = path.replace("%23","#") \ 896.replace("%40","@") \ 897.replace("%25","%") 898return path 899 900defwildcard_encode(path): 901# do % first to avoid double-encoding the %s introduced here 902 path = path.replace("%","%25") \ 903.replace("*","%2A") \ 904.replace("#","%23") \ 905.replace("@","%40") 906return path 907 908defwildcard_present(path): 909 m = re.search("[*#@%]", path) 910return m is not None 911 912class Command: 913def__init__(self): 914 self.usage ="usage: %prog [options]" 915 self.needsGit =True 916 self.verbose =False 917 918class P4UserMap: 919def__init__(self): 920 self.userMapFromPerforceServer =False 921 self.myP4UserId =None 922 923defp4UserId(self): 924if self.myP4UserId: 925return self.myP4UserId 926 927 results =p4CmdList("user -o") 928for r in results: 929if r.has_key('User'): 930 self.myP4UserId = r['User'] 931return r['User'] 932die("Could not find your p4 user id") 933 934defp4UserIsMe(self, p4User): 935# return True if the given p4 user is actually me 936 me = self.p4UserId() 937if not p4User or p4User != me: 938return False 939else: 940return True 941 942defgetUserCacheFilename(self): 943 home = os.environ.get("HOME", os.environ.get("USERPROFILE")) 944return home +"/.gitp4-usercache.txt" 945 946defgetUserMapFromPerforceServer(self): 947if self.userMapFromPerforceServer: 948return 949 self.users = {} 950 self.emails = {} 951 952for output inp4CmdList("users"): 953if not output.has_key("User"): 954continue 955 self.users[output["User"]] = output["FullName"] +" <"+ output["Email"] +">" 956 self.emails[output["Email"]] = output["User"] 957 958 959 s ='' 960for(key, val)in self.users.items(): 961 s +="%s\t%s\n"% (key.expandtabs(1), val.expandtabs(1)) 962 963open(self.getUserCacheFilename(),"wb").write(s) 964 self.userMapFromPerforceServer =True 965 966defloadUserMapFromCache(self): 967 self.users = {} 968 self.userMapFromPerforceServer =False 969try: 970 cache =open(self.getUserCacheFilename(),"rb") 971 lines = cache.readlines() 972 cache.close() 973for line in lines: 974 entry = line.strip().split("\t") 975 self.users[entry[0]] = entry[1] 976exceptIOError: 977 self.getUserMapFromPerforceServer() 978 979classP4Debug(Command): 980def__init__(self): 981 Command.__init__(self) 982 self.options = [] 983 self.description ="A tool to debug the output of p4 -G." 984 self.needsGit =False 985 986defrun(self, args): 987 j =0 988for output inp4CmdList(args): 989print'Element:%d'% j 990 j +=1 991print output 992return True 993 994classP4RollBack(Command): 995def__init__(self): 996 Command.__init__(self) 997 self.options = [ 998 optparse.make_option("--local", dest="rollbackLocalBranches", action="store_true") 999]1000 self.description ="A tool to debug the multi-branch import. Don't use :)"1001 self.rollbackLocalBranches =False10021003defrun(self, args):1004iflen(args) !=1:1005return False1006 maxChange =int(args[0])10071008if"p4ExitCode"inp4Cmd("changes -m 1"):1009die("Problems executing p4");10101011if self.rollbackLocalBranches:1012 refPrefix ="refs/heads/"1013 lines =read_pipe_lines("git rev-parse --symbolic --branches")1014else:1015 refPrefix ="refs/remotes/"1016 lines =read_pipe_lines("git rev-parse --symbolic --remotes")10171018for line in lines:1019if self.rollbackLocalBranches or(line.startswith("p4/")and line !="p4/HEAD\n"):1020 line = line.strip()1021 ref = refPrefix + line1022 log =extractLogMessageFromGitCommit(ref)1023 settings =extractSettingsGitLog(log)10241025 depotPaths = settings['depot-paths']1026 change = settings['change']10271028 changed =False10291030iflen(p4Cmd("changes -m 1 "+' '.join(['%s...@%s'% (p, maxChange)1031for p in depotPaths]))) ==0:1032print"Branch%sdid not exist at change%s, deleting."% (ref, maxChange)1033system("git update-ref -d%s`git rev-parse%s`"% (ref, ref))1034continue10351036while change andint(change) > maxChange:1037 changed =True1038if self.verbose:1039print"%sis at%s; rewinding towards%s"% (ref, change, maxChange)1040system("git update-ref%s\"%s^\""% (ref, ref))1041 log =extractLogMessageFromGitCommit(ref)1042 settings =extractSettingsGitLog(log)104310441045 depotPaths = settings['depot-paths']1046 change = settings['change']10471048if changed:1049print"%srewound to%s"% (ref, change)10501051return True10521053classP4Submit(Command, P4UserMap):10541055 conflict_behavior_choices = ("ask","skip","quit")10561057def__init__(self):1058 Command.__init__(self)1059 P4UserMap.__init__(self)1060 self.options = [1061 optparse.make_option("--origin", dest="origin"),1062 optparse.make_option("-M", dest="detectRenames", action="store_true"),1063# preserve the user, requires relevant p4 permissions1064 optparse.make_option("--preserve-user", dest="preserveUser", action="store_true"),1065 optparse.make_option("--export-labels", dest="exportLabels", action="store_true"),1066 optparse.make_option("--dry-run","-n", dest="dry_run", action="store_true"),1067 optparse.make_option("--prepare-p4-only", dest="prepare_p4_only", action="store_true"),1068 optparse.make_option("--conflict", dest="conflict_behavior",1069 choices=self.conflict_behavior_choices),1070 optparse.make_option("--branch", dest="branch"),1071]1072 self.description ="Submit changes from git to the perforce depot."1073 self.usage +=" [name of git branch to submit into perforce depot]"1074 self.origin =""1075 self.detectRenames =False1076 self.preserveUser =gitConfigBool("git-p4.preserveUser")1077 self.dry_run =False1078 self.prepare_p4_only =False1079 self.conflict_behavior =None1080 self.isWindows = (platform.system() =="Windows")1081 self.exportLabels =False1082 self.p4HasMoveCommand =p4_has_move_command()1083 self.branch =None10841085defcheck(self):1086iflen(p4CmdList("opened ...")) >0:1087die("You have files opened with perforce! Close them before starting the sync.")10881089defseparate_jobs_from_description(self, message):1090"""Extract and return a possible Jobs field in the commit1091 message. It goes into a separate section in the p4 change1092 specification.10931094 A jobs line starts with "Jobs:" and looks like a new field1095 in a form. Values are white-space separated on the same1096 line or on following lines that start with a tab.10971098 This does not parse and extract the full git commit message1099 like a p4 form. It just sees the Jobs: line as a marker1100 to pass everything from then on directly into the p4 form,1101 but outside the description section.11021103 Return a tuple (stripped log message, jobs string)."""11041105 m = re.search(r'^Jobs:', message, re.MULTILINE)1106if m is None:1107return(message,None)11081109 jobtext = message[m.start():]1110 stripped_message = message[:m.start()].rstrip()1111return(stripped_message, jobtext)11121113defprepareLogMessage(self, template, message, jobs):1114"""Edits the template returned from "p4 change -o" to insert1115 the message in the Description field, and the jobs text in1116 the Jobs field."""1117 result =""11181119 inDescriptionSection =False11201121for line in template.split("\n"):1122if line.startswith("#"):1123 result += line +"\n"1124continue11251126if inDescriptionSection:1127if line.startswith("Files:")or line.startswith("Jobs:"):1128 inDescriptionSection =False1129# insert Jobs section1130if jobs:1131 result += jobs +"\n"1132else:1133continue1134else:1135if line.startswith("Description:"):1136 inDescriptionSection =True1137 line +="\n"1138for messageLine in message.split("\n"):1139 line +="\t"+ messageLine +"\n"11401141 result += line +"\n"11421143return result11441145defpatchRCSKeywords(self,file, pattern):1146# Attempt to zap the RCS keywords in a p4 controlled file matching the given pattern1147(handle, outFileName) = tempfile.mkstemp(dir='.')1148try:1149 outFile = os.fdopen(handle,"w+")1150 inFile =open(file,"r")1151 regexp = re.compile(pattern, re.VERBOSE)1152for line in inFile.readlines():1153 line = regexp.sub(r'$\1$', line)1154 outFile.write(line)1155 inFile.close()1156 outFile.close()1157# Forcibly overwrite the original file1158 os.unlink(file)1159 shutil.move(outFileName,file)1160except:1161# cleanup our temporary file1162 os.unlink(outFileName)1163print"Failed to strip RCS keywords in%s"%file1164raise11651166print"Patched up RCS keywords in%s"%file11671168defp4UserForCommit(self,id):1169# Return the tuple (perforce user,git email) for a given git commit id1170 self.getUserMapFromPerforceServer()1171 gitEmail =read_pipe(["git","log","--max-count=1",1172"--format=%ae",id])1173 gitEmail = gitEmail.strip()1174if not self.emails.has_key(gitEmail):1175return(None,gitEmail)1176else:1177return(self.emails[gitEmail],gitEmail)11781179defcheckValidP4Users(self,commits):1180# check if any git authors cannot be mapped to p4 users1181foridin commits:1182(user,email) = self.p4UserForCommit(id)1183if not user:1184 msg ="Cannot find p4 user for email%sin commit%s."% (email,id)1185ifgitConfigBool("git-p4.allowMissingP4Users"):1186print"%s"% msg1187else:1188die("Error:%s\nSet git-p4.allowMissingP4Users to true to allow this."% msg)11891190deflastP4Changelist(self):1191# Get back the last changelist number submitted in this client spec. This1192# then gets used to patch up the username in the change. If the same1193# client spec is being used by multiple processes then this might go1194# wrong.1195 results =p4CmdList("client -o")# find the current client1196 client =None1197for r in results:1198if r.has_key('Client'):1199 client = r['Client']1200break1201if not client:1202die("could not get client spec")1203 results =p4CmdList(["changes","-c", client,"-m","1"])1204for r in results:1205if r.has_key('change'):1206return r['change']1207die("Could not get changelist number for last submit - cannot patch up user details")12081209defmodifyChangelistUser(self, changelist, newUser):1210# fixup the user field of a changelist after it has been submitted.1211 changes =p4CmdList("change -o%s"% changelist)1212iflen(changes) !=1:1213die("Bad output from p4 change modifying%sto user%s"%1214(changelist, newUser))12151216 c = changes[0]1217if c['User'] == newUser:return# nothing to do1218 c['User'] = newUser1219input= marshal.dumps(c)12201221 result =p4CmdList("change -f -i", stdin=input)1222for r in result:1223if r.has_key('code'):1224if r['code'] =='error':1225die("Could not modify user field of changelist%sto%s:%s"% (changelist, newUser, r['data']))1226if r.has_key('data'):1227print("Updated user field for changelist%sto%s"% (changelist, newUser))1228return1229die("Could not modify user field of changelist%sto%s"% (changelist, newUser))12301231defcanChangeChangelists(self):1232# check to see if we have p4 admin or super-user permissions, either of1233# which are required to modify changelists.1234 results =p4CmdList(["protects", self.depotPath])1235for r in results:1236if r.has_key('perm'):1237if r['perm'] =='admin':1238return11239if r['perm'] =='super':1240return11241return012421243defprepareSubmitTemplate(self):1244"""Run "p4 change -o" to grab a change specification template.1245 This does not use "p4 -G", as it is nice to keep the submission1246 template in original order, since a human might edit it.12471248 Remove lines in the Files section that show changes to files1249 outside the depot path we're committing into."""12501251 template =""1252 inFilesSection =False1253for line inp4_read_pipe_lines(['change','-o']):1254if line.endswith("\r\n"):1255 line = line[:-2] +"\n"1256if inFilesSection:1257if line.startswith("\t"):1258# path starts and ends with a tab1259 path = line[1:]1260 lastTab = path.rfind("\t")1261if lastTab != -1:1262 path = path[:lastTab]1263if notp4PathStartsWith(path, self.depotPath):1264continue1265else:1266 inFilesSection =False1267else:1268if line.startswith("Files:"):1269 inFilesSection =True12701271 template += line12721273return template12741275defedit_template(self, template_file):1276"""Invoke the editor to let the user change the submission1277 message. Return true if okay to continue with the submit."""12781279# if configured to skip the editing part, just submit1280ifgitConfigBool("git-p4.skipSubmitEdit"):1281return True12821283# look at the modification time, to check later if the user saved1284# the file1285 mtime = os.stat(template_file).st_mtime12861287# invoke the editor1288if os.environ.has_key("P4EDITOR")and(os.environ.get("P4EDITOR") !=""):1289 editor = os.environ.get("P4EDITOR")1290else:1291 editor =read_pipe("git var GIT_EDITOR").strip()1292system(["sh","-c", ('%s"$@"'% editor), editor, template_file])12931294# If the file was not saved, prompt to see if this patch should1295# be skipped. But skip this verification step if configured so.1296ifgitConfigBool("git-p4.skipSubmitEditCheck"):1297return True12981299# modification time updated means user saved the file1300if os.stat(template_file).st_mtime > mtime:1301return True13021303while True:1304 response =raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")1305if response =='y':1306return True1307if response =='n':1308return False13091310defget_diff_description(self, editedFiles, filesToAdd):1311# diff1312if os.environ.has_key("P4DIFF"):1313del(os.environ["P4DIFF"])1314 diff =""1315for editedFile in editedFiles:1316 diff +=p4_read_pipe(['diff','-du',1317wildcard_encode(editedFile)])13181319# new file diff1320 newdiff =""1321for newFile in filesToAdd:1322 newdiff +="==== new file ====\n"1323 newdiff +="--- /dev/null\n"1324 newdiff +="+++%s\n"% newFile1325 f =open(newFile,"r")1326for line in f.readlines():1327 newdiff +="+"+ line1328 f.close()13291330return(diff + newdiff).replace('\r\n','\n')13311332defapplyCommit(self,id):1333"""Apply one commit, return True if it succeeded."""13341335print"Applying",read_pipe(["git","show","-s",1336"--format=format:%h%s",id])13371338(p4User, gitEmail) = self.p4UserForCommit(id)13391340 diff =read_pipe_lines("git diff-tree -r%s\"%s^\" \"%s\""% (self.diffOpts,id,id))1341 filesToAdd =set()1342 filesToDelete =set()1343 editedFiles =set()1344 pureRenameCopy =set()1345 filesToChangeExecBit = {}13461347for line in diff:1348 diff =parseDiffTreeEntry(line)1349 modifier = diff['status']1350 path = diff['src']1351if modifier =="M":1352p4_edit(path)1353ifisModeExecChanged(diff['src_mode'], diff['dst_mode']):1354 filesToChangeExecBit[path] = diff['dst_mode']1355 editedFiles.add(path)1356elif modifier =="A":1357 filesToAdd.add(path)1358 filesToChangeExecBit[path] = diff['dst_mode']1359if path in filesToDelete:1360 filesToDelete.remove(path)1361elif modifier =="D":1362 filesToDelete.add(path)1363if path in filesToAdd:1364 filesToAdd.remove(path)1365elif modifier =="C":1366 src, dest = diff['src'], diff['dst']1367p4_integrate(src, dest)1368 pureRenameCopy.add(dest)1369if diff['src_sha1'] != diff['dst_sha1']:1370p4_edit(dest)1371 pureRenameCopy.discard(dest)1372ifisModeExecChanged(diff['src_mode'], diff['dst_mode']):1373p4_edit(dest)1374 pureRenameCopy.discard(dest)1375 filesToChangeExecBit[dest] = diff['dst_mode']1376if self.isWindows:1377# turn off read-only attribute1378 os.chmod(dest, stat.S_IWRITE)1379 os.unlink(dest)1380 editedFiles.add(dest)1381elif modifier =="R":1382 src, dest = diff['src'], diff['dst']1383if self.p4HasMoveCommand:1384p4_edit(src)# src must be open before move1385p4_move(src, dest)# opens for (move/delete, move/add)1386else:1387p4_integrate(src, dest)1388if diff['src_sha1'] != diff['dst_sha1']:1389p4_edit(dest)1390else:1391 pureRenameCopy.add(dest)1392ifisModeExecChanged(diff['src_mode'], diff['dst_mode']):1393if not self.p4HasMoveCommand:1394p4_edit(dest)# with move: already open, writable1395 filesToChangeExecBit[dest] = diff['dst_mode']1396if not self.p4HasMoveCommand:1397if self.isWindows:1398 os.chmod(dest, stat.S_IWRITE)1399 os.unlink(dest)1400 filesToDelete.add(src)1401 editedFiles.add(dest)1402else:1403die("unknown modifier%sfor%s"% (modifier, path))14041405 diffcmd ="git diff-tree --full-index -p\"%s\""% (id)1406 patchcmd = diffcmd +" | git apply "1407 tryPatchCmd = patchcmd +"--check -"1408 applyPatchCmd = patchcmd +"--check --apply -"1409 patch_succeeded =True14101411if os.system(tryPatchCmd) !=0:1412 fixed_rcs_keywords =False1413 patch_succeeded =False1414print"Unfortunately applying the change failed!"14151416# Patch failed, maybe it's just RCS keyword woes. Look through1417# the patch to see if that's possible.1418ifgitConfigBool("git-p4.attemptRCSCleanup"):1419file=None1420 pattern =None1421 kwfiles = {}1422forfilein editedFiles | filesToDelete:1423# did this file's delta contain RCS keywords?1424 pattern =p4_keywords_regexp_for_file(file)14251426if pattern:1427# this file is a possibility...look for RCS keywords.1428 regexp = re.compile(pattern, re.VERBOSE)1429for line inread_pipe_lines(["git","diff","%s^..%s"% (id,id),file]):1430if regexp.search(line):1431if verbose:1432print"got keyword match on%sin%sin%s"% (pattern, line,file)1433 kwfiles[file] = pattern1434break14351436forfilein kwfiles:1437if verbose:1438print"zapping%swith%s"% (line,pattern)1439# File is being deleted, so not open in p4. Must1440# disable the read-only bit on windows.1441if self.isWindows andfilenot in editedFiles:1442 os.chmod(file, stat.S_IWRITE)1443 self.patchRCSKeywords(file, kwfiles[file])1444 fixed_rcs_keywords =True14451446if fixed_rcs_keywords:1447print"Retrying the patch with RCS keywords cleaned up"1448if os.system(tryPatchCmd) ==0:1449 patch_succeeded =True14501451if not patch_succeeded:1452for f in editedFiles:1453p4_revert(f)1454return False14551456#1457# Apply the patch for real, and do add/delete/+x handling.1458#1459system(applyPatchCmd)14601461for f in filesToAdd:1462p4_add(f)1463for f in filesToDelete:1464p4_revert(f)1465p4_delete(f)14661467# Set/clear executable bits1468for f in filesToChangeExecBit.keys():1469 mode = filesToChangeExecBit[f]1470setP4ExecBit(f, mode)14711472#1473# Build p4 change description, starting with the contents1474# of the git commit message.1475#1476 logMessage =extractLogMessageFromGitCommit(id)1477 logMessage = logMessage.strip()1478(logMessage, jobs) = self.separate_jobs_from_description(logMessage)14791480 template = self.prepareSubmitTemplate()1481 submitTemplate = self.prepareLogMessage(template, logMessage, jobs)14821483if self.preserveUser:1484 submitTemplate +="\n######## Actual user%s, modified after commit\n"% p4User14851486if self.checkAuthorship and not self.p4UserIsMe(p4User):1487 submitTemplate +="######## git author%sdoes not match your p4 account.\n"% gitEmail1488 submitTemplate +="######## Use option --preserve-user to modify authorship.\n"1489 submitTemplate +="######## Variable git-p4.skipUserNameCheck hides this message.\n"14901491 separatorLine ="######## everything below this line is just the diff #######\n"1492if not self.prepare_p4_only:1493 submitTemplate += separatorLine1494 submitTemplate += self.get_diff_description(editedFiles, filesToAdd)14951496(handle, fileName) = tempfile.mkstemp()1497 tmpFile = os.fdopen(handle,"w+b")1498if self.isWindows:1499 submitTemplate = submitTemplate.replace("\n","\r\n")1500 tmpFile.write(submitTemplate)1501 tmpFile.close()15021503if self.prepare_p4_only:1504#1505# Leave the p4 tree prepared, and the submit template around1506# and let the user decide what to do next1507#1508print1509print"P4 workspace prepared for submission."1510print"To submit or revert, go to client workspace"1511print" "+ self.clientPath1512print1513print"To submit, use\"p4 submit\"to write a new description,"1514print"or\"p4 submit -i <%s\"to use the one prepared by" \1515"\"git p4\"."% fileName1516print"You can delete the file\"%s\"when finished."% fileName15171518if self.preserveUser and p4User and not self.p4UserIsMe(p4User):1519print"To preserve change ownership by user%s, you must\n" \1520"do\"p4 change -f <change>\"after submitting and\n" \1521"edit the User field."1522if pureRenameCopy:1523print"After submitting, renamed files must be re-synced."1524print"Invoke\"p4 sync -f\"on each of these files:"1525for f in pureRenameCopy:1526print" "+ f15271528print1529print"To revert the changes, use\"p4 revert ...\", and delete"1530print"the submit template file\"%s\""% fileName1531if filesToAdd:1532print"Since the commit adds new files, they must be deleted:"1533for f in filesToAdd:1534print" "+ f1535print1536return True15371538#1539# Let the user edit the change description, then submit it.1540#1541if self.edit_template(fileName):1542# read the edited message and submit1543 ret =True1544 tmpFile =open(fileName,"rb")1545 message = tmpFile.read()1546 tmpFile.close()1547if self.isWindows:1548 message = message.replace("\r\n","\n")1549 submitTemplate = message[:message.index(separatorLine)]1550p4_write_pipe(['submit','-i'], submitTemplate)15511552if self.preserveUser:1553if p4User:1554# Get last changelist number. Cannot easily get it from1555# the submit command output as the output is1556# unmarshalled.1557 changelist = self.lastP4Changelist()1558 self.modifyChangelistUser(changelist, p4User)15591560# The rename/copy happened by applying a patch that created a1561# new file. This leaves it writable, which confuses p4.1562for f in pureRenameCopy:1563p4_sync(f,"-f")15641565else:1566# skip this patch1567 ret =False1568print"Submission cancelled, undoing p4 changes."1569for f in editedFiles:1570p4_revert(f)1571for f in filesToAdd:1572p4_revert(f)1573 os.remove(f)1574for f in filesToDelete:1575p4_revert(f)15761577 os.remove(fileName)1578return ret15791580# Export git tags as p4 labels. Create a p4 label and then tag1581# with that.1582defexportGitTags(self, gitTags):1583 validLabelRegexp =gitConfig("git-p4.labelExportRegexp")1584iflen(validLabelRegexp) ==0:1585 validLabelRegexp = defaultLabelRegexp1586 m = re.compile(validLabelRegexp)15871588for name in gitTags:15891590if not m.match(name):1591if verbose:1592print"tag%sdoes not match regexp%s"% (name, validLabelRegexp)1593continue15941595# Get the p4 commit this corresponds to1596 logMessage =extractLogMessageFromGitCommit(name)1597 values =extractSettingsGitLog(logMessage)15981599if not values.has_key('change'):1600# a tag pointing to something not sent to p4; ignore1601if verbose:1602print"git tag%sdoes not give a p4 commit"% name1603continue1604else:1605 changelist = values['change']16061607# Get the tag details.1608 inHeader =True1609 isAnnotated =False1610 body = []1611for l inread_pipe_lines(["git","cat-file","-p", name]):1612 l = l.strip()1613if inHeader:1614if re.match(r'tag\s+', l):1615 isAnnotated =True1616elif re.match(r'\s*$', l):1617 inHeader =False1618continue1619else:1620 body.append(l)16211622if not isAnnotated:1623 body = ["lightweight tag imported by git p4\n"]16241625# Create the label - use the same view as the client spec we are using1626 clientSpec =getClientSpec()16271628 labelTemplate ="Label:%s\n"% name1629 labelTemplate +="Description:\n"1630for b in body:1631 labelTemplate +="\t"+ b +"\n"1632 labelTemplate +="View:\n"1633for depot_side in clientSpec.mappings:1634 labelTemplate +="\t%s\n"% depot_side16351636if self.dry_run:1637print"Would create p4 label%sfor tag"% name1638elif self.prepare_p4_only:1639print"Not creating p4 label%sfor tag due to option" \1640" --prepare-p4-only"% name1641else:1642p4_write_pipe(["label","-i"], labelTemplate)16431644# Use the label1645p4_system(["tag","-l", name] +1646["%s@%s"% (depot_side, changelist)for depot_side in clientSpec.mappings])16471648if verbose:1649print"created p4 label for tag%s"% name16501651defrun(self, args):1652iflen(args) ==0:1653 self.master =currentGitBranch()1654iflen(self.master) ==0or notgitBranchExists("refs/heads/%s"% self.master):1655die("Detecting current git branch failed!")1656eliflen(args) ==1:1657 self.master = args[0]1658if notbranchExists(self.master):1659die("Branch%sdoes not exist"% self.master)1660else:1661return False16621663 allowSubmit =gitConfig("git-p4.allowSubmit")1664iflen(allowSubmit) >0and not self.master in allowSubmit.split(","):1665die("%sis not in git-p4.allowSubmit"% self.master)16661667[upstream, settings] =findUpstreamBranchPoint()1668 self.depotPath = settings['depot-paths'][0]1669iflen(self.origin) ==0:1670 self.origin = upstream16711672if self.preserveUser:1673if not self.canChangeChangelists():1674die("Cannot preserve user names without p4 super-user or admin permissions")16751676# if not set from the command line, try the config file1677if self.conflict_behavior is None:1678 val =gitConfig("git-p4.conflict")1679if val:1680if val not in self.conflict_behavior_choices:1681die("Invalid value '%s' for config git-p4.conflict"% val)1682else:1683 val ="ask"1684 self.conflict_behavior = val16851686if self.verbose:1687print"Origin branch is "+ self.origin16881689iflen(self.depotPath) ==0:1690print"Internal error: cannot locate perforce depot path from existing branches"1691 sys.exit(128)16921693 self.useClientSpec =False1694ifgitConfigBool("git-p4.useclientspec"):1695 self.useClientSpec =True1696if self.useClientSpec:1697 self.clientSpecDirs =getClientSpec()16981699# Check for the existance of P4 branches1700 branchesDetected = (len(p4BranchesInGit().keys()) >1)17011702if self.useClientSpec and not branchesDetected:1703# all files are relative to the client spec1704 self.clientPath =getClientRoot()1705else:1706 self.clientPath =p4Where(self.depotPath)17071708if self.clientPath =="":1709die("Error: Cannot locate perforce checkout of%sin client view"% self.depotPath)17101711print"Perforce checkout for depot path%slocated at%s"% (self.depotPath, self.clientPath)1712 self.oldWorkingDirectory = os.getcwd()17131714# ensure the clientPath exists1715 new_client_dir =False1716if not os.path.exists(self.clientPath):1717 new_client_dir =True1718 os.makedirs(self.clientPath)17191720chdir(self.clientPath, is_client_path=True)1721if self.dry_run:1722print"Would synchronize p4 checkout in%s"% self.clientPath1723else:1724print"Synchronizing p4 checkout..."1725if new_client_dir:1726# old one was destroyed, and maybe nobody told p41727p4_sync("...","-f")1728else:1729p4_sync("...")1730 self.check()17311732 commits = []1733for line inread_pipe_lines(["git","rev-list","--no-merges","%s..%s"% (self.origin, self.master)]):1734 commits.append(line.strip())1735 commits.reverse()17361737if self.preserveUser orgitConfigBool("git-p4.skipUserNameCheck"):1738 self.checkAuthorship =False1739else:1740 self.checkAuthorship =True17411742if self.preserveUser:1743 self.checkValidP4Users(commits)17441745#1746# Build up a set of options to be passed to diff when1747# submitting each commit to p4.1748#1749if self.detectRenames:1750# command-line -M arg1751 self.diffOpts ="-M"1752else:1753# If not explicitly set check the config variable1754 detectRenames =gitConfig("git-p4.detectRenames")17551756if detectRenames.lower() =="false"or detectRenames =="":1757 self.diffOpts =""1758elif detectRenames.lower() =="true":1759 self.diffOpts ="-M"1760else:1761 self.diffOpts ="-M%s"% detectRenames17621763# no command-line arg for -C or --find-copies-harder, just1764# config variables1765 detectCopies =gitConfig("git-p4.detectCopies")1766if detectCopies.lower() =="false"or detectCopies =="":1767pass1768elif detectCopies.lower() =="true":1769 self.diffOpts +=" -C"1770else:1771 self.diffOpts +=" -C%s"% detectCopies17721773ifgitConfigBool("git-p4.detectCopiesHarder"):1774 self.diffOpts +=" --find-copies-harder"17751776#1777# Apply the commits, one at a time. On failure, ask if should1778# continue to try the rest of the patches, or quit.1779#1780if self.dry_run:1781print"Would apply"1782 applied = []1783 last =len(commits) -11784for i, commit inenumerate(commits):1785if self.dry_run:1786print" ",read_pipe(["git","show","-s",1787"--format=format:%h%s", commit])1788 ok =True1789else:1790 ok = self.applyCommit(commit)1791if ok:1792 applied.append(commit)1793else:1794if self.prepare_p4_only and i < last:1795print"Processing only the first commit due to option" \1796" --prepare-p4-only"1797break1798if i < last:1799 quit =False1800while True:1801# prompt for what to do, or use the option/variable1802if self.conflict_behavior =="ask":1803print"What do you want to do?"1804 response =raw_input("[s]kip this commit but apply"1805" the rest, or [q]uit? ")1806if not response:1807continue1808elif self.conflict_behavior =="skip":1809 response ="s"1810elif self.conflict_behavior =="quit":1811 response ="q"1812else:1813die("Unknown conflict_behavior '%s'"%1814 self.conflict_behavior)18151816if response[0] =="s":1817print"Skipping this commit, but applying the rest"1818break1819if response[0] =="q":1820print"Quitting"1821 quit =True1822break1823if quit:1824break18251826chdir(self.oldWorkingDirectory)18271828if self.dry_run:1829pass1830elif self.prepare_p4_only:1831pass1832eliflen(commits) ==len(applied):1833print"All commits applied!"18341835 sync =P4Sync()1836if self.branch:1837 sync.branch = self.branch1838 sync.run([])18391840 rebase =P4Rebase()1841 rebase.rebase()18421843else:1844iflen(applied) ==0:1845print"No commits applied."1846else:1847print"Applied only the commits marked with '*':"1848for c in commits:1849if c in applied:1850 star ="*"1851else:1852 star =" "1853print star,read_pipe(["git","show","-s",1854"--format=format:%h%s", c])1855print"You will have to do 'git p4 sync' and rebase."18561857ifgitConfigBool("git-p4.exportLabels"):1858 self.exportLabels =True18591860if self.exportLabels:1861 p4Labels =getP4Labels(self.depotPath)1862 gitTags =getGitTags()18631864 missingGitTags = gitTags - p4Labels1865 self.exportGitTags(missingGitTags)18661867# exit with error unless everything applied perfectly1868iflen(commits) !=len(applied):1869 sys.exit(1)18701871return True18721873classView(object):1874"""Represent a p4 view ("p4 help views"), and map files in a1875 repo according to the view."""18761877def__init__(self, client_name):1878 self.mappings = []1879 self.client_prefix ="//%s/"% client_name1880# cache results of "p4 where" to lookup client file locations1881 self.client_spec_path_cache = {}18821883defappend(self, view_line):1884"""Parse a view line, splitting it into depot and client1885 sides. Append to self.mappings, preserving order. This1886 is only needed for tag creation."""18871888# Split the view line into exactly two words. P4 enforces1889# structure on these lines that simplifies this quite a bit.1890#1891# Either or both words may be double-quoted.1892# Single quotes do not matter.1893# Double-quote marks cannot occur inside the words.1894# A + or - prefix is also inside the quotes.1895# There are no quotes unless they contain a space.1896# The line is already white-space stripped.1897# The two words are separated by a single space.1898#1899if view_line[0] =='"':1900# First word is double quoted. Find its end.1901 close_quote_index = view_line.find('"',1)1902if close_quote_index <=0:1903die("No first-word closing quote found:%s"% view_line)1904 depot_side = view_line[1:close_quote_index]1905# skip closing quote and space1906 rhs_index = close_quote_index +1+11907else:1908 space_index = view_line.find(" ")1909if space_index <=0:1910die("No word-splitting space found:%s"% view_line)1911 depot_side = view_line[0:space_index]1912 rhs_index = space_index +119131914# prefix + means overlay on previous mapping1915if depot_side.startswith("+"):1916 depot_side = depot_side[1:]19171918# prefix - means exclude this path, leave out of mappings1919 exclude =False1920if depot_side.startswith("-"):1921 exclude =True1922 depot_side = depot_side[1:]19231924if not exclude:1925 self.mappings.append(depot_side)19261927defconvert_client_path(self, clientFile):1928# chop off //client/ part to make it relative1929if not clientFile.startswith(self.client_prefix):1930die("No prefix '%s' on clientFile '%s'"%1931(self.client_prefix, clientFile))1932return clientFile[len(self.client_prefix):]19331934defupdate_client_spec_path_cache(self, files):1935""" Caching file paths by "p4 where" batch query """19361937# List depot file paths exclude that already cached1938 fileArgs = [f['path']for f in files if f['path']not in self.client_spec_path_cache]19391940iflen(fileArgs) ==0:1941return# All files in cache19421943 where_result =p4CmdList(["-x","-","where"], stdin=fileArgs)1944for res in where_result:1945if"code"in res and res["code"] =="error":1946# assume error is "... file(s) not in client view"1947continue1948if"clientFile"not in res:1949die("No clientFile in 'p4 where' output")1950if"unmap"in res:1951# it will list all of them, but only one not unmap-ped1952continue1953 self.client_spec_path_cache[res['depotFile']] = self.convert_client_path(res["clientFile"])19541955# not found files or unmap files set to ""1956for depotFile in fileArgs:1957if depotFile not in self.client_spec_path_cache:1958 self.client_spec_path_cache[depotFile] =""19591960defmap_in_client(self, depot_path):1961"""Return the relative location in the client where this1962 depot file should live. Returns "" if the file should1963 not be mapped in the client."""19641965if depot_path in self.client_spec_path_cache:1966return self.client_spec_path_cache[depot_path]19671968die("Error:%sis not found in client spec path"% depot_path )1969return""19701971classP4Sync(Command, P4UserMap):1972 delete_actions = ("delete","move/delete","purge")19731974def__init__(self):1975 Command.__init__(self)1976 P4UserMap.__init__(self)1977 self.options = [1978 optparse.make_option("--branch", dest="branch"),1979 optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"),1980 optparse.make_option("--changesfile", dest="changesFile"),1981 optparse.make_option("--silent", dest="silent", action="store_true"),1982 optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),1983 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),1984 optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",1985help="Import into refs/heads/ , not refs/remotes"),1986 optparse.make_option("--max-changes", dest="maxChanges",1987help="Maximum number of changes to import"),1988 optparse.make_option("--changes-block-size", dest="changes_block_size",type="int",1989help="Internal block size to use when iteratively calling p4 changes"),1990 optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',1991help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),1992 optparse.make_option("--use-client-spec", dest="useClientSpec", action='store_true',1993help="Only sync files that are included in the Perforce Client Spec"),1994 optparse.make_option("-/", dest="cloneExclude",1995 action="append",type="string",1996help="exclude depot path"),1997]1998 self.description ="""Imports from Perforce into a git repository.\n1999 example:2000 //depot/my/project/ -- to import the current head2001 //depot/my/project/@all -- to import everything2002 //depot/my/project/@1,6 -- to import only from revision 1 to 620032004 (a ... is not needed in the path p4 specification, it's added implicitly)"""20052006 self.usage +=" //depot/path[@revRange]"2007 self.silent =False2008 self.createdBranches =set()2009 self.committedChanges =set()2010 self.branch =""2011 self.detectBranches =False2012 self.detectLabels =False2013 self.importLabels =False2014 self.changesFile =""2015 self.syncWithOrigin =True2016 self.importIntoRemotes =True2017 self.maxChanges =""2018 self.changes_block_size =None2019 self.keepRepoPath =False2020 self.depotPaths =None2021 self.p4BranchesInGit = []2022 self.cloneExclude = []2023 self.useClientSpec =False2024 self.useClientSpec_from_options =False2025 self.clientSpecDirs =None2026 self.tempBranches = []2027 self.tempBranchLocation ="git-p4-tmp"20282029ifgitConfig("git-p4.syncFromOrigin") =="false":2030 self.syncWithOrigin =False20312032# This is required for the "append" cloneExclude action2033defensure_value(self, attr, value):2034if nothasattr(self, attr)orgetattr(self, attr)is None:2035setattr(self, attr, value)2036returngetattr(self, attr)20372038# Force a checkpoint in fast-import and wait for it to finish2039defcheckpoint(self):2040 self.gitStream.write("checkpoint\n\n")2041 self.gitStream.write("progress checkpoint\n\n")2042 out = self.gitOutput.readline()2043if self.verbose:2044print"checkpoint finished: "+ out20452046defextractFilesFromCommit(self, commit):2047 self.cloneExclude = [re.sub(r"\.\.\.$","", path)2048for path in self.cloneExclude]2049 files = []2050 fnum =02051while commit.has_key("depotFile%s"% fnum):2052 path = commit["depotFile%s"% fnum]20532054if[p for p in self.cloneExclude2055ifp4PathStartsWith(path, p)]:2056 found =False2057else:2058 found = [p for p in self.depotPaths2059ifp4PathStartsWith(path, p)]2060if not found:2061 fnum = fnum +12062continue20632064file= {}2065file["path"] = path2066file["rev"] = commit["rev%s"% fnum]2067file["action"] = commit["action%s"% fnum]2068file["type"] = commit["type%s"% fnum]2069 files.append(file)2070 fnum = fnum +12071return files20722073defstripRepoPath(self, path, prefixes):2074"""When streaming files, this is called to map a p4 depot path2075 to where it should go in git. The prefixes are either2076 self.depotPaths, or self.branchPrefixes in the case of2077 branch detection."""20782079if self.useClientSpec:2080# branch detection moves files up a level (the branch name)2081# from what client spec interpretation gives2082 path = self.clientSpecDirs.map_in_client(path)2083if self.detectBranches:2084for b in self.knownBranches:2085if path.startswith(b +"/"):2086 path = path[len(b)+1:]20872088elif self.keepRepoPath:2089# Preserve everything in relative path name except leading2090# //depot/; just look at first prefix as they all should2091# be in the same depot.2092 depot = re.sub("^(//[^/]+/).*", r'\1', prefixes[0])2093ifp4PathStartsWith(path, depot):2094 path = path[len(depot):]20952096else:2097for p in prefixes:2098ifp4PathStartsWith(path, p):2099 path = path[len(p):]2100break21012102 path =wildcard_decode(path)2103return path21042105defsplitFilesIntoBranches(self, commit):2106"""Look at each depotFile in the commit to figure out to what2107 branch it belongs."""21082109if self.clientSpecDirs:2110 files = self.extractFilesFromCommit(commit)2111 self.clientSpecDirs.update_client_spec_path_cache(files)21122113 branches = {}2114 fnum =02115while commit.has_key("depotFile%s"% fnum):2116 path = commit["depotFile%s"% fnum]2117 found = [p for p in self.depotPaths2118ifp4PathStartsWith(path, p)]2119if not found:2120 fnum = fnum +12121continue21222123file= {}2124file["path"] = path2125file["rev"] = commit["rev%s"% fnum]2126file["action"] = commit["action%s"% fnum]2127file["type"] = commit["type%s"% fnum]2128 fnum = fnum +121292130# start with the full relative path where this file would2131# go in a p4 client2132if self.useClientSpec:2133 relPath = self.clientSpecDirs.map_in_client(path)2134else:2135 relPath = self.stripRepoPath(path, self.depotPaths)21362137for branch in self.knownBranches.keys():2138# add a trailing slash so that a commit into qt/4.2foo2139# doesn't end up in qt/4.2, e.g.2140if relPath.startswith(branch +"/"):2141if branch not in branches:2142 branches[branch] = []2143 branches[branch].append(file)2144break21452146return branches21472148# output one file from the P4 stream2149# - helper for streamP4Files21502151defstreamOneP4File(self,file, contents):2152 relPath = self.stripRepoPath(file['depotFile'], self.branchPrefixes)2153if verbose:2154 sys.stderr.write("%s\n"% relPath)21552156(type_base, type_mods) =split_p4_type(file["type"])21572158 git_mode ="100644"2159if"x"in type_mods:2160 git_mode ="100755"2161if type_base =="symlink":2162 git_mode ="120000"2163# p4 print on a symlink sometimes contains "target\n";2164# if it does, remove the newline2165 data =''.join(contents)2166if not data:2167# Some version of p4 allowed creating a symlink that pointed2168# to nothing. This causes p4 errors when checking out such2169# a change, and errors here too. Work around it by ignoring2170# the bad symlink; hopefully a future change fixes it.2171print"\nIgnoring empty symlink in%s"%file['depotFile']2172return2173elif data[-1] =='\n':2174 contents = [data[:-1]]2175else:2176 contents = [data]21772178if type_base =="utf16":2179# p4 delivers different text in the python output to -G2180# than it does when using "print -o", or normal p4 client2181# operations. utf16 is converted to ascii or utf8, perhaps.2182# But ascii text saved as -t utf16 is completely mangled.2183# Invoke print -o to get the real contents.2184#2185# On windows, the newlines will always be mangled by print, so put2186# them back too. This is not needed to the cygwin windows version,2187# just the native "NT" type.2188#2189 text =p4_read_pipe(['print','-q','-o','-',"%s@%s"% (file['depotFile'],file['change']) ])2190ifp4_version_string().find("/NT") >=0:2191 text = text.replace("\r\n","\n")2192 contents = [ text ]21932194if type_base =="apple":2195# Apple filetype files will be streamed as a concatenation of2196# its appledouble header and the contents. This is useless2197# on both macs and non-macs. If using "print -q -o xx", it2198# will create "xx" with the data, and "%xx" with the header.2199# This is also not very useful.2200#2201# Ideally, someday, this script can learn how to generate2202# appledouble files directly and import those to git, but2203# non-mac machines can never find a use for apple filetype.2204print"\nIgnoring apple filetype file%s"%file['depotFile']2205return22062207# Note that we do not try to de-mangle keywords on utf16 files,2208# even though in theory somebody may want that.2209 pattern =p4_keywords_regexp_for_type(type_base, type_mods)2210if pattern:2211 regexp = re.compile(pattern, re.VERBOSE)2212 text =''.join(contents)2213 text = regexp.sub(r'$\1$', text)2214 contents = [ text ]22152216try:2217 relPath.decode('ascii')2218except:2219 encoding ='utf8'2220ifgitConfig('git-p4.pathEncoding'):2221 encoding =gitConfig('git-p4.pathEncoding')2222 relPath = relPath.decode(encoding).encode('utf8','replace')2223if self.verbose:2224print'Path with non-ASCII characters detected. Used%sto encode:%s'% (encoding, relPath)22252226 self.gitStream.write("M%sinline%s\n"% (git_mode, relPath))22272228# total length...2229 length =02230for d in contents:2231 length = length +len(d)22322233 self.gitStream.write("data%d\n"% length)2234for d in contents:2235 self.gitStream.write(d)2236 self.gitStream.write("\n")22372238defstreamOneP4Deletion(self,file):2239 relPath = self.stripRepoPath(file['path'], self.branchPrefixes)2240if verbose:2241 sys.stderr.write("delete%s\n"% relPath)2242 self.gitStream.write("D%s\n"% relPath)22432244# handle another chunk of streaming data2245defstreamP4FilesCb(self, marshalled):22462247# catch p4 errors and complain2248 err =None2249if"code"in marshalled:2250if marshalled["code"] =="error":2251if"data"in marshalled:2252 err = marshalled["data"].rstrip()2253if err:2254 f =None2255if self.stream_have_file_info:2256if"depotFile"in self.stream_file:2257 f = self.stream_file["depotFile"]2258# force a failure in fast-import, else an empty2259# commit will be made2260 self.gitStream.write("\n")2261 self.gitStream.write("die-now\n")2262 self.gitStream.close()2263# ignore errors, but make sure it exits first2264 self.importProcess.wait()2265if f:2266die("Error from p4 print for%s:%s"% (f, err))2267else:2268die("Error from p4 print:%s"% err)22692270if marshalled.has_key('depotFile')and self.stream_have_file_info:2271# start of a new file - output the old one first2272 self.streamOneP4File(self.stream_file, self.stream_contents)2273 self.stream_file = {}2274 self.stream_contents = []2275 self.stream_have_file_info =False22762277# pick up the new file information... for the2278# 'data' field we need to append to our array2279for k in marshalled.keys():2280if k =='data':2281 self.stream_contents.append(marshalled['data'])2282else:2283 self.stream_file[k] = marshalled[k]22842285 self.stream_have_file_info =True22862287# Stream directly from "p4 files" into "git fast-import"2288defstreamP4Files(self, files):2289 filesForCommit = []2290 filesToRead = []2291 filesToDelete = []22922293for f in files:2294# if using a client spec, only add the files that have2295# a path in the client2296if self.clientSpecDirs:2297if self.clientSpecDirs.map_in_client(f['path']) =="":2298continue22992300 filesForCommit.append(f)2301if f['action']in self.delete_actions:2302 filesToDelete.append(f)2303else:2304 filesToRead.append(f)23052306# deleted files...2307for f in filesToDelete:2308 self.streamOneP4Deletion(f)23092310iflen(filesToRead) >0:2311 self.stream_file = {}2312 self.stream_contents = []2313 self.stream_have_file_info =False23142315# curry self argument2316defstreamP4FilesCbSelf(entry):2317 self.streamP4FilesCb(entry)23182319 fileArgs = ['%s#%s'% (f['path'], f['rev'])for f in filesToRead]23202321p4CmdList(["-x","-","print"],2322 stdin=fileArgs,2323 cb=streamP4FilesCbSelf)23242325# do the last chunk2326if self.stream_file.has_key('depotFile'):2327 self.streamOneP4File(self.stream_file, self.stream_contents)23282329defmake_email(self, userid):2330if userid in self.users:2331return self.users[userid]2332else:2333return"%s<a@b>"% userid23342335# Stream a p4 tag2336defstreamTag(self, gitStream, labelName, labelDetails, commit, epoch):2337if verbose:2338print"writing tag%sfor commit%s"% (labelName, commit)2339 gitStream.write("tag%s\n"% labelName)2340 gitStream.write("from%s\n"% commit)23412342if labelDetails.has_key('Owner'):2343 owner = labelDetails["Owner"]2344else:2345 owner =None23462347# Try to use the owner of the p4 label, or failing that,2348# the current p4 user id.2349if owner:2350 email = self.make_email(owner)2351else:2352 email = self.make_email(self.p4UserId())2353 tagger ="%s %s %s"% (email, epoch, self.tz)23542355 gitStream.write("tagger%s\n"% tagger)23562357print"labelDetails=",labelDetails2358if labelDetails.has_key('Description'):2359 description = labelDetails['Description']2360else:2361 description ='Label from git p4'23622363 gitStream.write("data%d\n"%len(description))2364 gitStream.write(description)2365 gitStream.write("\n")23662367defcommit(self, details, files, branch, parent =""):2368 epoch = details["time"]2369 author = details["user"]23702371if self.verbose:2372print"commit into%s"% branch23732374# start with reading files; if that fails, we should not2375# create a commit.2376 new_files = []2377for f in files:2378if[p for p in self.branchPrefixes ifp4PathStartsWith(f['path'], p)]:2379 new_files.append(f)2380else:2381 sys.stderr.write("Ignoring file outside of prefix:%s\n"% f['path'])23822383if self.clientSpecDirs:2384 self.clientSpecDirs.update_client_spec_path_cache(files)23852386 self.gitStream.write("commit%s\n"% branch)2387# gitStream.write("mark :%s\n" % details["change"])2388 self.committedChanges.add(int(details["change"]))2389 committer =""2390if author not in self.users:2391 self.getUserMapFromPerforceServer()2392 committer ="%s %s %s"% (self.make_email(author), epoch, self.tz)23932394 self.gitStream.write("committer%s\n"% committer)23952396 self.gitStream.write("data <<EOT\n")2397 self.gitStream.write(details["desc"])2398 self.gitStream.write("\n[git-p4: depot-paths =\"%s\": change =%s"%2399(','.join(self.branchPrefixes), details["change"]))2400iflen(details['options']) >0:2401 self.gitStream.write(": options =%s"% details['options'])2402 self.gitStream.write("]\nEOT\n\n")24032404iflen(parent) >0:2405if self.verbose:2406print"parent%s"% parent2407 self.gitStream.write("from%s\n"% parent)24082409 self.streamP4Files(new_files)2410 self.gitStream.write("\n")24112412 change =int(details["change"])24132414if self.labels.has_key(change):2415 label = self.labels[change]2416 labelDetails = label[0]2417 labelRevisions = label[1]2418if self.verbose:2419print"Change%sis labelled%s"% (change, labelDetails)24202421 files =p4CmdList(["files"] + ["%s...@%s"% (p, change)2422for p in self.branchPrefixes])24232424iflen(files) ==len(labelRevisions):24252426 cleanedFiles = {}2427for info in files:2428if info["action"]in self.delete_actions:2429continue2430 cleanedFiles[info["depotFile"]] = info["rev"]24312432if cleanedFiles == labelRevisions:2433 self.streamTag(self.gitStream,'tag_%s'% labelDetails['label'], labelDetails, branch, epoch)24342435else:2436if not self.silent:2437print("Tag%sdoes not match with change%s: files do not match."2438% (labelDetails["label"], change))24392440else:2441if not self.silent:2442print("Tag%sdoes not match with change%s: file count is different."2443% (labelDetails["label"], change))24442445# Build a dictionary of changelists and labels, for "detect-labels" option.2446defgetLabels(self):2447 self.labels = {}24482449 l =p4CmdList(["labels"] + ["%s..."% p for p in self.depotPaths])2450iflen(l) >0and not self.silent:2451print"Finding files belonging to labels in%s"% `self.depotPaths`24522453for output in l:2454 label = output["label"]2455 revisions = {}2456 newestChange =02457if self.verbose:2458print"Querying files for label%s"% label2459forfileinp4CmdList(["files"] +2460["%s...@%s"% (p, label)2461for p in self.depotPaths]):2462 revisions[file["depotFile"]] =file["rev"]2463 change =int(file["change"])2464if change > newestChange:2465 newestChange = change24662467 self.labels[newestChange] = [output, revisions]24682469if self.verbose:2470print"Label changes:%s"% self.labels.keys()24712472# Import p4 labels as git tags. A direct mapping does not2473# exist, so assume that if all the files are at the same revision2474# then we can use that, or it's something more complicated we should2475# just ignore.2476defimportP4Labels(self, stream, p4Labels):2477if verbose:2478print"import p4 labels: "+' '.join(p4Labels)24792480 ignoredP4Labels =gitConfigList("git-p4.ignoredP4Labels")2481 validLabelRegexp =gitConfig("git-p4.labelImportRegexp")2482iflen(validLabelRegexp) ==0:2483 validLabelRegexp = defaultLabelRegexp2484 m = re.compile(validLabelRegexp)24852486for name in p4Labels:2487 commitFound =False24882489if not m.match(name):2490if verbose:2491print"label%sdoes not match regexp%s"% (name,validLabelRegexp)2492continue24932494if name in ignoredP4Labels:2495continue24962497 labelDetails =p4CmdList(['label',"-o", name])[0]24982499# get the most recent changelist for each file in this label2500 change =p4Cmd(["changes","-m","1"] + ["%s...@%s"% (p, name)2501for p in self.depotPaths])25022503if change.has_key('change'):2504# find the corresponding git commit; take the oldest commit2505 changelist =int(change['change'])2506 gitCommit =read_pipe(["git","rev-list","--max-count=1",2507"--reverse",":/\[git-p4:.*change =%d\]"% changelist])2508iflen(gitCommit) ==0:2509print"could not find git commit for changelist%d"% changelist2510else:2511 gitCommit = gitCommit.strip()2512 commitFound =True2513# Convert from p4 time format2514try:2515 tmwhen = time.strptime(labelDetails['Update'],"%Y/%m/%d%H:%M:%S")2516exceptValueError:2517print"Could not convert label time%s"% labelDetails['Update']2518 tmwhen =125192520 when =int(time.mktime(tmwhen))2521 self.streamTag(stream, name, labelDetails, gitCommit, when)2522if verbose:2523print"p4 label%smapped to git commit%s"% (name, gitCommit)2524else:2525if verbose:2526print"Label%shas no changelists - possibly deleted?"% name25272528if not commitFound:2529# We can't import this label; don't try again as it will get very2530# expensive repeatedly fetching all the files for labels that will2531# never be imported. If the label is moved in the future, the2532# ignore will need to be removed manually.2533system(["git","config","--add","git-p4.ignoredP4Labels", name])25342535defguessProjectName(self):2536for p in self.depotPaths:2537if p.endswith("/"):2538 p = p[:-1]2539 p = p[p.strip().rfind("/") +1:]2540if not p.endswith("/"):2541 p +="/"2542return p25432544defgetBranchMapping(self):2545 lostAndFoundBranches =set()25462547 user =gitConfig("git-p4.branchUser")2548iflen(user) >0:2549 command ="branches -u%s"% user2550else:2551 command ="branches"25522553for info inp4CmdList(command):2554 details =p4Cmd(["branch","-o", info["branch"]])2555 viewIdx =02556while details.has_key("View%s"% viewIdx):2557 paths = details["View%s"% viewIdx].split(" ")2558 viewIdx = viewIdx +12559# require standard //depot/foo/... //depot/bar/... mapping2560iflen(paths) !=2or not paths[0].endswith("/...")or not paths[1].endswith("/..."):2561continue2562 source = paths[0]2563 destination = paths[1]2564## HACK2565ifp4PathStartsWith(source, self.depotPaths[0])andp4PathStartsWith(destination, self.depotPaths[0]):2566 source = source[len(self.depotPaths[0]):-4]2567 destination = destination[len(self.depotPaths[0]):-4]25682569if destination in self.knownBranches:2570if not self.silent:2571print"p4 branch%sdefines a mapping from%sto%s"% (info["branch"], source, destination)2572print"but there exists another mapping from%sto%salready!"% (self.knownBranches[destination], destination)2573continue25742575 self.knownBranches[destination] = source25762577 lostAndFoundBranches.discard(destination)25782579if source not in self.knownBranches:2580 lostAndFoundBranches.add(source)25812582# Perforce does not strictly require branches to be defined, so we also2583# check git config for a branch list.2584#2585# Example of branch definition in git config file:2586# [git-p4]2587# branchList=main:branchA2588# branchList=main:branchB2589# branchList=branchA:branchC2590 configBranches =gitConfigList("git-p4.branchList")2591for branch in configBranches:2592if branch:2593(source, destination) = branch.split(":")2594 self.knownBranches[destination] = source25952596 lostAndFoundBranches.discard(destination)25972598if source not in self.knownBranches:2599 lostAndFoundBranches.add(source)260026012602for branch in lostAndFoundBranches:2603 self.knownBranches[branch] = branch26042605defgetBranchMappingFromGitBranches(self):2606 branches =p4BranchesInGit(self.importIntoRemotes)2607for branch in branches.keys():2608if branch =="master":2609 branch ="main"2610else:2611 branch = branch[len(self.projectName):]2612 self.knownBranches[branch] = branch26132614defupdateOptionDict(self, d):2615 option_keys = {}2616if self.keepRepoPath:2617 option_keys['keepRepoPath'] =126182619 d["options"] =' '.join(sorted(option_keys.keys()))26202621defreadOptions(self, d):2622 self.keepRepoPath = (d.has_key('options')2623and('keepRepoPath'in d['options']))26242625defgitRefForBranch(self, branch):2626if branch =="main":2627return self.refPrefix +"master"26282629iflen(branch) <=0:2630return branch26312632return self.refPrefix + self.projectName + branch26332634defgitCommitByP4Change(self, ref, change):2635if self.verbose:2636print"looking in ref "+ ref +" for change%susing bisect..."% change26372638 earliestCommit =""2639 latestCommit =parseRevision(ref)26402641while True:2642if self.verbose:2643print"trying: earliest%slatest%s"% (earliestCommit, latestCommit)2644 next =read_pipe("git rev-list --bisect%s %s"% (latestCommit, earliestCommit)).strip()2645iflen(next) ==0:2646if self.verbose:2647print"argh"2648return""2649 log =extractLogMessageFromGitCommit(next)2650 settings =extractSettingsGitLog(log)2651 currentChange =int(settings['change'])2652if self.verbose:2653print"current change%s"% currentChange26542655if currentChange == change:2656if self.verbose:2657print"found%s"% next2658return next26592660if currentChange < change:2661 earliestCommit ="^%s"% next2662else:2663 latestCommit ="%s"% next26642665return""26662667defimportNewBranch(self, branch, maxChange):2668# make fast-import flush all changes to disk and update the refs using the checkpoint2669# command so that we can try to find the branch parent in the git history2670 self.gitStream.write("checkpoint\n\n");2671 self.gitStream.flush();2672 branchPrefix = self.depotPaths[0] + branch +"/"2673range="@1,%s"% maxChange2674#print "prefix" + branchPrefix2675 changes =p4ChangesForPaths([branchPrefix],range, self.changes_block_size)2676iflen(changes) <=0:2677return False2678 firstChange = changes[0]2679#print "first change in branch: %s" % firstChange2680 sourceBranch = self.knownBranches[branch]2681 sourceDepotPath = self.depotPaths[0] + sourceBranch2682 sourceRef = self.gitRefForBranch(sourceBranch)2683#print "source " + sourceBranch26842685 branchParentChange =int(p4Cmd(["changes","-m","1","%s...@1,%s"% (sourceDepotPath, firstChange)])["change"])2686#print "branch parent: %s" % branchParentChange2687 gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)2688iflen(gitParent) >0:2689 self.initialParents[self.gitRefForBranch(branch)] = gitParent2690#print "parent git commit: %s" % gitParent26912692 self.importChanges(changes)2693return True26942695defsearchParent(self, parent, branch, target):2696 parentFound =False2697for blob inread_pipe_lines(["git","rev-list","--reverse",2698"--no-merges", parent]):2699 blob = blob.strip()2700iflen(read_pipe(["git","diff-tree", blob, target])) ==0:2701 parentFound =True2702if self.verbose:2703print"Found parent of%sin commit%s"% (branch, blob)2704break2705if parentFound:2706return blob2707else:2708return None27092710defimportChanges(self, changes):2711 cnt =12712for change in changes:2713 description =p4_describe(change)2714 self.updateOptionDict(description)27152716if not self.silent:2717 sys.stdout.write("\rImporting revision%s(%s%%)"% (change, cnt *100/len(changes)))2718 sys.stdout.flush()2719 cnt = cnt +127202721try:2722if self.detectBranches:2723 branches = self.splitFilesIntoBranches(description)2724for branch in branches.keys():2725## HACK --hwn2726 branchPrefix = self.depotPaths[0] + branch +"/"2727 self.branchPrefixes = [ branchPrefix ]27282729 parent =""27302731 filesForCommit = branches[branch]27322733if self.verbose:2734print"branch is%s"% branch27352736 self.updatedBranches.add(branch)27372738if branch not in self.createdBranches:2739 self.createdBranches.add(branch)2740 parent = self.knownBranches[branch]2741if parent == branch:2742 parent =""2743else:2744 fullBranch = self.projectName + branch2745if fullBranch not in self.p4BranchesInGit:2746if not self.silent:2747print("\nImporting new branch%s"% fullBranch);2748if self.importNewBranch(branch, change -1):2749 parent =""2750 self.p4BranchesInGit.append(fullBranch)2751if not self.silent:2752print("\nResuming with change%s"% change);27532754if self.verbose:2755print"parent determined through known branches:%s"% parent27562757 branch = self.gitRefForBranch(branch)2758 parent = self.gitRefForBranch(parent)27592760if self.verbose:2761print"looking for initial parent for%s; current parent is%s"% (branch, parent)27622763iflen(parent) ==0and branch in self.initialParents:2764 parent = self.initialParents[branch]2765del self.initialParents[branch]27662767 blob =None2768iflen(parent) >0:2769 tempBranch ="%s/%d"% (self.tempBranchLocation, change)2770if self.verbose:2771print"Creating temporary branch: "+ tempBranch2772 self.commit(description, filesForCommit, tempBranch)2773 self.tempBranches.append(tempBranch)2774 self.checkpoint()2775 blob = self.searchParent(parent, branch, tempBranch)2776if blob:2777 self.commit(description, filesForCommit, branch, blob)2778else:2779if self.verbose:2780print"Parent of%snot found. Committing into head of%s"% (branch, parent)2781 self.commit(description, filesForCommit, branch, parent)2782else:2783 files = self.extractFilesFromCommit(description)2784 self.commit(description, files, self.branch,2785 self.initialParent)2786# only needed once, to connect to the previous commit2787 self.initialParent =""2788exceptIOError:2789print self.gitError.read()2790 sys.exit(1)27912792defimportHeadRevision(self, revision):2793print"Doing initial import of%sfrom revision%sinto%s"% (' '.join(self.depotPaths), revision, self.branch)27942795 details = {}2796 details["user"] ="git perforce import user"2797 details["desc"] = ("Initial import of%sfrom the state at revision%s\n"2798% (' '.join(self.depotPaths), revision))2799 details["change"] = revision2800 newestRevision =028012802 fileCnt =02803 fileArgs = ["%s...%s"% (p,revision)for p in self.depotPaths]28042805for info inp4CmdList(["files"] + fileArgs):28062807if'code'in info and info['code'] =='error':2808 sys.stderr.write("p4 returned an error:%s\n"2809% info['data'])2810if info['data'].find("must refer to client") >=0:2811 sys.stderr.write("This particular p4 error is misleading.\n")2812 sys.stderr.write("Perhaps the depot path was misspelled.\n");2813 sys.stderr.write("Depot path:%s\n"%" ".join(self.depotPaths))2814 sys.exit(1)2815if'p4ExitCode'in info:2816 sys.stderr.write("p4 exitcode:%s\n"% info['p4ExitCode'])2817 sys.exit(1)281828192820 change =int(info["change"])2821if change > newestRevision:2822 newestRevision = change28232824if info["action"]in self.delete_actions:2825# don't increase the file cnt, otherwise details["depotFile123"] will have gaps!2826#fileCnt = fileCnt + 12827continue28282829for prop in["depotFile","rev","action","type"]:2830 details["%s%s"% (prop, fileCnt)] = info[prop]28312832 fileCnt = fileCnt +128332834 details["change"] = newestRevision28352836# Use time from top-most change so that all git p4 clones of2837# the same p4 repo have the same commit SHA1s.2838 res =p4_describe(newestRevision)2839 details["time"] = res["time"]28402841 self.updateOptionDict(details)2842try:2843 self.commit(details, self.extractFilesFromCommit(details), self.branch)2844exceptIOError:2845print"IO error with git fast-import. Is your git version recent enough?"2846print self.gitError.read()284728482849defrun(self, args):2850 self.depotPaths = []2851 self.changeRange =""2852 self.previousDepotPaths = []2853 self.hasOrigin =False28542855# map from branch depot path to parent branch2856 self.knownBranches = {}2857 self.initialParents = {}28582859if self.importIntoRemotes:2860 self.refPrefix ="refs/remotes/p4/"2861else:2862 self.refPrefix ="refs/heads/p4/"28632864if self.syncWithOrigin:2865 self.hasOrigin =originP4BranchesExist()2866if self.hasOrigin:2867if not self.silent:2868print'Syncing with origin first, using "git fetch origin"'2869system("git fetch origin")28702871 branch_arg_given =bool(self.branch)2872iflen(self.branch) ==0:2873 self.branch = self.refPrefix +"master"2874ifgitBranchExists("refs/heads/p4")and self.importIntoRemotes:2875system("git update-ref%srefs/heads/p4"% self.branch)2876system("git branch -D p4")28772878# accept either the command-line option, or the configuration variable2879if self.useClientSpec:2880# will use this after clone to set the variable2881 self.useClientSpec_from_options =True2882else:2883ifgitConfigBool("git-p4.useclientspec"):2884 self.useClientSpec =True2885if self.useClientSpec:2886 self.clientSpecDirs =getClientSpec()28872888# TODO: should always look at previous commits,2889# merge with previous imports, if possible.2890if args == []:2891if self.hasOrigin:2892createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)28932894# branches holds mapping from branch name to sha12895 branches =p4BranchesInGit(self.importIntoRemotes)28962897# restrict to just this one, disabling detect-branches2898if branch_arg_given:2899 short = self.branch.split("/")[-1]2900if short in branches:2901 self.p4BranchesInGit = [ short ]2902else:2903 self.p4BranchesInGit = branches.keys()29042905iflen(self.p4BranchesInGit) >1:2906if not self.silent:2907print"Importing from/into multiple branches"2908 self.detectBranches =True2909for branch in branches.keys():2910 self.initialParents[self.refPrefix + branch] = \2911 branches[branch]29122913if self.verbose:2914print"branches:%s"% self.p4BranchesInGit29152916 p4Change =02917for branch in self.p4BranchesInGit:2918 logMsg =extractLogMessageFromGitCommit(self.refPrefix + branch)29192920 settings =extractSettingsGitLog(logMsg)29212922 self.readOptions(settings)2923if(settings.has_key('depot-paths')2924and settings.has_key('change')):2925 change =int(settings['change']) +12926 p4Change =max(p4Change, change)29272928 depotPaths =sorted(settings['depot-paths'])2929if self.previousDepotPaths == []:2930 self.previousDepotPaths = depotPaths2931else:2932 paths = []2933for(prev, cur)inzip(self.previousDepotPaths, depotPaths):2934 prev_list = prev.split("/")2935 cur_list = cur.split("/")2936for i inrange(0,min(len(cur_list),len(prev_list))):2937if cur_list[i] <> prev_list[i]:2938 i = i -12939break29402941 paths.append("/".join(cur_list[:i +1]))29422943 self.previousDepotPaths = paths29442945if p4Change >0:2946 self.depotPaths =sorted(self.previousDepotPaths)2947 self.changeRange ="@%s,#head"% p4Change2948if not self.silent and not self.detectBranches:2949print"Performing incremental import into%sgit branch"% self.branch29502951# accept multiple ref name abbreviations:2952# refs/foo/bar/branch -> use it exactly2953# p4/branch -> prepend refs/remotes/ or refs/heads/2954# branch -> prepend refs/remotes/p4/ or refs/heads/p4/2955if not self.branch.startswith("refs/"):2956if self.importIntoRemotes:2957 prepend ="refs/remotes/"2958else:2959 prepend ="refs/heads/"2960if not self.branch.startswith("p4/"):2961 prepend +="p4/"2962 self.branch = prepend + self.branch29632964iflen(args) ==0and self.depotPaths:2965if not self.silent:2966print"Depot paths:%s"%' '.join(self.depotPaths)2967else:2968if self.depotPaths and self.depotPaths != args:2969print("previous import used depot path%sand now%swas specified. "2970"This doesn't work!"% (' '.join(self.depotPaths),2971' '.join(args)))2972 sys.exit(1)29732974 self.depotPaths =sorted(args)29752976 revision =""2977 self.users = {}29782979# Make sure no revision specifiers are used when --changesfile2980# is specified.2981 bad_changesfile =False2982iflen(self.changesFile) >0:2983for p in self.depotPaths:2984if p.find("@") >=0or p.find("#") >=0:2985 bad_changesfile =True2986break2987if bad_changesfile:2988die("Option --changesfile is incompatible with revision specifiers")29892990 newPaths = []2991for p in self.depotPaths:2992if p.find("@") != -1:2993 atIdx = p.index("@")2994 self.changeRange = p[atIdx:]2995if self.changeRange =="@all":2996 self.changeRange =""2997elif','not in self.changeRange:2998 revision = self.changeRange2999 self.changeRange =""3000 p = p[:atIdx]3001elif p.find("#") != -1:3002 hashIdx = p.index("#")3003 revision = p[hashIdx:]3004 p = p[:hashIdx]3005elif self.previousDepotPaths == []:3006# pay attention to changesfile, if given, else import3007# the entire p4 tree at the head revision3008iflen(self.changesFile) ==0:3009 revision ="#head"30103011 p = re.sub("\.\.\.$","", p)3012if not p.endswith("/"):3013 p +="/"30143015 newPaths.append(p)30163017 self.depotPaths = newPaths30183019# --detect-branches may change this for each branch3020 self.branchPrefixes = self.depotPaths30213022 self.loadUserMapFromCache()3023 self.labels = {}3024if self.detectLabels:3025 self.getLabels();30263027if self.detectBranches:3028## FIXME - what's a P4 projectName ?3029 self.projectName = self.guessProjectName()30303031if self.hasOrigin:3032 self.getBranchMappingFromGitBranches()3033else:3034 self.getBranchMapping()3035if self.verbose:3036print"p4-git branches:%s"% self.p4BranchesInGit3037print"initial parents:%s"% self.initialParents3038for b in self.p4BranchesInGit:3039if b !="master":30403041## FIXME3042 b = b[len(self.projectName):]3043 self.createdBranches.add(b)30443045 self.tz ="%+03d%02d"% (- time.timezone /3600, ((- time.timezone %3600) /60))30463047 self.importProcess = subprocess.Popen(["git","fast-import"],3048 stdin=subprocess.PIPE,3049 stdout=subprocess.PIPE,3050 stderr=subprocess.PIPE);3051 self.gitOutput = self.importProcess.stdout3052 self.gitStream = self.importProcess.stdin3053 self.gitError = self.importProcess.stderr30543055if revision:3056 self.importHeadRevision(revision)3057else:3058 changes = []30593060iflen(self.changesFile) >0:3061 output =open(self.changesFile).readlines()3062 changeSet =set()3063for line in output:3064 changeSet.add(int(line))30653066for change in changeSet:3067 changes.append(change)30683069 changes.sort()3070else:3071# catch "git p4 sync" with no new branches, in a repo that3072# does not have any existing p4 branches3073iflen(args) ==0:3074if not self.p4BranchesInGit:3075die("No remote p4 branches. Perhaps you never did\"git p4 clone\"in here.")30763077# The default branch is master, unless --branch is used to3078# specify something else. Make sure it exists, or complain3079# nicely about how to use --branch.3080if not self.detectBranches:3081if notbranch_exists(self.branch):3082if branch_arg_given:3083die("Error: branch%sdoes not exist."% self.branch)3084else:3085die("Error: no branch%s; perhaps specify one with --branch."%3086 self.branch)30873088if self.verbose:3089print"Getting p4 changes for%s...%s"% (', '.join(self.depotPaths),3090 self.changeRange)3091 changes =p4ChangesForPaths(self.depotPaths, self.changeRange, self.changes_block_size)30923093iflen(self.maxChanges) >0:3094 changes = changes[:min(int(self.maxChanges),len(changes))]30953096iflen(changes) ==0:3097if not self.silent:3098print"No changes to import!"3099else:3100if not self.silent and not self.detectBranches:3101print"Import destination:%s"% self.branch31023103 self.updatedBranches =set()31043105if not self.detectBranches:3106if args:3107# start a new branch3108 self.initialParent =""3109else:3110# build on a previous revision3111 self.initialParent =parseRevision(self.branch)31123113 self.importChanges(changes)31143115if not self.silent:3116print""3117iflen(self.updatedBranches) >0:3118 sys.stdout.write("Updated branches: ")3119for b in self.updatedBranches:3120 sys.stdout.write("%s"% b)3121 sys.stdout.write("\n")31223123ifgitConfigBool("git-p4.importLabels"):3124 self.importLabels =True31253126if self.importLabels:3127 p4Labels =getP4Labels(self.depotPaths)3128 gitTags =getGitTags()31293130 missingP4Labels = p4Labels - gitTags3131 self.importP4Labels(self.gitStream, missingP4Labels)31323133 self.gitStream.close()3134if self.importProcess.wait() !=0:3135die("fast-import failed:%s"% self.gitError.read())3136 self.gitOutput.close()3137 self.gitError.close()31383139# Cleanup temporary branches created during import3140if self.tempBranches != []:3141for branch in self.tempBranches:3142read_pipe("git update-ref -d%s"% branch)3143 os.rmdir(os.path.join(os.environ.get("GIT_DIR",".git"), self.tempBranchLocation))31443145# Create a symbolic ref p4/HEAD pointing to p4/<branch> to allow3146# a convenient shortcut refname "p4".3147if self.importIntoRemotes:3148 head_ref = self.refPrefix +"HEAD"3149if notgitBranchExists(head_ref)andgitBranchExists(self.branch):3150system(["git","symbolic-ref", head_ref, self.branch])31513152return True31533154classP4Rebase(Command):3155def__init__(self):3156 Command.__init__(self)3157 self.options = [3158 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),3159]3160 self.importLabels =False3161 self.description = ("Fetches the latest revision from perforce and "3162+"rebases the current work (branch) against it")31633164defrun(self, args):3165 sync =P4Sync()3166 sync.importLabels = self.importLabels3167 sync.run([])31683169return self.rebase()31703171defrebase(self):3172if os.system("git update-index --refresh") !=0:3173die("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.");3174iflen(read_pipe("git diff-index HEAD --")) >0:3175die("You have uncommitted changes. Please commit them before rebasing or stash them away with git stash.");31763177[upstream, settings] =findUpstreamBranchPoint()3178iflen(upstream) ==0:3179die("Cannot find upstream branchpoint for rebase")31803181# the branchpoint may be p4/foo~3, so strip off the parent3182 upstream = re.sub("~[0-9]+$","", upstream)31833184print"Rebasing the current branch onto%s"% upstream3185 oldHead =read_pipe("git rev-parse HEAD").strip()3186system("git rebase%s"% upstream)3187system("git diff-tree --stat --summary -M%sHEAD --"% oldHead)3188return True31893190classP4Clone(P4Sync):3191def__init__(self):3192 P4Sync.__init__(self)3193 self.description ="Creates a new git repository and imports from Perforce into it"3194 self.usage ="usage: %prog [options] //depot/path[@revRange]"3195 self.options += [3196 optparse.make_option("--destination", dest="cloneDestination",3197 action='store', default=None,3198help="where to leave result of the clone"),3199 optparse.make_option("--bare", dest="cloneBare",3200 action="store_true", default=False),3201]3202 self.cloneDestination =None3203 self.needsGit =False3204 self.cloneBare =False32053206defdefaultDestination(self, args):3207## TODO: use common prefix of args?3208 depotPath = args[0]3209 depotDir = re.sub("(@[^@]*)$","", depotPath)3210 depotDir = re.sub("(#[^#]*)$","", depotDir)3211 depotDir = re.sub(r"\.\.\.$","", depotDir)3212 depotDir = re.sub(r"/$","", depotDir)3213return os.path.split(depotDir)[1]32143215defrun(self, args):3216iflen(args) <1:3217return False32183219if self.keepRepoPath and not self.cloneDestination:3220 sys.stderr.write("Must specify destination for --keep-path\n")3221 sys.exit(1)32223223 depotPaths = args32243225if not self.cloneDestination andlen(depotPaths) >1:3226 self.cloneDestination = depotPaths[-1]3227 depotPaths = depotPaths[:-1]32283229 self.cloneExclude = ["/"+p for p in self.cloneExclude]3230for p in depotPaths:3231if not p.startswith("//"):3232 sys.stderr.write('Depot paths must start with "//":%s\n'% p)3233return False32343235if not self.cloneDestination:3236 self.cloneDestination = self.defaultDestination(args)32373238print"Importing from%sinto%s"% (', '.join(depotPaths), self.cloneDestination)32393240if not os.path.exists(self.cloneDestination):3241 os.makedirs(self.cloneDestination)3242chdir(self.cloneDestination)32433244 init_cmd = ["git","init"]3245if self.cloneBare:3246 init_cmd.append("--bare")3247 retcode = subprocess.call(init_cmd)3248if retcode:3249raiseCalledProcessError(retcode, init_cmd)32503251if not P4Sync.run(self, depotPaths):3252return False32533254# create a master branch and check out a work tree3255ifgitBranchExists(self.branch):3256system(["git","branch","master", self.branch ])3257if not self.cloneBare:3258system(["git","checkout","-f"])3259else:3260print'Not checking out any branch, use ' \3261'"git checkout -q -b master <branch>"'32623263# auto-set this variable if invoked with --use-client-spec3264if self.useClientSpec_from_options:3265system("git config --bool git-p4.useclientspec true")32663267return True32683269classP4Branches(Command):3270def__init__(self):3271 Command.__init__(self)3272 self.options = [ ]3273 self.description = ("Shows the git branches that hold imports and their "3274+"corresponding perforce depot paths")3275 self.verbose =False32763277defrun(self, args):3278iforiginP4BranchesExist():3279createOrUpdateBranchesFromOrigin()32803281 cmdline ="git rev-parse --symbolic "3282 cmdline +=" --remotes"32833284for line inread_pipe_lines(cmdline):3285 line = line.strip()32863287if not line.startswith('p4/')or line =="p4/HEAD":3288continue3289 branch = line32903291 log =extractLogMessageFromGitCommit("refs/remotes/%s"% branch)3292 settings =extractSettingsGitLog(log)32933294print"%s<=%s(%s)"% (branch,",".join(settings["depot-paths"]), settings["change"])3295return True32963297classHelpFormatter(optparse.IndentedHelpFormatter):3298def__init__(self):3299 optparse.IndentedHelpFormatter.__init__(self)33003301defformat_description(self, description):3302if description:3303return description +"\n"3304else:3305return""33063307defprintUsage(commands):3308print"usage:%s<command> [options]"% sys.argv[0]3309print""3310print"valid commands:%s"%", ".join(commands)3311print""3312print"Try%s<command> --help for command specific help."% sys.argv[0]3313print""33143315commands = {3316"debug": P4Debug,3317"submit": P4Submit,3318"commit": P4Submit,3319"sync": P4Sync,3320"rebase": P4Rebase,3321"clone": P4Clone,3322"rollback": P4RollBack,3323"branches": P4Branches3324}332533263327defmain():3328iflen(sys.argv[1:]) ==0:3329printUsage(commands.keys())3330 sys.exit(2)33313332 cmdName = sys.argv[1]3333try:3334 klass = commands[cmdName]3335 cmd =klass()3336exceptKeyError:3337print"unknown command%s"% cmdName3338print""3339printUsage(commands.keys())3340 sys.exit(2)33413342 options = cmd.options3343 cmd.gitdir = os.environ.get("GIT_DIR",None)33443345 args = sys.argv[2:]33463347 options.append(optparse.make_option("--verbose","-v", dest="verbose", action="store_true"))3348if cmd.needsGit:3349 options.append(optparse.make_option("--git-dir", dest="gitdir"))33503351 parser = optparse.OptionParser(cmd.usage.replace("%prog","%prog "+ cmdName),3352 options,3353 description = cmd.description,3354 formatter =HelpFormatter())33553356(cmd, args) = parser.parse_args(sys.argv[2:], cmd);3357global verbose3358 verbose = cmd.verbose3359if cmd.needsGit:3360if cmd.gitdir ==None:3361 cmd.gitdir = os.path.abspath(".git")3362if notisValidGitDir(cmd.gitdir):3363 cmd.gitdir =read_pipe("git rev-parse --git-dir").strip()3364if os.path.exists(cmd.gitdir):3365 cdup =read_pipe("git rev-parse --show-cdup").strip()3366iflen(cdup) >0:3367chdir(cdup);33683369if notisValidGitDir(cmd.gitdir):3370ifisValidGitDir(cmd.gitdir +"/.git"):3371 cmd.gitdir +="/.git"3372else:3373die("fatal: cannot locate git repository at%s"% cmd.gitdir)33743375 os.environ["GIT_DIR"] = cmd.gitdir33763377if not cmd.run(args):3378 parser.print_help()3379 sys.exit(2)338033813382if __name__ =='__main__':3383main()