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 ]22152216 self.gitStream.write("M%sinline%s\n"% (git_mode, relPath))22172218# total length...2219 length =02220for d in contents:2221 length = length +len(d)22222223 self.gitStream.write("data%d\n"% length)2224for d in contents:2225 self.gitStream.write(d)2226 self.gitStream.write("\n")22272228defstreamOneP4Deletion(self,file):2229 relPath = self.stripRepoPath(file['path'], self.branchPrefixes)2230if verbose:2231 sys.stderr.write("delete%s\n"% relPath)2232 self.gitStream.write("D%s\n"% relPath)22332234# handle another chunk of streaming data2235defstreamP4FilesCb(self, marshalled):22362237# catch p4 errors and complain2238 err =None2239if"code"in marshalled:2240if marshalled["code"] =="error":2241if"data"in marshalled:2242 err = marshalled["data"].rstrip()2243if err:2244 f =None2245if self.stream_have_file_info:2246if"depotFile"in self.stream_file:2247 f = self.stream_file["depotFile"]2248# force a failure in fast-import, else an empty2249# commit will be made2250 self.gitStream.write("\n")2251 self.gitStream.write("die-now\n")2252 self.gitStream.close()2253# ignore errors, but make sure it exits first2254 self.importProcess.wait()2255if f:2256die("Error from p4 print for%s:%s"% (f, err))2257else:2258die("Error from p4 print:%s"% err)22592260if marshalled.has_key('depotFile')and self.stream_have_file_info:2261# start of a new file - output the old one first2262 self.streamOneP4File(self.stream_file, self.stream_contents)2263 self.stream_file = {}2264 self.stream_contents = []2265 self.stream_have_file_info =False22662267# pick up the new file information... for the2268# 'data' field we need to append to our array2269for k in marshalled.keys():2270if k =='data':2271 self.stream_contents.append(marshalled['data'])2272else:2273 self.stream_file[k] = marshalled[k]22742275 self.stream_have_file_info =True22762277# Stream directly from "p4 files" into "git fast-import"2278defstreamP4Files(self, files):2279 filesForCommit = []2280 filesToRead = []2281 filesToDelete = []22822283for f in files:2284# if using a client spec, only add the files that have2285# a path in the client2286if self.clientSpecDirs:2287if self.clientSpecDirs.map_in_client(f['path']) =="":2288continue22892290 filesForCommit.append(f)2291if f['action']in self.delete_actions:2292 filesToDelete.append(f)2293else:2294 filesToRead.append(f)22952296# deleted files...2297for f in filesToDelete:2298 self.streamOneP4Deletion(f)22992300iflen(filesToRead) >0:2301 self.stream_file = {}2302 self.stream_contents = []2303 self.stream_have_file_info =False23042305# curry self argument2306defstreamP4FilesCbSelf(entry):2307 self.streamP4FilesCb(entry)23082309 fileArgs = ['%s#%s'% (f['path'], f['rev'])for f in filesToRead]23102311p4CmdList(["-x","-","print"],2312 stdin=fileArgs,2313 cb=streamP4FilesCbSelf)23142315# do the last chunk2316if self.stream_file.has_key('depotFile'):2317 self.streamOneP4File(self.stream_file, self.stream_contents)23182319defmake_email(self, userid):2320if userid in self.users:2321return self.users[userid]2322else:2323return"%s<a@b>"% userid23242325# Stream a p4 tag2326defstreamTag(self, gitStream, labelName, labelDetails, commit, epoch):2327if verbose:2328print"writing tag%sfor commit%s"% (labelName, commit)2329 gitStream.write("tag%s\n"% labelName)2330 gitStream.write("from%s\n"% commit)23312332if labelDetails.has_key('Owner'):2333 owner = labelDetails["Owner"]2334else:2335 owner =None23362337# Try to use the owner of the p4 label, or failing that,2338# the current p4 user id.2339if owner:2340 email = self.make_email(owner)2341else:2342 email = self.make_email(self.p4UserId())2343 tagger ="%s %s %s"% (email, epoch, self.tz)23442345 gitStream.write("tagger%s\n"% tagger)23462347print"labelDetails=",labelDetails2348if labelDetails.has_key('Description'):2349 description = labelDetails['Description']2350else:2351 description ='Label from git p4'23522353 gitStream.write("data%d\n"%len(description))2354 gitStream.write(description)2355 gitStream.write("\n")23562357defcommit(self, details, files, branch, parent =""):2358 epoch = details["time"]2359 author = details["user"]23602361if self.verbose:2362print"commit into%s"% branch23632364# start with reading files; if that fails, we should not2365# create a commit.2366 new_files = []2367for f in files:2368if[p for p in self.branchPrefixes ifp4PathStartsWith(f['path'], p)]:2369 new_files.append(f)2370else:2371 sys.stderr.write("Ignoring file outside of prefix:%s\n"% f['path'])23722373if self.clientSpecDirs:2374 self.clientSpecDirs.update_client_spec_path_cache(files)23752376 self.gitStream.write("commit%s\n"% branch)2377# gitStream.write("mark :%s\n" % details["change"])2378 self.committedChanges.add(int(details["change"]))2379 committer =""2380if author not in self.users:2381 self.getUserMapFromPerforceServer()2382 committer ="%s %s %s"% (self.make_email(author), epoch, self.tz)23832384 self.gitStream.write("committer%s\n"% committer)23852386 self.gitStream.write("data <<EOT\n")2387 self.gitStream.write(details["desc"])2388 self.gitStream.write("\n[git-p4: depot-paths =\"%s\": change =%s"%2389(','.join(self.branchPrefixes), details["change"]))2390iflen(details['options']) >0:2391 self.gitStream.write(": options =%s"% details['options'])2392 self.gitStream.write("]\nEOT\n\n")23932394iflen(parent) >0:2395if self.verbose:2396print"parent%s"% parent2397 self.gitStream.write("from%s\n"% parent)23982399 self.streamP4Files(new_files)2400 self.gitStream.write("\n")24012402 change =int(details["change"])24032404if self.labels.has_key(change):2405 label = self.labels[change]2406 labelDetails = label[0]2407 labelRevisions = label[1]2408if self.verbose:2409print"Change%sis labelled%s"% (change, labelDetails)24102411 files =p4CmdList(["files"] + ["%s...@%s"% (p, change)2412for p in self.branchPrefixes])24132414iflen(files) ==len(labelRevisions):24152416 cleanedFiles = {}2417for info in files:2418if info["action"]in self.delete_actions:2419continue2420 cleanedFiles[info["depotFile"]] = info["rev"]24212422if cleanedFiles == labelRevisions:2423 self.streamTag(self.gitStream,'tag_%s'% labelDetails['label'], labelDetails, branch, epoch)24242425else:2426if not self.silent:2427print("Tag%sdoes not match with change%s: files do not match."2428% (labelDetails["label"], change))24292430else:2431if not self.silent:2432print("Tag%sdoes not match with change%s: file count is different."2433% (labelDetails["label"], change))24342435# Build a dictionary of changelists and labels, for "detect-labels" option.2436defgetLabels(self):2437 self.labels = {}24382439 l =p4CmdList(["labels"] + ["%s..."% p for p in self.depotPaths])2440iflen(l) >0and not self.silent:2441print"Finding files belonging to labels in%s"% `self.depotPaths`24422443for output in l:2444 label = output["label"]2445 revisions = {}2446 newestChange =02447if self.verbose:2448print"Querying files for label%s"% label2449forfileinp4CmdList(["files"] +2450["%s...@%s"% (p, label)2451for p in self.depotPaths]):2452 revisions[file["depotFile"]] =file["rev"]2453 change =int(file["change"])2454if change > newestChange:2455 newestChange = change24562457 self.labels[newestChange] = [output, revisions]24582459if self.verbose:2460print"Label changes:%s"% self.labels.keys()24612462# Import p4 labels as git tags. A direct mapping does not2463# exist, so assume that if all the files are at the same revision2464# then we can use that, or it's something more complicated we should2465# just ignore.2466defimportP4Labels(self, stream, p4Labels):2467if verbose:2468print"import p4 labels: "+' '.join(p4Labels)24692470 ignoredP4Labels =gitConfigList("git-p4.ignoredP4Labels")2471 validLabelRegexp =gitConfig("git-p4.labelImportRegexp")2472iflen(validLabelRegexp) ==0:2473 validLabelRegexp = defaultLabelRegexp2474 m = re.compile(validLabelRegexp)24752476for name in p4Labels:2477 commitFound =False24782479if not m.match(name):2480if verbose:2481print"label%sdoes not match regexp%s"% (name,validLabelRegexp)2482continue24832484if name in ignoredP4Labels:2485continue24862487 labelDetails =p4CmdList(['label',"-o", name])[0]24882489# get the most recent changelist for each file in this label2490 change =p4Cmd(["changes","-m","1"] + ["%s...@%s"% (p, name)2491for p in self.depotPaths])24922493if change.has_key('change'):2494# find the corresponding git commit; take the oldest commit2495 changelist =int(change['change'])2496 gitCommit =read_pipe(["git","rev-list","--max-count=1",2497"--reverse",":/\[git-p4:.*change =%d\]"% changelist], ignore_error=True)2498iflen(gitCommit) ==0:2499print"importing label%s: could not find git commit for changelist%d"% (name, changelist)2500else:2501 gitCommit = gitCommit.strip()2502 commitFound =True2503# Convert from p4 time format2504try:2505 tmwhen = time.strptime(labelDetails['Update'],"%Y/%m/%d%H:%M:%S")2506exceptValueError:2507print"Could not convert label time%s"% labelDetails['Update']2508 tmwhen =125092510 when =int(time.mktime(tmwhen))2511 self.streamTag(stream, name, labelDetails, gitCommit, when)2512if verbose:2513print"p4 label%smapped to git commit%s"% (name, gitCommit)2514else:2515if verbose:2516print"Label%shas no changelists - possibly deleted?"% name25172518if not commitFound:2519# We can't import this label; don't try again as it will get very2520# expensive repeatedly fetching all the files for labels that will2521# never be imported. If the label is moved in the future, the2522# ignore will need to be removed manually.2523system(["git","config","--add","git-p4.ignoredP4Labels", name])25242525defguessProjectName(self):2526for p in self.depotPaths:2527if p.endswith("/"):2528 p = p[:-1]2529 p = p[p.strip().rfind("/") +1:]2530if not p.endswith("/"):2531 p +="/"2532return p25332534defgetBranchMapping(self):2535 lostAndFoundBranches =set()25362537 user =gitConfig("git-p4.branchUser")2538iflen(user) >0:2539 command ="branches -u%s"% user2540else:2541 command ="branches"25422543for info inp4CmdList(command):2544 details =p4Cmd(["branch","-o", info["branch"]])2545 viewIdx =02546while details.has_key("View%s"% viewIdx):2547 paths = details["View%s"% viewIdx].split(" ")2548 viewIdx = viewIdx +12549# require standard //depot/foo/... //depot/bar/... mapping2550iflen(paths) !=2or not paths[0].endswith("/...")or not paths[1].endswith("/..."):2551continue2552 source = paths[0]2553 destination = paths[1]2554## HACK2555ifp4PathStartsWith(source, self.depotPaths[0])andp4PathStartsWith(destination, self.depotPaths[0]):2556 source = source[len(self.depotPaths[0]):-4]2557 destination = destination[len(self.depotPaths[0]):-4]25582559if destination in self.knownBranches:2560if not self.silent:2561print"p4 branch%sdefines a mapping from%sto%s"% (info["branch"], source, destination)2562print"but there exists another mapping from%sto%salready!"% (self.knownBranches[destination], destination)2563continue25642565 self.knownBranches[destination] = source25662567 lostAndFoundBranches.discard(destination)25682569if source not in self.knownBranches:2570 lostAndFoundBranches.add(source)25712572# Perforce does not strictly require branches to be defined, so we also2573# check git config for a branch list.2574#2575# Example of branch definition in git config file:2576# [git-p4]2577# branchList=main:branchA2578# branchList=main:branchB2579# branchList=branchA:branchC2580 configBranches =gitConfigList("git-p4.branchList")2581for branch in configBranches:2582if branch:2583(source, destination) = branch.split(":")2584 self.knownBranches[destination] = source25852586 lostAndFoundBranches.discard(destination)25872588if source not in self.knownBranches:2589 lostAndFoundBranches.add(source)259025912592for branch in lostAndFoundBranches:2593 self.knownBranches[branch] = branch25942595defgetBranchMappingFromGitBranches(self):2596 branches =p4BranchesInGit(self.importIntoRemotes)2597for branch in branches.keys():2598if branch =="master":2599 branch ="main"2600else:2601 branch = branch[len(self.projectName):]2602 self.knownBranches[branch] = branch26032604defupdateOptionDict(self, d):2605 option_keys = {}2606if self.keepRepoPath:2607 option_keys['keepRepoPath'] =126082609 d["options"] =' '.join(sorted(option_keys.keys()))26102611defreadOptions(self, d):2612 self.keepRepoPath = (d.has_key('options')2613and('keepRepoPath'in d['options']))26142615defgitRefForBranch(self, branch):2616if branch =="main":2617return self.refPrefix +"master"26182619iflen(branch) <=0:2620return branch26212622return self.refPrefix + self.projectName + branch26232624defgitCommitByP4Change(self, ref, change):2625if self.verbose:2626print"looking in ref "+ ref +" for change%susing bisect..."% change26272628 earliestCommit =""2629 latestCommit =parseRevision(ref)26302631while True:2632if self.verbose:2633print"trying: earliest%slatest%s"% (earliestCommit, latestCommit)2634 next =read_pipe("git rev-list --bisect%s %s"% (latestCommit, earliestCommit)).strip()2635iflen(next) ==0:2636if self.verbose:2637print"argh"2638return""2639 log =extractLogMessageFromGitCommit(next)2640 settings =extractSettingsGitLog(log)2641 currentChange =int(settings['change'])2642if self.verbose:2643print"current change%s"% currentChange26442645if currentChange == change:2646if self.verbose:2647print"found%s"% next2648return next26492650if currentChange < change:2651 earliestCommit ="^%s"% next2652else:2653 latestCommit ="%s"% next26542655return""26562657defimportNewBranch(self, branch, maxChange):2658# make fast-import flush all changes to disk and update the refs using the checkpoint2659# command so that we can try to find the branch parent in the git history2660 self.gitStream.write("checkpoint\n\n");2661 self.gitStream.flush();2662 branchPrefix = self.depotPaths[0] + branch +"/"2663range="@1,%s"% maxChange2664#print "prefix" + branchPrefix2665 changes =p4ChangesForPaths([branchPrefix],range, self.changes_block_size)2666iflen(changes) <=0:2667return False2668 firstChange = changes[0]2669#print "first change in branch: %s" % firstChange2670 sourceBranch = self.knownBranches[branch]2671 sourceDepotPath = self.depotPaths[0] + sourceBranch2672 sourceRef = self.gitRefForBranch(sourceBranch)2673#print "source " + sourceBranch26742675 branchParentChange =int(p4Cmd(["changes","-m","1","%s...@1,%s"% (sourceDepotPath, firstChange)])["change"])2676#print "branch parent: %s" % branchParentChange2677 gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)2678iflen(gitParent) >0:2679 self.initialParents[self.gitRefForBranch(branch)] = gitParent2680#print "parent git commit: %s" % gitParent26812682 self.importChanges(changes)2683return True26842685defsearchParent(self, parent, branch, target):2686 parentFound =False2687for blob inread_pipe_lines(["git","rev-list","--reverse",2688"--no-merges", parent]):2689 blob = blob.strip()2690iflen(read_pipe(["git","diff-tree", blob, target])) ==0:2691 parentFound =True2692if self.verbose:2693print"Found parent of%sin commit%s"% (branch, blob)2694break2695if parentFound:2696return blob2697else:2698return None26992700defimportChanges(self, changes):2701 cnt =12702for change in changes:2703 description =p4_describe(change)2704 self.updateOptionDict(description)27052706if not self.silent:2707 sys.stdout.write("\rImporting revision%s(%s%%)"% (change, cnt *100/len(changes)))2708 sys.stdout.flush()2709 cnt = cnt +127102711try:2712if self.detectBranches:2713 branches = self.splitFilesIntoBranches(description)2714for branch in branches.keys():2715## HACK --hwn2716 branchPrefix = self.depotPaths[0] + branch +"/"2717 self.branchPrefixes = [ branchPrefix ]27182719 parent =""27202721 filesForCommit = branches[branch]27222723if self.verbose:2724print"branch is%s"% branch27252726 self.updatedBranches.add(branch)27272728if branch not in self.createdBranches:2729 self.createdBranches.add(branch)2730 parent = self.knownBranches[branch]2731if parent == branch:2732 parent =""2733else:2734 fullBranch = self.projectName + branch2735if fullBranch not in self.p4BranchesInGit:2736if not self.silent:2737print("\nImporting new branch%s"% fullBranch);2738if self.importNewBranch(branch, change -1):2739 parent =""2740 self.p4BranchesInGit.append(fullBranch)2741if not self.silent:2742print("\nResuming with change%s"% change);27432744if self.verbose:2745print"parent determined through known branches:%s"% parent27462747 branch = self.gitRefForBranch(branch)2748 parent = self.gitRefForBranch(parent)27492750if self.verbose:2751print"looking for initial parent for%s; current parent is%s"% (branch, parent)27522753iflen(parent) ==0and branch in self.initialParents:2754 parent = self.initialParents[branch]2755del self.initialParents[branch]27562757 blob =None2758iflen(parent) >0:2759 tempBranch ="%s/%d"% (self.tempBranchLocation, change)2760if self.verbose:2761print"Creating temporary branch: "+ tempBranch2762 self.commit(description, filesForCommit, tempBranch)2763 self.tempBranches.append(tempBranch)2764 self.checkpoint()2765 blob = self.searchParent(parent, branch, tempBranch)2766if blob:2767 self.commit(description, filesForCommit, branch, blob)2768else:2769if self.verbose:2770print"Parent of%snot found. Committing into head of%s"% (branch, parent)2771 self.commit(description, filesForCommit, branch, parent)2772else:2773 files = self.extractFilesFromCommit(description)2774 self.commit(description, files, self.branch,2775 self.initialParent)2776# only needed once, to connect to the previous commit2777 self.initialParent =""2778exceptIOError:2779print self.gitError.read()2780 sys.exit(1)27812782defimportHeadRevision(self, revision):2783print"Doing initial import of%sfrom revision%sinto%s"% (' '.join(self.depotPaths), revision, self.branch)27842785 details = {}2786 details["user"] ="git perforce import user"2787 details["desc"] = ("Initial import of%sfrom the state at revision%s\n"2788% (' '.join(self.depotPaths), revision))2789 details["change"] = revision2790 newestRevision =027912792 fileCnt =02793 fileArgs = ["%s...%s"% (p,revision)for p in self.depotPaths]27942795for info inp4CmdList(["files"] + fileArgs):27962797if'code'in info and info['code'] =='error':2798 sys.stderr.write("p4 returned an error:%s\n"2799% info['data'])2800if info['data'].find("must refer to client") >=0:2801 sys.stderr.write("This particular p4 error is misleading.\n")2802 sys.stderr.write("Perhaps the depot path was misspelled.\n");2803 sys.stderr.write("Depot path:%s\n"%" ".join(self.depotPaths))2804 sys.exit(1)2805if'p4ExitCode'in info:2806 sys.stderr.write("p4 exitcode:%s\n"% info['p4ExitCode'])2807 sys.exit(1)280828092810 change =int(info["change"])2811if change > newestRevision:2812 newestRevision = change28132814if info["action"]in self.delete_actions:2815# don't increase the file cnt, otherwise details["depotFile123"] will have gaps!2816#fileCnt = fileCnt + 12817continue28182819for prop in["depotFile","rev","action","type"]:2820 details["%s%s"% (prop, fileCnt)] = info[prop]28212822 fileCnt = fileCnt +128232824 details["change"] = newestRevision28252826# Use time from top-most change so that all git p4 clones of2827# the same p4 repo have the same commit SHA1s.2828 res =p4_describe(newestRevision)2829 details["time"] = res["time"]28302831 self.updateOptionDict(details)2832try:2833 self.commit(details, self.extractFilesFromCommit(details), self.branch)2834exceptIOError:2835print"IO error with git fast-import. Is your git version recent enough?"2836print self.gitError.read()283728382839defrun(self, args):2840 self.depotPaths = []2841 self.changeRange =""2842 self.previousDepotPaths = []2843 self.hasOrigin =False28442845# map from branch depot path to parent branch2846 self.knownBranches = {}2847 self.initialParents = {}28482849if self.importIntoRemotes:2850 self.refPrefix ="refs/remotes/p4/"2851else:2852 self.refPrefix ="refs/heads/p4/"28532854if self.syncWithOrigin:2855 self.hasOrigin =originP4BranchesExist()2856if self.hasOrigin:2857if not self.silent:2858print'Syncing with origin first, using "git fetch origin"'2859system("git fetch origin")28602861 branch_arg_given =bool(self.branch)2862iflen(self.branch) ==0:2863 self.branch = self.refPrefix +"master"2864ifgitBranchExists("refs/heads/p4")and self.importIntoRemotes:2865system("git update-ref%srefs/heads/p4"% self.branch)2866system("git branch -D p4")28672868# accept either the command-line option, or the configuration variable2869if self.useClientSpec:2870# will use this after clone to set the variable2871 self.useClientSpec_from_options =True2872else:2873ifgitConfigBool("git-p4.useclientspec"):2874 self.useClientSpec =True2875if self.useClientSpec:2876 self.clientSpecDirs =getClientSpec()28772878# TODO: should always look at previous commits,2879# merge with previous imports, if possible.2880if args == []:2881if self.hasOrigin:2882createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)28832884# branches holds mapping from branch name to sha12885 branches =p4BranchesInGit(self.importIntoRemotes)28862887# restrict to just this one, disabling detect-branches2888if branch_arg_given:2889 short = self.branch.split("/")[-1]2890if short in branches:2891 self.p4BranchesInGit = [ short ]2892else:2893 self.p4BranchesInGit = branches.keys()28942895iflen(self.p4BranchesInGit) >1:2896if not self.silent:2897print"Importing from/into multiple branches"2898 self.detectBranches =True2899for branch in branches.keys():2900 self.initialParents[self.refPrefix + branch] = \2901 branches[branch]29022903if self.verbose:2904print"branches:%s"% self.p4BranchesInGit29052906 p4Change =02907for branch in self.p4BranchesInGit:2908 logMsg =extractLogMessageFromGitCommit(self.refPrefix + branch)29092910 settings =extractSettingsGitLog(logMsg)29112912 self.readOptions(settings)2913if(settings.has_key('depot-paths')2914and settings.has_key('change')):2915 change =int(settings['change']) +12916 p4Change =max(p4Change, change)29172918 depotPaths =sorted(settings['depot-paths'])2919if self.previousDepotPaths == []:2920 self.previousDepotPaths = depotPaths2921else:2922 paths = []2923for(prev, cur)inzip(self.previousDepotPaths, depotPaths):2924 prev_list = prev.split("/")2925 cur_list = cur.split("/")2926for i inrange(0,min(len(cur_list),len(prev_list))):2927if cur_list[i] <> prev_list[i]:2928 i = i -12929break29302931 paths.append("/".join(cur_list[:i +1]))29322933 self.previousDepotPaths = paths29342935if p4Change >0:2936 self.depotPaths =sorted(self.previousDepotPaths)2937 self.changeRange ="@%s,#head"% p4Change2938if not self.silent and not self.detectBranches:2939print"Performing incremental import into%sgit branch"% self.branch29402941# accept multiple ref name abbreviations:2942# refs/foo/bar/branch -> use it exactly2943# p4/branch -> prepend refs/remotes/ or refs/heads/2944# branch -> prepend refs/remotes/p4/ or refs/heads/p4/2945if not self.branch.startswith("refs/"):2946if self.importIntoRemotes:2947 prepend ="refs/remotes/"2948else:2949 prepend ="refs/heads/"2950if not self.branch.startswith("p4/"):2951 prepend +="p4/"2952 self.branch = prepend + self.branch29532954iflen(args) ==0and self.depotPaths:2955if not self.silent:2956print"Depot paths:%s"%' '.join(self.depotPaths)2957else:2958if self.depotPaths and self.depotPaths != args:2959print("previous import used depot path%sand now%swas specified. "2960"This doesn't work!"% (' '.join(self.depotPaths),2961' '.join(args)))2962 sys.exit(1)29632964 self.depotPaths =sorted(args)29652966 revision =""2967 self.users = {}29682969# Make sure no revision specifiers are used when --changesfile2970# is specified.2971 bad_changesfile =False2972iflen(self.changesFile) >0:2973for p in self.depotPaths:2974if p.find("@") >=0or p.find("#") >=0:2975 bad_changesfile =True2976break2977if bad_changesfile:2978die("Option --changesfile is incompatible with revision specifiers")29792980 newPaths = []2981for p in self.depotPaths:2982if p.find("@") != -1:2983 atIdx = p.index("@")2984 self.changeRange = p[atIdx:]2985if self.changeRange =="@all":2986 self.changeRange =""2987elif','not in self.changeRange:2988 revision = self.changeRange2989 self.changeRange =""2990 p = p[:atIdx]2991elif p.find("#") != -1:2992 hashIdx = p.index("#")2993 revision = p[hashIdx:]2994 p = p[:hashIdx]2995elif self.previousDepotPaths == []:2996# pay attention to changesfile, if given, else import2997# the entire p4 tree at the head revision2998iflen(self.changesFile) ==0:2999 revision ="#head"30003001 p = re.sub("\.\.\.$","", p)3002if not p.endswith("/"):3003 p +="/"30043005 newPaths.append(p)30063007 self.depotPaths = newPaths30083009# --detect-branches may change this for each branch3010 self.branchPrefixes = self.depotPaths30113012 self.loadUserMapFromCache()3013 self.labels = {}3014if self.detectLabels:3015 self.getLabels();30163017if self.detectBranches:3018## FIXME - what's a P4 projectName ?3019 self.projectName = self.guessProjectName()30203021if self.hasOrigin:3022 self.getBranchMappingFromGitBranches()3023else:3024 self.getBranchMapping()3025if self.verbose:3026print"p4-git branches:%s"% self.p4BranchesInGit3027print"initial parents:%s"% self.initialParents3028for b in self.p4BranchesInGit:3029if b !="master":30303031## FIXME3032 b = b[len(self.projectName):]3033 self.createdBranches.add(b)30343035 self.tz ="%+03d%02d"% (- time.timezone /3600, ((- time.timezone %3600) /60))30363037 self.importProcess = subprocess.Popen(["git","fast-import"],3038 stdin=subprocess.PIPE,3039 stdout=subprocess.PIPE,3040 stderr=subprocess.PIPE);3041 self.gitOutput = self.importProcess.stdout3042 self.gitStream = self.importProcess.stdin3043 self.gitError = self.importProcess.stderr30443045if revision:3046 self.importHeadRevision(revision)3047else:3048 changes = []30493050iflen(self.changesFile) >0:3051 output =open(self.changesFile).readlines()3052 changeSet =set()3053for line in output:3054 changeSet.add(int(line))30553056for change in changeSet:3057 changes.append(change)30583059 changes.sort()3060else:3061# catch "git p4 sync" with no new branches, in a repo that3062# does not have any existing p4 branches3063iflen(args) ==0:3064if not self.p4BranchesInGit:3065die("No remote p4 branches. Perhaps you never did\"git p4 clone\"in here.")30663067# The default branch is master, unless --branch is used to3068# specify something else. Make sure it exists, or complain3069# nicely about how to use --branch.3070if not self.detectBranches:3071if notbranch_exists(self.branch):3072if branch_arg_given:3073die("Error: branch%sdoes not exist."% self.branch)3074else:3075die("Error: no branch%s; perhaps specify one with --branch."%3076 self.branch)30773078if self.verbose:3079print"Getting p4 changes for%s...%s"% (', '.join(self.depotPaths),3080 self.changeRange)3081 changes =p4ChangesForPaths(self.depotPaths, self.changeRange, self.changes_block_size)30823083iflen(self.maxChanges) >0:3084 changes = changes[:min(int(self.maxChanges),len(changes))]30853086iflen(changes) ==0:3087if not self.silent:3088print"No changes to import!"3089else:3090if not self.silent and not self.detectBranches:3091print"Import destination:%s"% self.branch30923093 self.updatedBranches =set()30943095if not self.detectBranches:3096if args:3097# start a new branch3098 self.initialParent =""3099else:3100# build on a previous revision3101 self.initialParent =parseRevision(self.branch)31023103 self.importChanges(changes)31043105if not self.silent:3106print""3107iflen(self.updatedBranches) >0:3108 sys.stdout.write("Updated branches: ")3109for b in self.updatedBranches:3110 sys.stdout.write("%s"% b)3111 sys.stdout.write("\n")31123113ifgitConfigBool("git-p4.importLabels"):3114 self.importLabels =True31153116if self.importLabels:3117 p4Labels =getP4Labels(self.depotPaths)3118 gitTags =getGitTags()31193120 missingP4Labels = p4Labels - gitTags3121 self.importP4Labels(self.gitStream, missingP4Labels)31223123 self.gitStream.close()3124if self.importProcess.wait() !=0:3125die("fast-import failed:%s"% self.gitError.read())3126 self.gitOutput.close()3127 self.gitError.close()31283129# Cleanup temporary branches created during import3130if self.tempBranches != []:3131for branch in self.tempBranches:3132read_pipe("git update-ref -d%s"% branch)3133 os.rmdir(os.path.join(os.environ.get("GIT_DIR",".git"), self.tempBranchLocation))31343135# Create a symbolic ref p4/HEAD pointing to p4/<branch> to allow3136# a convenient shortcut refname "p4".3137if self.importIntoRemotes:3138 head_ref = self.refPrefix +"HEAD"3139if notgitBranchExists(head_ref)andgitBranchExists(self.branch):3140system(["git","symbolic-ref", head_ref, self.branch])31413142return True31433144classP4Rebase(Command):3145def__init__(self):3146 Command.__init__(self)3147 self.options = [3148 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),3149]3150 self.importLabels =False3151 self.description = ("Fetches the latest revision from perforce and "3152+"rebases the current work (branch) against it")31533154defrun(self, args):3155 sync =P4Sync()3156 sync.importLabels = self.importLabels3157 sync.run([])31583159return self.rebase()31603161defrebase(self):3162if os.system("git update-index --refresh") !=0:3163die("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.");3164iflen(read_pipe("git diff-index HEAD --")) >0:3165die("You have uncommitted changes. Please commit them before rebasing or stash them away with git stash.");31663167[upstream, settings] =findUpstreamBranchPoint()3168iflen(upstream) ==0:3169die("Cannot find upstream branchpoint for rebase")31703171# the branchpoint may be p4/foo~3, so strip off the parent3172 upstream = re.sub("~[0-9]+$","", upstream)31733174print"Rebasing the current branch onto%s"% upstream3175 oldHead =read_pipe("git rev-parse HEAD").strip()3176system("git rebase%s"% upstream)3177system("git diff-tree --stat --summary -M%sHEAD --"% oldHead)3178return True31793180classP4Clone(P4Sync):3181def__init__(self):3182 P4Sync.__init__(self)3183 self.description ="Creates a new git repository and imports from Perforce into it"3184 self.usage ="usage: %prog [options] //depot/path[@revRange]"3185 self.options += [3186 optparse.make_option("--destination", dest="cloneDestination",3187 action='store', default=None,3188help="where to leave result of the clone"),3189 optparse.make_option("--bare", dest="cloneBare",3190 action="store_true", default=False),3191]3192 self.cloneDestination =None3193 self.needsGit =False3194 self.cloneBare =False31953196defdefaultDestination(self, args):3197## TODO: use common prefix of args?3198 depotPath = args[0]3199 depotDir = re.sub("(@[^@]*)$","", depotPath)3200 depotDir = re.sub("(#[^#]*)$","", depotDir)3201 depotDir = re.sub(r"\.\.\.$","", depotDir)3202 depotDir = re.sub(r"/$","", depotDir)3203return os.path.split(depotDir)[1]32043205defrun(self, args):3206iflen(args) <1:3207return False32083209if self.keepRepoPath and not self.cloneDestination:3210 sys.stderr.write("Must specify destination for --keep-path\n")3211 sys.exit(1)32123213 depotPaths = args32143215if not self.cloneDestination andlen(depotPaths) >1:3216 self.cloneDestination = depotPaths[-1]3217 depotPaths = depotPaths[:-1]32183219 self.cloneExclude = ["/"+p for p in self.cloneExclude]3220for p in depotPaths:3221if not p.startswith("//"):3222 sys.stderr.write('Depot paths must start with "//":%s\n'% p)3223return False32243225if not self.cloneDestination:3226 self.cloneDestination = self.defaultDestination(args)32273228print"Importing from%sinto%s"% (', '.join(depotPaths), self.cloneDestination)32293230if not os.path.exists(self.cloneDestination):3231 os.makedirs(self.cloneDestination)3232chdir(self.cloneDestination)32333234 init_cmd = ["git","init"]3235if self.cloneBare:3236 init_cmd.append("--bare")3237 retcode = subprocess.call(init_cmd)3238if retcode:3239raiseCalledProcessError(retcode, init_cmd)32403241if not P4Sync.run(self, depotPaths):3242return False32433244# create a master branch and check out a work tree3245ifgitBranchExists(self.branch):3246system(["git","branch","master", self.branch ])3247if not self.cloneBare:3248system(["git","checkout","-f"])3249else:3250print'Not checking out any branch, use ' \3251'"git checkout -q -b master <branch>"'32523253# auto-set this variable if invoked with --use-client-spec3254if self.useClientSpec_from_options:3255system("git config --bool git-p4.useclientspec true")32563257return True32583259classP4Branches(Command):3260def__init__(self):3261 Command.__init__(self)3262 self.options = [ ]3263 self.description = ("Shows the git branches that hold imports and their "3264+"corresponding perforce depot paths")3265 self.verbose =False32663267defrun(self, args):3268iforiginP4BranchesExist():3269createOrUpdateBranchesFromOrigin()32703271 cmdline ="git rev-parse --symbolic "3272 cmdline +=" --remotes"32733274for line inread_pipe_lines(cmdline):3275 line = line.strip()32763277if not line.startswith('p4/')or line =="p4/HEAD":3278continue3279 branch = line32803281 log =extractLogMessageFromGitCommit("refs/remotes/%s"% branch)3282 settings =extractSettingsGitLog(log)32833284print"%s<=%s(%s)"% (branch,",".join(settings["depot-paths"]), settings["change"])3285return True32863287classHelpFormatter(optparse.IndentedHelpFormatter):3288def__init__(self):3289 optparse.IndentedHelpFormatter.__init__(self)32903291defformat_description(self, description):3292if description:3293return description +"\n"3294else:3295return""32963297defprintUsage(commands):3298print"usage:%s<command> [options]"% sys.argv[0]3299print""3300print"valid commands:%s"%", ".join(commands)3301print""3302print"Try%s<command> --help for command specific help."% sys.argv[0]3303print""33043305commands = {3306"debug": P4Debug,3307"submit": P4Submit,3308"commit": P4Submit,3309"sync": P4Sync,3310"rebase": P4Rebase,3311"clone": P4Clone,3312"rollback": P4RollBack,3313"branches": P4Branches3314}331533163317defmain():3318iflen(sys.argv[1:]) ==0:3319printUsage(commands.keys())3320 sys.exit(2)33213322 cmdName = sys.argv[1]3323try:3324 klass = commands[cmdName]3325 cmd =klass()3326exceptKeyError:3327print"unknown command%s"% cmdName3328print""3329printUsage(commands.keys())3330 sys.exit(2)33313332 options = cmd.options3333 cmd.gitdir = os.environ.get("GIT_DIR",None)33343335 args = sys.argv[2:]33363337 options.append(optparse.make_option("--verbose","-v", dest="verbose", action="store_true"))3338if cmd.needsGit:3339 options.append(optparse.make_option("--git-dir", dest="gitdir"))33403341 parser = optparse.OptionParser(cmd.usage.replace("%prog","%prog "+ cmdName),3342 options,3343 description = cmd.description,3344 formatter =HelpFormatter())33453346(cmd, args) = parser.parse_args(sys.argv[2:], cmd);3347global verbose3348 verbose = cmd.verbose3349if cmd.needsGit:3350if cmd.gitdir ==None:3351 cmd.gitdir = os.path.abspath(".git")3352if notisValidGitDir(cmd.gitdir):3353 cmd.gitdir =read_pipe("git rev-parse --git-dir").strip()3354if os.path.exists(cmd.gitdir):3355 cdup =read_pipe("git rev-parse --show-cdup").strip()3356iflen(cdup) >0:3357chdir(cdup);33583359if notisValidGitDir(cmd.gitdir):3360ifisValidGitDir(cmd.gitdir +"/.git"):3361 cmd.gitdir +="/.git"3362else:3363die("fatal: cannot locate git repository at%s"% cmd.gitdir)33643365 os.environ["GIT_DIR"] = cmd.gitdir33663367if not cmd.run(args):3368 parser.print_help()3369 sys.exit(2)337033713372if __name__ =='__main__':3373main()