1#!/usr/bin/env python 2# 3# git-p4.py -- A tool for bidirectional operation between a Perforce depot and git. 4# 5# Author: Simon Hausmann <simon@lst.de> 6# Copyright: 2007 Simon Hausmann <simon@lst.de> 7# 2007 Trolltech ASA 8# License: MIT <http://www.opensource.org/licenses/mit-license.php> 9# 10 11import optparse, sys, os, marshal, subprocess, shelve 12import tempfile, getopt, os.path, time, platform 13import re, shutil 14 15verbose =False 16 17# Only labels/tags matching this will be imported/exported 18defaultLabelRegexp = r'[a-zA-Z0-9_\-.]+$' 19 20defp4_build_cmd(cmd): 21"""Build a suitable p4 command line. 22 23 This consolidates building and returning a p4 command line into one 24 location. It means that hooking into the environment, or other configuration 25 can be done more easily. 26 """ 27 real_cmd = ["p4"] 28 29 user =gitConfig("git-p4.user") 30iflen(user) >0: 31 real_cmd += ["-u",user] 32 33 password =gitConfig("git-p4.password") 34iflen(password) >0: 35 real_cmd += ["-P", password] 36 37 port =gitConfig("git-p4.port") 38iflen(port) >0: 39 real_cmd += ["-p", port] 40 41 host =gitConfig("git-p4.host") 42iflen(host) >0: 43 real_cmd += ["-H", host] 44 45 client =gitConfig("git-p4.client") 46iflen(client) >0: 47 real_cmd += ["-c", client] 48 49 50ifisinstance(cmd,basestring): 51 real_cmd =' '.join(real_cmd) +' '+ cmd 52else: 53 real_cmd += cmd 54return real_cmd 55 56defchdir(dir): 57# P4 uses the PWD environment variable rather than getcwd(). Since we're 58# not using the shell, we have to set it ourselves. This path could 59# be relative, so go there first, then figure out where we ended up. 60 os.chdir(dir) 61 os.environ['PWD'] = os.getcwd() 62 63defdie(msg): 64if verbose: 65raiseException(msg) 66else: 67 sys.stderr.write(msg +"\n") 68 sys.exit(1) 69 70defwrite_pipe(c, stdin): 71if verbose: 72 sys.stderr.write('Writing pipe:%s\n'%str(c)) 73 74 expand =isinstance(c,basestring) 75 p = subprocess.Popen(c, stdin=subprocess.PIPE, shell=expand) 76 pipe = p.stdin 77 val = pipe.write(stdin) 78 pipe.close() 79if p.wait(): 80die('Command failed:%s'%str(c)) 81 82return val 83 84defp4_write_pipe(c, stdin): 85 real_cmd =p4_build_cmd(c) 86returnwrite_pipe(real_cmd, stdin) 87 88defread_pipe(c, ignore_error=False): 89if verbose: 90 sys.stderr.write('Reading pipe:%s\n'%str(c)) 91 92 expand =isinstance(c,basestring) 93 p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand) 94 pipe = p.stdout 95 val = pipe.read() 96if p.wait()and not ignore_error: 97die('Command failed:%s'%str(c)) 98 99return val 100 101defp4_read_pipe(c, ignore_error=False): 102 real_cmd =p4_build_cmd(c) 103returnread_pipe(real_cmd, ignore_error) 104 105defread_pipe_lines(c): 106if verbose: 107 sys.stderr.write('Reading pipe:%s\n'%str(c)) 108 109 expand =isinstance(c, basestring) 110 p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand) 111 pipe = p.stdout 112 val = pipe.readlines() 113if pipe.close()or p.wait(): 114die('Command failed:%s'%str(c)) 115 116return val 117 118defp4_read_pipe_lines(c): 119"""Specifically invoke p4 on the command supplied. """ 120 real_cmd =p4_build_cmd(c) 121returnread_pipe_lines(real_cmd) 122 123defp4_has_command(cmd): 124"""Ask p4 for help on this command. If it returns an error, the 125 command does not exist in this version of p4.""" 126 real_cmd =p4_build_cmd(["help", cmd]) 127 p = subprocess.Popen(real_cmd, stdout=subprocess.PIPE, 128 stderr=subprocess.PIPE) 129 p.communicate() 130return p.returncode ==0 131 132defsystem(cmd): 133 expand =isinstance(cmd,basestring) 134if verbose: 135 sys.stderr.write("executing%s\n"%str(cmd)) 136 subprocess.check_call(cmd, shell=expand) 137 138defp4_system(cmd): 139"""Specifically invoke p4 as the system command. """ 140 real_cmd =p4_build_cmd(cmd) 141 expand =isinstance(real_cmd, basestring) 142 subprocess.check_call(real_cmd, shell=expand) 143 144defp4_integrate(src, dest): 145p4_system(["integrate","-Dt",wildcard_encode(src),wildcard_encode(dest)]) 146 147defp4_sync(f, *options): 148p4_system(["sync"] +list(options) + [wildcard_encode(f)]) 149 150defp4_add(f): 151# forcibly add file names with wildcards 152ifwildcard_present(f): 153p4_system(["add","-f", f]) 154else: 155p4_system(["add", f]) 156 157defp4_delete(f): 158p4_system(["delete",wildcard_encode(f)]) 159 160defp4_edit(f): 161p4_system(["edit",wildcard_encode(f)]) 162 163defp4_revert(f): 164p4_system(["revert",wildcard_encode(f)]) 165 166defp4_reopen(type, f): 167p4_system(["reopen","-t",type,wildcard_encode(f)]) 168 169defp4_move(src, dest): 170p4_system(["move","-k",wildcard_encode(src),wildcard_encode(dest)]) 171 172# 173# Canonicalize the p4 type and return a tuple of the 174# base type, plus any modifiers. See "p4 help filetypes" 175# for a list and explanation. 176# 177defsplit_p4_type(p4type): 178 179 p4_filetypes_historical = { 180"ctempobj":"binary+Sw", 181"ctext":"text+C", 182"cxtext":"text+Cx", 183"ktext":"text+k", 184"kxtext":"text+kx", 185"ltext":"text+F", 186"tempobj":"binary+FSw", 187"ubinary":"binary+F", 188"uresource":"resource+F", 189"uxbinary":"binary+Fx", 190"xbinary":"binary+x", 191"xltext":"text+Fx", 192"xtempobj":"binary+Swx", 193"xtext":"text+x", 194"xunicode":"unicode+x", 195"xutf16":"utf16+x", 196} 197if p4type in p4_filetypes_historical: 198 p4type = p4_filetypes_historical[p4type] 199 mods ="" 200 s = p4type.split("+") 201 base = s[0] 202 mods ="" 203iflen(s) >1: 204 mods = s[1] 205return(base, mods) 206 207# 208# return the raw p4 type of a file (text, text+ko, etc) 209# 210defp4_type(file): 211 results =p4CmdList(["fstat","-T","headType",file]) 212return results[0]['headType'] 213 214# 215# Given a type base and modifier, return a regexp matching 216# the keywords that can be expanded in the file 217# 218defp4_keywords_regexp_for_type(base, type_mods): 219if base in("text","unicode","binary"): 220 kwords =None 221if"ko"in type_mods: 222 kwords ='Id|Header' 223elif"k"in type_mods: 224 kwords ='Id|Header|Author|Date|DateTime|Change|File|Revision' 225else: 226return None 227 pattern = r""" 228 \$ # Starts with a dollar, followed by... 229 (%s) # one of the keywords, followed by... 230 (:[^$]+)? # possibly an old expansion, followed by... 231 \$ # another dollar 232 """% kwords 233return pattern 234else: 235return None 236 237# 238# Given a file, return a regexp matching the possible 239# RCS keywords that will be expanded, or None for files 240# with kw expansion turned off. 241# 242defp4_keywords_regexp_for_file(file): 243if not os.path.exists(file): 244return None 245else: 246(type_base, type_mods) =split_p4_type(p4_type(file)) 247returnp4_keywords_regexp_for_type(type_base, type_mods) 248 249defsetP4ExecBit(file, mode): 250# Reopens an already open file and changes the execute bit to match 251# the execute bit setting in the passed in mode. 252 253 p4Type ="+x" 254 255if notisModeExec(mode): 256 p4Type =getP4OpenedType(file) 257 p4Type = re.sub('^([cku]?)x(.*)','\\1\\2', p4Type) 258 p4Type = re.sub('(.*?\+.*?)x(.*?)','\\1\\2', p4Type) 259if p4Type[-1] =="+": 260 p4Type = p4Type[0:-1] 261 262p4_reopen(p4Type,file) 263 264defgetP4OpenedType(file): 265# Returns the perforce file type for the given file. 266 267 result =p4_read_pipe(["opened",wildcard_encode(file)]) 268 match = re.match(".*\((.+)\)\r?$", result) 269if match: 270return match.group(1) 271else: 272die("Could not determine file type for%s(result: '%s')"% (file, result)) 273 274# Return the set of all p4 labels 275defgetP4Labels(depotPaths): 276 labels =set() 277ifisinstance(depotPaths,basestring): 278 depotPaths = [depotPaths] 279 280for l inp4CmdList(["labels"] + ["%s..."% p for p in depotPaths]): 281 label = l['label'] 282 labels.add(label) 283 284return labels 285 286# Return the set of all git tags 287defgetGitTags(): 288 gitTags =set() 289for line inread_pipe_lines(["git","tag"]): 290 tag = line.strip() 291 gitTags.add(tag) 292return gitTags 293 294defdiffTreePattern(): 295# This is a simple generator for the diff tree regex pattern. This could be 296# a class variable if this and parseDiffTreeEntry were a part of a class. 297 pattern = re.compile(':(\d+) (\d+) (\w+) (\w+) ([A-Z])(\d+)?\t(.*?)((\t(.*))|$)') 298while True: 299yield pattern 300 301defparseDiffTreeEntry(entry): 302"""Parses a single diff tree entry into its component elements. 303 304 See git-diff-tree(1) manpage for details about the format of the diff 305 output. This method returns a dictionary with the following elements: 306 307 src_mode - The mode of the source file 308 dst_mode - The mode of the destination file 309 src_sha1 - The sha1 for the source file 310 dst_sha1 - The sha1 fr the destination file 311 status - The one letter status of the diff (i.e. 'A', 'M', 'D', etc) 312 status_score - The score for the status (applicable for 'C' and 'R' 313 statuses). This is None if there is no score. 314 src - The path for the source file. 315 dst - The path for the destination file. This is only present for 316 copy or renames. If it is not present, this is None. 317 318 If the pattern is not matched, None is returned.""" 319 320 match =diffTreePattern().next().match(entry) 321if match: 322return{ 323'src_mode': match.group(1), 324'dst_mode': match.group(2), 325'src_sha1': match.group(3), 326'dst_sha1': match.group(4), 327'status': match.group(5), 328'status_score': match.group(6), 329'src': match.group(7), 330'dst': match.group(10) 331} 332return None 333 334defisModeExec(mode): 335# Returns True if the given git mode represents an executable file, 336# otherwise False. 337return mode[-3:] =="755" 338 339defisModeExecChanged(src_mode, dst_mode): 340returnisModeExec(src_mode) !=isModeExec(dst_mode) 341 342defp4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None): 343 344ifisinstance(cmd,basestring): 345 cmd ="-G "+ cmd 346 expand =True 347else: 348 cmd = ["-G"] + cmd 349 expand =False 350 351 cmd =p4_build_cmd(cmd) 352if verbose: 353 sys.stderr.write("Opening pipe:%s\n"%str(cmd)) 354 355# Use a temporary file to avoid deadlocks without 356# subprocess.communicate(), which would put another copy 357# of stdout into memory. 358 stdin_file =None 359if stdin is not None: 360 stdin_file = tempfile.TemporaryFile(prefix='p4-stdin', mode=stdin_mode) 361ifisinstance(stdin,basestring): 362 stdin_file.write(stdin) 363else: 364for i in stdin: 365 stdin_file.write(i +'\n') 366 stdin_file.flush() 367 stdin_file.seek(0) 368 369 p4 = subprocess.Popen(cmd, 370 shell=expand, 371 stdin=stdin_file, 372 stdout=subprocess.PIPE) 373 374 result = [] 375try: 376while True: 377 entry = marshal.load(p4.stdout) 378if cb is not None: 379cb(entry) 380else: 381 result.append(entry) 382exceptEOFError: 383pass 384 exitCode = p4.wait() 385if exitCode !=0: 386 entry = {} 387 entry["p4ExitCode"] = exitCode 388 result.append(entry) 389 390return result 391 392defp4Cmd(cmd): 393list=p4CmdList(cmd) 394 result = {} 395for entry inlist: 396 result.update(entry) 397return result; 398 399defp4Where(depotPath): 400if not depotPath.endswith("/"): 401 depotPath +="/" 402 depotPath = depotPath +"..." 403 outputList =p4CmdList(["where", depotPath]) 404 output =None 405for entry in outputList: 406if"depotFile"in entry: 407if entry["depotFile"] == depotPath: 408 output = entry 409break 410elif"data"in entry: 411 data = entry.get("data") 412 space = data.find(" ") 413if data[:space] == depotPath: 414 output = entry 415break 416if output ==None: 417return"" 418if output["code"] =="error": 419return"" 420 clientPath ="" 421if"path"in output: 422 clientPath = output.get("path") 423elif"data"in output: 424 data = output.get("data") 425 lastSpace = data.rfind(" ") 426 clientPath = data[lastSpace +1:] 427 428if clientPath.endswith("..."): 429 clientPath = clientPath[:-3] 430return clientPath 431 432defcurrentGitBranch(): 433returnread_pipe("git name-rev HEAD").split(" ")[1].strip() 434 435defisValidGitDir(path): 436if(os.path.exists(path +"/HEAD") 437and os.path.exists(path +"/refs")and os.path.exists(path +"/objects")): 438return True; 439return False 440 441defparseRevision(ref): 442returnread_pipe("git rev-parse%s"% ref).strip() 443 444defbranchExists(ref): 445 rev =read_pipe(["git","rev-parse","-q","--verify", ref], 446 ignore_error=True) 447returnlen(rev) >0 448 449defextractLogMessageFromGitCommit(commit): 450 logMessage ="" 451 452## fixme: title is first line of commit, not 1st paragraph. 453 foundTitle =False 454for log inread_pipe_lines("git cat-file commit%s"% commit): 455if not foundTitle: 456iflen(log) ==1: 457 foundTitle =True 458continue 459 460 logMessage += log 461return logMessage 462 463defextractSettingsGitLog(log): 464 values = {} 465for line in log.split("\n"): 466 line = line.strip() 467 m = re.search(r"^ *\[git-p4: (.*)\]$", line) 468if not m: 469continue 470 471 assignments = m.group(1).split(':') 472for a in assignments: 473 vals = a.split('=') 474 key = vals[0].strip() 475 val = ('='.join(vals[1:])).strip() 476if val.endswith('\"')and val.startswith('"'): 477 val = val[1:-1] 478 479 values[key] = val 480 481 paths = values.get("depot-paths") 482if not paths: 483 paths = values.get("depot-path") 484if paths: 485 values['depot-paths'] = paths.split(',') 486return values 487 488defgitBranchExists(branch): 489 proc = subprocess.Popen(["git","rev-parse", branch], 490 stderr=subprocess.PIPE, stdout=subprocess.PIPE); 491return proc.wait() ==0; 492 493_gitConfig = {} 494defgitConfig(key, args =None):# set args to "--bool", for instance 495if not _gitConfig.has_key(key): 496 argsFilter ="" 497if args !=None: 498 argsFilter ="%s"% args 499 cmd ="git config%s%s"% (argsFilter, key) 500 _gitConfig[key] =read_pipe(cmd, ignore_error=True).strip() 501return _gitConfig[key] 502 503defgitConfigList(key): 504if not _gitConfig.has_key(key): 505 _gitConfig[key] =read_pipe("git config --get-all%s"% key, ignore_error=True).strip().split(os.linesep) 506return _gitConfig[key] 507 508defp4BranchesInGit(branchesAreInRemotes =True): 509 branches = {} 510 511 cmdline ="git rev-parse --symbolic " 512if branchesAreInRemotes: 513 cmdline +=" --remotes" 514else: 515 cmdline +=" --branches" 516 517for line inread_pipe_lines(cmdline): 518 line = line.strip() 519 520## only import to p4/ 521if not line.startswith('p4/')or line =="p4/HEAD": 522continue 523 branch = line 524 525# strip off p4 526 branch = re.sub("^p4/","", line) 527 528 branches[branch] =parseRevision(line) 529return branches 530 531deffindUpstreamBranchPoint(head ="HEAD"): 532 branches =p4BranchesInGit() 533# map from depot-path to branch name 534 branchByDepotPath = {} 535for branch in branches.keys(): 536 tip = branches[branch] 537 log =extractLogMessageFromGitCommit(tip) 538 settings =extractSettingsGitLog(log) 539if settings.has_key("depot-paths"): 540 paths =",".join(settings["depot-paths"]) 541 branchByDepotPath[paths] ="remotes/p4/"+ branch 542 543 settings =None 544 parent =0 545while parent <65535: 546 commit = head +"~%s"% parent 547 log =extractLogMessageFromGitCommit(commit) 548 settings =extractSettingsGitLog(log) 549if settings.has_key("depot-paths"): 550 paths =",".join(settings["depot-paths"]) 551if branchByDepotPath.has_key(paths): 552return[branchByDepotPath[paths], settings] 553 554 parent = parent +1 555 556return["", settings] 557 558defcreateOrUpdateBranchesFromOrigin(localRefPrefix ="refs/remotes/p4/", silent=True): 559if not silent: 560print("Creating/updating branch(es) in%sbased on origin branch(es)" 561% localRefPrefix) 562 563 originPrefix ="origin/p4/" 564 565for line inread_pipe_lines("git rev-parse --symbolic --remotes"): 566 line = line.strip() 567if(not line.startswith(originPrefix))or line.endswith("HEAD"): 568continue 569 570 headName = line[len(originPrefix):] 571 remoteHead = localRefPrefix + headName 572 originHead = line 573 574 original =extractSettingsGitLog(extractLogMessageFromGitCommit(originHead)) 575if(not original.has_key('depot-paths') 576or not original.has_key('change')): 577continue 578 579 update =False 580if notgitBranchExists(remoteHead): 581if verbose: 582print"creating%s"% remoteHead 583 update =True 584else: 585 settings =extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead)) 586if settings.has_key('change') >0: 587if settings['depot-paths'] == original['depot-paths']: 588 originP4Change =int(original['change']) 589 p4Change =int(settings['change']) 590if originP4Change > p4Change: 591print("%s(%s) is newer than%s(%s). " 592"Updating p4 branch from origin." 593% (originHead, originP4Change, 594 remoteHead, p4Change)) 595 update =True 596else: 597print("Ignoring:%swas imported from%swhile " 598"%swas imported from%s" 599% (originHead,','.join(original['depot-paths']), 600 remoteHead,','.join(settings['depot-paths']))) 601 602if update: 603system("git update-ref%s %s"% (remoteHead, originHead)) 604 605deforiginP4BranchesExist(): 606returngitBranchExists("origin")orgitBranchExists("origin/p4")orgitBranchExists("origin/p4/master") 607 608defp4ChangesForPaths(depotPaths, changeRange): 609assert depotPaths 610 cmd = ['changes'] 611for p in depotPaths: 612 cmd += ["%s...%s"% (p, changeRange)] 613 output =p4_read_pipe_lines(cmd) 614 615 changes = {} 616for line in output: 617 changeNum =int(line.split(" ")[1]) 618 changes[changeNum] =True 619 620 changelist = changes.keys() 621 changelist.sort() 622return changelist 623 624defp4PathStartsWith(path, prefix): 625# This method tries to remedy a potential mixed-case issue: 626# 627# If UserA adds //depot/DirA/file1 628# and UserB adds //depot/dira/file2 629# 630# we may or may not have a problem. If you have core.ignorecase=true, 631# we treat DirA and dira as the same directory 632 ignorecase =gitConfig("core.ignorecase","--bool") =="true" 633if ignorecase: 634return path.lower().startswith(prefix.lower()) 635return path.startswith(prefix) 636 637defgetClientSpec(): 638"""Look at the p4 client spec, create a View() object that contains 639 all the mappings, and return it.""" 640 641 specList =p4CmdList("client -o") 642iflen(specList) !=1: 643die('Output from "client -o" is%dlines, expecting 1'% 644len(specList)) 645 646# dictionary of all client parameters 647 entry = specList[0] 648 649# just the keys that start with "View" 650 view_keys = [ k for k in entry.keys()if k.startswith("View") ] 651 652# hold this new View 653 view =View() 654 655# append the lines, in order, to the view 656for view_num inrange(len(view_keys)): 657 k ="View%d"% view_num 658if k not in view_keys: 659die("Expected view key%smissing"% k) 660 view.append(entry[k]) 661 662return view 663 664defgetClientRoot(): 665"""Grab the client directory.""" 666 667 output =p4CmdList("client -o") 668iflen(output) !=1: 669die('Output from "client -o" is%dlines, expecting 1'%len(output)) 670 671 entry = output[0] 672if"Root"not in entry: 673die('Client has no "Root"') 674 675return entry["Root"] 676 677# 678# P4 wildcards are not allowed in filenames. P4 complains 679# if you simply add them, but you can force it with "-f", in 680# which case it translates them into %xx encoding internally. 681# 682defwildcard_decode(path): 683# Search for and fix just these four characters. Do % last so 684# that fixing it does not inadvertently create new %-escapes. 685# Cannot have * in a filename in windows; untested as to 686# what p4 would do in such a case. 687if not platform.system() =="Windows": 688 path = path.replace("%2A","*") 689 path = path.replace("%23","#") \ 690.replace("%40","@") \ 691.replace("%25","%") 692return path 693 694defwildcard_encode(path): 695# do % first to avoid double-encoding the %s introduced here 696 path = path.replace("%","%25") \ 697.replace("*","%2A") \ 698.replace("#","%23") \ 699.replace("@","%40") 700return path 701 702defwildcard_present(path): 703return path.translate(None,"*#@%") != path 704 705class Command: 706def__init__(self): 707 self.usage ="usage: %prog [options]" 708 self.needsGit =True 709 self.verbose =False 710 711class P4UserMap: 712def__init__(self): 713 self.userMapFromPerforceServer =False 714 self.myP4UserId =None 715 716defp4UserId(self): 717if self.myP4UserId: 718return self.myP4UserId 719 720 results =p4CmdList("user -o") 721for r in results: 722if r.has_key('User'): 723 self.myP4UserId = r['User'] 724return r['User'] 725die("Could not find your p4 user id") 726 727defp4UserIsMe(self, p4User): 728# return True if the given p4 user is actually me 729 me = self.p4UserId() 730if not p4User or p4User != me: 731return False 732else: 733return True 734 735defgetUserCacheFilename(self): 736 home = os.environ.get("HOME", os.environ.get("USERPROFILE")) 737return home +"/.gitp4-usercache.txt" 738 739defgetUserMapFromPerforceServer(self): 740if self.userMapFromPerforceServer: 741return 742 self.users = {} 743 self.emails = {} 744 745for output inp4CmdList("users"): 746if not output.has_key("User"): 747continue 748 self.users[output["User"]] = output["FullName"] +" <"+ output["Email"] +">" 749 self.emails[output["Email"]] = output["User"] 750 751 752 s ='' 753for(key, val)in self.users.items(): 754 s +="%s\t%s\n"% (key.expandtabs(1), val.expandtabs(1)) 755 756open(self.getUserCacheFilename(),"wb").write(s) 757 self.userMapFromPerforceServer =True 758 759defloadUserMapFromCache(self): 760 self.users = {} 761 self.userMapFromPerforceServer =False 762try: 763 cache =open(self.getUserCacheFilename(),"rb") 764 lines = cache.readlines() 765 cache.close() 766for line in lines: 767 entry = line.strip().split("\t") 768 self.users[entry[0]] = entry[1] 769exceptIOError: 770 self.getUserMapFromPerforceServer() 771 772classP4Debug(Command): 773def__init__(self): 774 Command.__init__(self) 775 self.options = [] 776 self.description ="A tool to debug the output of p4 -G." 777 self.needsGit =False 778 779defrun(self, args): 780 j =0 781for output inp4CmdList(args): 782print'Element:%d'% j 783 j +=1 784print output 785return True 786 787classP4RollBack(Command): 788def__init__(self): 789 Command.__init__(self) 790 self.options = [ 791 optparse.make_option("--local", dest="rollbackLocalBranches", action="store_true") 792] 793 self.description ="A tool to debug the multi-branch import. Don't use :)" 794 self.rollbackLocalBranches =False 795 796defrun(self, args): 797iflen(args) !=1: 798return False 799 maxChange =int(args[0]) 800 801if"p4ExitCode"inp4Cmd("changes -m 1"): 802die("Problems executing p4"); 803 804if self.rollbackLocalBranches: 805 refPrefix ="refs/heads/" 806 lines =read_pipe_lines("git rev-parse --symbolic --branches") 807else: 808 refPrefix ="refs/remotes/" 809 lines =read_pipe_lines("git rev-parse --symbolic --remotes") 810 811for line in lines: 812if self.rollbackLocalBranches or(line.startswith("p4/")and line !="p4/HEAD\n"): 813 line = line.strip() 814 ref = refPrefix + line 815 log =extractLogMessageFromGitCommit(ref) 816 settings =extractSettingsGitLog(log) 817 818 depotPaths = settings['depot-paths'] 819 change = settings['change'] 820 821 changed =False 822 823iflen(p4Cmd("changes -m 1 "+' '.join(['%s...@%s'% (p, maxChange) 824for p in depotPaths]))) ==0: 825print"Branch%sdid not exist at change%s, deleting."% (ref, maxChange) 826system("git update-ref -d%s`git rev-parse%s`"% (ref, ref)) 827continue 828 829while change andint(change) > maxChange: 830 changed =True 831if self.verbose: 832print"%sis at%s; rewinding towards%s"% (ref, change, maxChange) 833system("git update-ref%s\"%s^\""% (ref, ref)) 834 log =extractLogMessageFromGitCommit(ref) 835 settings =extractSettingsGitLog(log) 836 837 838 depotPaths = settings['depot-paths'] 839 change = settings['change'] 840 841if changed: 842print"%srewound to%s"% (ref, change) 843 844return True 845 846classP4Submit(Command, P4UserMap): 847def__init__(self): 848 Command.__init__(self) 849 P4UserMap.__init__(self) 850 self.options = [ 851 optparse.make_option("--origin", dest="origin"), 852 optparse.make_option("-M", dest="detectRenames", action="store_true"), 853# preserve the user, requires relevant p4 permissions 854 optparse.make_option("--preserve-user", dest="preserveUser", action="store_true"), 855 optparse.make_option("--export-labels", dest="exportLabels", action="store_true"), 856] 857 self.description ="Submit changes from git to the perforce depot." 858 self.usage +=" [name of git branch to submit into perforce depot]" 859 self.origin ="" 860 self.detectRenames =False 861 self.preserveUser =gitConfig("git-p4.preserveUser").lower() =="true" 862 self.isWindows = (platform.system() =="Windows") 863 self.exportLabels =False 864 self.p4HasMoveCommand =p4_has_command("move") 865 866defcheck(self): 867iflen(p4CmdList("opened ...")) >0: 868die("You have files opened with perforce! Close them before starting the sync.") 869 870defseparate_jobs_from_description(self, message): 871"""Extract and return a possible Jobs field in the commit 872 message. It goes into a separate section in the p4 change 873 specification. 874 875 A jobs line starts with "Jobs:" and looks like a new field 876 in a form. Values are white-space separated on the same 877 line or on following lines that start with a tab. 878 879 This does not parse and extract the full git commit message 880 like a p4 form. It just sees the Jobs: line as a marker 881 to pass everything from then on directly into the p4 form, 882 but outside the description section. 883 884 Return a tuple (stripped log message, jobs string).""" 885 886 m = re.search(r'^Jobs:', message, re.MULTILINE) 887if m is None: 888return(message,None) 889 890 jobtext = message[m.start():] 891 stripped_message = message[:m.start()].rstrip() 892return(stripped_message, jobtext) 893 894defprepareLogMessage(self, template, message, jobs): 895"""Edits the template returned from "p4 change -o" to insert 896 the message in the Description field, and the jobs text in 897 the Jobs field.""" 898 result ="" 899 900 inDescriptionSection =False 901 902for line in template.split("\n"): 903if line.startswith("#"): 904 result += line +"\n" 905continue 906 907if inDescriptionSection: 908if line.startswith("Files:")or line.startswith("Jobs:"): 909 inDescriptionSection =False 910# insert Jobs section 911if jobs: 912 result += jobs +"\n" 913else: 914continue 915else: 916if line.startswith("Description:"): 917 inDescriptionSection =True 918 line +="\n" 919for messageLine in message.split("\n"): 920 line +="\t"+ messageLine +"\n" 921 922 result += line +"\n" 923 924return result 925 926defpatchRCSKeywords(self,file, pattern): 927# Attempt to zap the RCS keywords in a p4 controlled file matching the given pattern 928(handle, outFileName) = tempfile.mkstemp(dir='.') 929try: 930 outFile = os.fdopen(handle,"w+") 931 inFile =open(file,"r") 932 regexp = re.compile(pattern, re.VERBOSE) 933for line in inFile.readlines(): 934 line = regexp.sub(r'$\1$', line) 935 outFile.write(line) 936 inFile.close() 937 outFile.close() 938# Forcibly overwrite the original file 939 os.unlink(file) 940 shutil.move(outFileName,file) 941except: 942# cleanup our temporary file 943 os.unlink(outFileName) 944print"Failed to strip RCS keywords in%s"%file 945raise 946 947print"Patched up RCS keywords in%s"%file 948 949defp4UserForCommit(self,id): 950# Return the tuple (perforce user,git email) for a given git commit id 951 self.getUserMapFromPerforceServer() 952 gitEmail =read_pipe("git log --max-count=1 --format='%%ae'%s"%id) 953 gitEmail = gitEmail.strip() 954if not self.emails.has_key(gitEmail): 955return(None,gitEmail) 956else: 957return(self.emails[gitEmail],gitEmail) 958 959defcheckValidP4Users(self,commits): 960# check if any git authors cannot be mapped to p4 users 961foridin commits: 962(user,email) = self.p4UserForCommit(id) 963if not user: 964 msg ="Cannot find p4 user for email%sin commit%s."% (email,id) 965ifgitConfig('git-p4.allowMissingP4Users').lower() =="true": 966print"%s"% msg 967else: 968die("Error:%s\nSet git-p4.allowMissingP4Users to true to allow this."% msg) 969 970deflastP4Changelist(self): 971# Get back the last changelist number submitted in this client spec. This 972# then gets used to patch up the username in the change. If the same 973# client spec is being used by multiple processes then this might go 974# wrong. 975 results =p4CmdList("client -o")# find the current client 976 client =None 977for r in results: 978if r.has_key('Client'): 979 client = r['Client'] 980break 981if not client: 982die("could not get client spec") 983 results =p4CmdList(["changes","-c", client,"-m","1"]) 984for r in results: 985if r.has_key('change'): 986return r['change'] 987die("Could not get changelist number for last submit - cannot patch up user details") 988 989defmodifyChangelistUser(self, changelist, newUser): 990# fixup the user field of a changelist after it has been submitted. 991 changes =p4CmdList("change -o%s"% changelist) 992iflen(changes) !=1: 993die("Bad output from p4 change modifying%sto user%s"% 994(changelist, newUser)) 995 996 c = changes[0] 997if c['User'] == newUser:return# nothing to do 998 c['User'] = newUser 999input= marshal.dumps(c)10001001 result =p4CmdList("change -f -i", stdin=input)1002for r in result:1003if r.has_key('code'):1004if r['code'] =='error':1005die("Could not modify user field of changelist%sto%s:%s"% (changelist, newUser, r['data']))1006if r.has_key('data'):1007print("Updated user field for changelist%sto%s"% (changelist, newUser))1008return1009die("Could not modify user field of changelist%sto%s"% (changelist, newUser))10101011defcanChangeChangelists(self):1012# check to see if we have p4 admin or super-user permissions, either of1013# which are required to modify changelists.1014 results =p4CmdList(["protects", self.depotPath])1015for r in results:1016if r.has_key('perm'):1017if r['perm'] =='admin':1018return11019if r['perm'] =='super':1020return11021return010221023defprepareSubmitTemplate(self):1024"""Run "p4 change -o" to grab a change specification template.1025 This does not use "p4 -G", as it is nice to keep the submission1026 template in original order, since a human might edit it.10271028 Remove lines in the Files section that show changes to files1029 outside the depot path we're committing into."""10301031 template =""1032 inFilesSection =False1033for line inp4_read_pipe_lines(['change','-o']):1034if line.endswith("\r\n"):1035 line = line[:-2] +"\n"1036if inFilesSection:1037if line.startswith("\t"):1038# path starts and ends with a tab1039 path = line[1:]1040 lastTab = path.rfind("\t")1041if lastTab != -1:1042 path = path[:lastTab]1043if notp4PathStartsWith(path, self.depotPath):1044continue1045else:1046 inFilesSection =False1047else:1048if line.startswith("Files:"):1049 inFilesSection =True10501051 template += line10521053return template10541055defedit_template(self, template_file):1056"""Invoke the editor to let the user change the submission1057 message. Return true if okay to continue with the submit."""10581059# if configured to skip the editing part, just submit1060ifgitConfig("git-p4.skipSubmitEdit") =="true":1061return True10621063# look at the modification time, to check later if the user saved1064# the file1065 mtime = os.stat(template_file).st_mtime10661067# invoke the editor1068if os.environ.has_key("P4EDITOR")and(os.environ.get("P4EDITOR") !=""):1069 editor = os.environ.get("P4EDITOR")1070else:1071 editor =read_pipe("git var GIT_EDITOR").strip()1072system(editor +" "+ template_file)10731074# If the file was not saved, prompt to see if this patch should1075# be skipped. But skip this verification step if configured so.1076ifgitConfig("git-p4.skipSubmitEditCheck") =="true":1077return True10781079# modification time updated means user saved the file1080if os.stat(template_file).st_mtime > mtime:1081return True10821083while True:1084 response =raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")1085if response =='y':1086return True1087if response =='n':1088return False10891090defapplyCommit(self,id):1091"""Apply one commit, return True if it succeeded."""10921093print"Applying",read_pipe(["git","show","-s",1094"--format=format:%h%s",id])10951096(p4User, gitEmail) = self.p4UserForCommit(id)10971098 diff =read_pipe_lines("git diff-tree -r%s\"%s^\" \"%s\""% (self.diffOpts,id,id))1099 filesToAdd =set()1100 filesToDelete =set()1101 editedFiles =set()1102 pureRenameCopy =set()1103 filesToChangeExecBit = {}11041105for line in diff:1106 diff =parseDiffTreeEntry(line)1107 modifier = diff['status']1108 path = diff['src']1109if modifier =="M":1110p4_edit(path)1111ifisModeExecChanged(diff['src_mode'], diff['dst_mode']):1112 filesToChangeExecBit[path] = diff['dst_mode']1113 editedFiles.add(path)1114elif modifier =="A":1115 filesToAdd.add(path)1116 filesToChangeExecBit[path] = diff['dst_mode']1117if path in filesToDelete:1118 filesToDelete.remove(path)1119elif modifier =="D":1120 filesToDelete.add(path)1121if path in filesToAdd:1122 filesToAdd.remove(path)1123elif modifier =="C":1124 src, dest = diff['src'], diff['dst']1125p4_integrate(src, dest)1126 pureRenameCopy.add(dest)1127if diff['src_sha1'] != diff['dst_sha1']:1128p4_edit(dest)1129 pureRenameCopy.discard(dest)1130ifisModeExecChanged(diff['src_mode'], diff['dst_mode']):1131p4_edit(dest)1132 pureRenameCopy.discard(dest)1133 filesToChangeExecBit[dest] = diff['dst_mode']1134 os.unlink(dest)1135 editedFiles.add(dest)1136elif modifier =="R":1137 src, dest = diff['src'], diff['dst']1138if self.p4HasMoveCommand:1139p4_edit(src)# src must be open before move1140p4_move(src, dest)# opens for (move/delete, move/add)1141else:1142p4_integrate(src, dest)1143if diff['src_sha1'] != diff['dst_sha1']:1144p4_edit(dest)1145else:1146 pureRenameCopy.add(dest)1147ifisModeExecChanged(diff['src_mode'], diff['dst_mode']):1148if not self.p4HasMoveCommand:1149p4_edit(dest)# with move: already open, writable1150 filesToChangeExecBit[dest] = diff['dst_mode']1151if not self.p4HasMoveCommand:1152 os.unlink(dest)1153 filesToDelete.add(src)1154 editedFiles.add(dest)1155else:1156die("unknown modifier%sfor%s"% (modifier, path))11571158 diffcmd ="git format-patch -k --stdout\"%s^\"..\"%s\""% (id,id)1159 patchcmd = diffcmd +" | git apply "1160 tryPatchCmd = patchcmd +"--check -"1161 applyPatchCmd = patchcmd +"--check --apply -"1162 patch_succeeded =True11631164if os.system(tryPatchCmd) !=0:1165 fixed_rcs_keywords =False1166 patch_succeeded =False1167print"Unfortunately applying the change failed!"11681169# Patch failed, maybe it's just RCS keyword woes. Look through1170# the patch to see if that's possible.1171ifgitConfig("git-p4.attemptRCSCleanup","--bool") =="true":1172file=None1173 pattern =None1174 kwfiles = {}1175forfilein editedFiles | filesToDelete:1176# did this file's delta contain RCS keywords?1177 pattern =p4_keywords_regexp_for_file(file)11781179if pattern:1180# this file is a possibility...look for RCS keywords.1181 regexp = re.compile(pattern, re.VERBOSE)1182for line inread_pipe_lines(["git","diff","%s^..%s"% (id,id),file]):1183if regexp.search(line):1184if verbose:1185print"got keyword match on%sin%sin%s"% (pattern, line,file)1186 kwfiles[file] = pattern1187break11881189forfilein kwfiles:1190if verbose:1191print"zapping%swith%s"% (line,pattern)1192 self.patchRCSKeywords(file, kwfiles[file])1193 fixed_rcs_keywords =True11941195if fixed_rcs_keywords:1196print"Retrying the patch with RCS keywords cleaned up"1197if os.system(tryPatchCmd) ==0:1198 patch_succeeded =True11991200if not patch_succeeded:1201for f in editedFiles:1202p4_revert(f)1203return False12041205#1206# Apply the patch for real, and do add/delete/+x handling.1207#1208system(applyPatchCmd)12091210for f in filesToAdd:1211p4_add(f)1212for f in filesToDelete:1213p4_revert(f)1214p4_delete(f)12151216# Set/clear executable bits1217for f in filesToChangeExecBit.keys():1218 mode = filesToChangeExecBit[f]1219setP4ExecBit(f, mode)12201221#1222# Build p4 change description, starting with the contents1223# of the git commit message.1224#1225 logMessage =extractLogMessageFromGitCommit(id)1226 logMessage = logMessage.strip()1227(logMessage, jobs) = self.separate_jobs_from_description(logMessage)12281229 template = self.prepareSubmitTemplate()1230 submitTemplate = self.prepareLogMessage(template, logMessage, jobs)12311232if self.preserveUser:1233 submitTemplate +="\n######## Actual user%s, modified after commit\n"% p4User12341235if self.checkAuthorship and not self.p4UserIsMe(p4User):1236 submitTemplate +="######## git author%sdoes not match your p4 account.\n"% gitEmail1237 submitTemplate +="######## Use option --preserve-user to modify authorship.\n"1238 submitTemplate +="######## Variable git-p4.skipUserNameCheck hides this message.\n"12391240 separatorLine ="######## everything below this line is just the diff #######\n"12411242# diff1243if os.environ.has_key("P4DIFF"):1244del(os.environ["P4DIFF"])1245 diff =""1246for editedFile in editedFiles:1247 diff +=p4_read_pipe(['diff','-du',1248wildcard_encode(editedFile)])12491250# new file diff1251 newdiff =""1252for newFile in filesToAdd:1253 newdiff +="==== new file ====\n"1254 newdiff +="--- /dev/null\n"1255 newdiff +="+++%s\n"% newFile1256 f =open(newFile,"r")1257for line in f.readlines():1258 newdiff +="+"+ line1259 f.close()12601261# change description file: submitTemplate, separatorLine, diff, newdiff1262(handle, fileName) = tempfile.mkstemp()1263 tmpFile = os.fdopen(handle,"w+")1264if self.isWindows:1265 submitTemplate = submitTemplate.replace("\n","\r\n")1266 separatorLine = separatorLine.replace("\n","\r\n")1267 newdiff = newdiff.replace("\n","\r\n")1268 tmpFile.write(submitTemplate + separatorLine + diff + newdiff)1269 tmpFile.close()12701271#1272# Let the user edit the change description, then submit it.1273#1274if self.edit_template(fileName):1275# read the edited message and submit1276 ret =True1277 tmpFile =open(fileName,"rb")1278 message = tmpFile.read()1279 tmpFile.close()1280 submitTemplate = message[:message.index(separatorLine)]1281if self.isWindows:1282 submitTemplate = submitTemplate.replace("\r\n","\n")1283p4_write_pipe(['submit','-i'], submitTemplate)12841285if self.preserveUser:1286if p4User:1287# Get last changelist number. Cannot easily get it from1288# the submit command output as the output is1289# unmarshalled.1290 changelist = self.lastP4Changelist()1291 self.modifyChangelistUser(changelist, p4User)12921293# The rename/copy happened by applying a patch that created a1294# new file. This leaves it writable, which confuses p4.1295for f in pureRenameCopy:1296p4_sync(f,"-f")12971298else:1299# skip this patch1300 ret =False1301print"Submission cancelled, undoing p4 changes."1302for f in editedFiles:1303p4_revert(f)1304for f in filesToAdd:1305p4_revert(f)1306 os.remove(f)1307for f in filesToDelete:1308p4_revert(f)13091310 os.remove(fileName)1311return ret13121313# Export git tags as p4 labels. Create a p4 label and then tag1314# with that.1315defexportGitTags(self, gitTags):1316 validLabelRegexp =gitConfig("git-p4.labelExportRegexp")1317iflen(validLabelRegexp) ==0:1318 validLabelRegexp = defaultLabelRegexp1319 m = re.compile(validLabelRegexp)13201321for name in gitTags:13221323if not m.match(name):1324if verbose:1325print"tag%sdoes not match regexp%s"% (name, validLabelRegexp)1326continue13271328# Get the p4 commit this corresponds to1329 logMessage =extractLogMessageFromGitCommit(name)1330 values =extractSettingsGitLog(logMessage)13311332if not values.has_key('change'):1333# a tag pointing to something not sent to p4; ignore1334if verbose:1335print"git tag%sdoes not give a p4 commit"% name1336continue1337else:1338 changelist = values['change']13391340# Get the tag details.1341 inHeader =True1342 isAnnotated =False1343 body = []1344for l inread_pipe_lines(["git","cat-file","-p", name]):1345 l = l.strip()1346if inHeader:1347if re.match(r'tag\s+', l):1348 isAnnotated =True1349elif re.match(r'\s*$', l):1350 inHeader =False1351continue1352else:1353 body.append(l)13541355if not isAnnotated:1356 body = ["lightweight tag imported by git p4\n"]13571358# Create the label - use the same view as the client spec we are using1359 clientSpec =getClientSpec()13601361 labelTemplate ="Label:%s\n"% name1362 labelTemplate +="Description:\n"1363for b in body:1364 labelTemplate +="\t"+ b +"\n"1365 labelTemplate +="View:\n"1366for mapping in clientSpec.mappings:1367 labelTemplate +="\t%s\n"% mapping.depot_side.path13681369p4_write_pipe(["label","-i"], labelTemplate)13701371# Use the label1372p4_system(["tag","-l", name] +1373["%s@%s"% (mapping.depot_side.path, changelist)for mapping in clientSpec.mappings])13741375if verbose:1376print"created p4 label for tag%s"% name13771378defrun(self, args):1379iflen(args) ==0:1380 self.master =currentGitBranch()1381iflen(self.master) ==0or notgitBranchExists("refs/heads/%s"% self.master):1382die("Detecting current git branch failed!")1383eliflen(args) ==1:1384 self.master = args[0]1385if notbranchExists(self.master):1386die("Branch%sdoes not exist"% self.master)1387else:1388return False13891390 allowSubmit =gitConfig("git-p4.allowSubmit")1391iflen(allowSubmit) >0and not self.master in allowSubmit.split(","):1392die("%sis not in git-p4.allowSubmit"% self.master)13931394[upstream, settings] =findUpstreamBranchPoint()1395 self.depotPath = settings['depot-paths'][0]1396iflen(self.origin) ==0:1397 self.origin = upstream13981399if self.preserveUser:1400if not self.canChangeChangelists():1401die("Cannot preserve user names without p4 super-user or admin permissions")14021403if self.verbose:1404print"Origin branch is "+ self.origin14051406iflen(self.depotPath) ==0:1407print"Internal error: cannot locate perforce depot path from existing branches"1408 sys.exit(128)14091410 self.useClientSpec =False1411ifgitConfig("git-p4.useclientspec","--bool") =="true":1412 self.useClientSpec =True1413if self.useClientSpec:1414 self.clientSpecDirs =getClientSpec()14151416if self.useClientSpec:1417# all files are relative to the client spec1418 self.clientPath =getClientRoot()1419else:1420 self.clientPath =p4Where(self.depotPath)14211422if self.clientPath =="":1423die("Error: Cannot locate perforce checkout of%sin client view"% self.depotPath)14241425print"Perforce checkout for depot path%slocated at%s"% (self.depotPath, self.clientPath)1426 self.oldWorkingDirectory = os.getcwd()14271428# ensure the clientPath exists1429 new_client_dir =False1430if not os.path.exists(self.clientPath):1431 new_client_dir =True1432 os.makedirs(self.clientPath)14331434chdir(self.clientPath)1435print"Synchronizing p4 checkout..."1436if new_client_dir:1437# old one was destroyed, and maybe nobody told p41438p4_sync("...","-f")1439else:1440p4_sync("...")1441 self.check()14421443 commits = []1444for line inread_pipe_lines("git rev-list --no-merges%s..%s"% (self.origin, self.master)):1445 commits.append(line.strip())1446 commits.reverse()14471448if self.preserveUser or(gitConfig("git-p4.skipUserNameCheck") =="true"):1449 self.checkAuthorship =False1450else:1451 self.checkAuthorship =True14521453if self.preserveUser:1454 self.checkValidP4Users(commits)14551456#1457# Build up a set of options to be passed to diff when1458# submitting each commit to p4.1459#1460if self.detectRenames:1461# command-line -M arg1462 self.diffOpts ="-M"1463else:1464# If not explicitly set check the config variable1465 detectRenames =gitConfig("git-p4.detectRenames")14661467if detectRenames.lower() =="false"or detectRenames =="":1468 self.diffOpts =""1469elif detectRenames.lower() =="true":1470 self.diffOpts ="-M"1471else:1472 self.diffOpts ="-M%s"% detectRenames14731474# no command-line arg for -C or --find-copies-harder, just1475# config variables1476 detectCopies =gitConfig("git-p4.detectCopies")1477if detectCopies.lower() =="false"or detectCopies =="":1478pass1479elif detectCopies.lower() =="true":1480 self.diffOpts +=" -C"1481else:1482 self.diffOpts +=" -C%s"% detectCopies14831484ifgitConfig("git-p4.detectCopiesHarder","--bool") =="true":1485 self.diffOpts +=" --find-copies-harder"14861487#1488# Apply the commits, one at a time. On failure, ask if should1489# continue to try the rest of the patches, or quit.1490#1491 applied = []1492 last =len(commits) -11493for i, commit inenumerate(commits):1494 ok = self.applyCommit(commit)1495if ok:1496 applied.append(commit)1497else:1498if i < last:1499 quit =False1500while True:1501print"What do you want to do?"1502 response =raw_input("[s]kip this commit but apply"1503" the rest, or [q]uit? ")1504if not response:1505continue1506if response[0] =="s":1507print"Skipping this commit, but applying the rest"1508break1509if response[0] =="q":1510print"Quitting"1511 quit =True1512break1513if quit:1514break15151516chdir(self.oldWorkingDirectory)15171518iflen(commits) ==len(applied):1519print"All commits applied!"15201521 sync =P4Sync()1522 sync.run([])15231524 rebase =P4Rebase()1525 rebase.rebase()15261527else:1528iflen(applied) ==0:1529print"No commits applied."1530else:1531print"Applied only the commits marked with '*':"1532for c in commits:1533if c in applied:1534 star ="*"1535else:1536 star =" "1537print star,read_pipe(["git","show","-s",1538"--format=format:%h%s", c])1539print"You will have to do 'git p4 sync' and rebase."15401541ifgitConfig("git-p4.exportLabels","--bool") =="true":1542 self.exportLabels =True15431544if self.exportLabels:1545 p4Labels =getP4Labels(self.depotPath)1546 gitTags =getGitTags()15471548 missingGitTags = gitTags - p4Labels1549 self.exportGitTags(missingGitTags)15501551# exit with error unless everything applied perfecly1552iflen(commits) !=len(applied):1553 sys.exit(1)15541555return True15561557classView(object):1558"""Represent a p4 view ("p4 help views"), and map files in a1559 repo according to the view."""15601561classPath(object):1562"""A depot or client path, possibly containing wildcards.1563 The only one supported is ... at the end, currently.1564 Initialize with the full path, with //depot or //client."""15651566def__init__(self, path, is_depot):1567 self.path = path1568 self.is_depot = is_depot1569 self.find_wildcards()1570# remember the prefix bit, useful for relative mappings1571 m = re.match("(//[^/]+/)", self.path)1572if not m:1573die("Path%sdoes not start with //prefix/"% self.path)1574 prefix = m.group(1)1575if not self.is_depot:1576# strip //client/ on client paths1577 self.path = self.path[len(prefix):]15781579deffind_wildcards(self):1580"""Make sure wildcards are valid, and set up internal1581 variables."""15821583 self.ends_triple_dot =False1584# There are three wildcards allowed in p4 views1585# (see "p4 help views"). This code knows how to1586# handle "..." (only at the end), but cannot deal with1587# "%%n" or "*". Only check the depot_side, as p4 should1588# validate that the client_side matches too.1589if re.search(r'%%[1-9]', self.path):1590die("Can't handle%%n wildcards in view:%s"% self.path)1591if self.path.find("*") >=0:1592die("Can't handle * wildcards in view:%s"% self.path)1593 triple_dot_index = self.path.find("...")1594if triple_dot_index >=0:1595if triple_dot_index !=len(self.path) -3:1596die("Can handle only single ... wildcard, at end:%s"%1597 self.path)1598 self.ends_triple_dot =True15991600defensure_compatible(self, other_path):1601"""Make sure the wildcards agree."""1602if self.ends_triple_dot != other_path.ends_triple_dot:1603die("Both paths must end with ... if either does;\n"+1604"paths:%s %s"% (self.path, other_path.path))16051606defmatch_wildcards(self, test_path):1607"""See if this test_path matches us, and fill in the value1608 of the wildcards if so. Returns a tuple of1609 (True|False, wildcards[]). For now, only the ... at end1610 is supported, so at most one wildcard."""1611if self.ends_triple_dot:1612 dotless = self.path[:-3]1613if test_path.startswith(dotless):1614 wildcard = test_path[len(dotless):]1615return(True, [ wildcard ])1616else:1617if test_path == self.path:1618return(True, [])1619return(False, [])16201621defmatch(self, test_path):1622"""Just return if it matches; don't bother with the wildcards."""1623 b, _ = self.match_wildcards(test_path)1624return b16251626deffill_in_wildcards(self, wildcards):1627"""Return the relative path, with the wildcards filled in1628 if there are any."""1629if self.ends_triple_dot:1630return self.path[:-3] + wildcards[0]1631else:1632return self.path16331634classMapping(object):1635def__init__(self, depot_side, client_side, overlay, exclude):1636# depot_side is without the trailing /... if it had one1637 self.depot_side = View.Path(depot_side, is_depot=True)1638 self.client_side = View.Path(client_side, is_depot=False)1639 self.overlay = overlay # started with "+"1640 self.exclude = exclude # started with "-"1641assert not(self.overlay and self.exclude)1642 self.depot_side.ensure_compatible(self.client_side)16431644def__str__(self):1645 c =" "1646if self.overlay:1647 c ="+"1648if self.exclude:1649 c ="-"1650return"View.Mapping:%s%s->%s"% \1651(c, self.depot_side.path, self.client_side.path)16521653defmap_depot_to_client(self, depot_path):1654"""Calculate the client path if using this mapping on the1655 given depot path; does not consider the effect of other1656 mappings in a view. Even excluded mappings are returned."""1657 matches, wildcards = self.depot_side.match_wildcards(depot_path)1658if not matches:1659return""1660 client_path = self.client_side.fill_in_wildcards(wildcards)1661return client_path16621663#1664# View methods1665#1666def__init__(self):1667 self.mappings = []16681669defappend(self, view_line):1670"""Parse a view line, splitting it into depot and client1671 sides. Append to self.mappings, preserving order."""16721673# Split the view line into exactly two words. P4 enforces1674# structure on these lines that simplifies this quite a bit.1675#1676# Either or both words may be double-quoted.1677# Single quotes do not matter.1678# Double-quote marks cannot occur inside the words.1679# A + or - prefix is also inside the quotes.1680# There are no quotes unless they contain a space.1681# The line is already white-space stripped.1682# The two words are separated by a single space.1683#1684if view_line[0] =='"':1685# First word is double quoted. Find its end.1686 close_quote_index = view_line.find('"',1)1687if close_quote_index <=0:1688die("No first-word closing quote found:%s"% view_line)1689 depot_side = view_line[1:close_quote_index]1690# skip closing quote and space1691 rhs_index = close_quote_index +1+11692else:1693 space_index = view_line.find(" ")1694if space_index <=0:1695die("No word-splitting space found:%s"% view_line)1696 depot_side = view_line[0:space_index]1697 rhs_index = space_index +116981699if view_line[rhs_index] =='"':1700# Second word is double quoted. Make sure there is a1701# double quote at the end too.1702if not view_line.endswith('"'):1703die("View line with rhs quote should end with one:%s"%1704 view_line)1705# skip the quotes1706 client_side = view_line[rhs_index+1:-1]1707else:1708 client_side = view_line[rhs_index:]17091710# prefix + means overlay on previous mapping1711 overlay =False1712if depot_side.startswith("+"):1713 overlay =True1714 depot_side = depot_side[1:]17151716# prefix - means exclude this path1717 exclude =False1718if depot_side.startswith("-"):1719 exclude =True1720 depot_side = depot_side[1:]17211722 m = View.Mapping(depot_side, client_side, overlay, exclude)1723 self.mappings.append(m)17241725defmap_in_client(self, depot_path):1726"""Return the relative location in the client where this1727 depot file should live. Returns "" if the file should1728 not be mapped in the client."""17291730 paths_filled = []1731 client_path =""17321733# look at later entries first1734for m in self.mappings[::-1]:17351736# see where will this path end up in the client1737 p = m.map_depot_to_client(depot_path)17381739if p =="":1740# Depot path does not belong in client. Must remember1741# this, as previous items should not cause files to1742# exist in this path either. Remember that the list is1743# being walked from the end, which has higher precedence.1744# Overlap mappings do not exclude previous mappings.1745if not m.overlay:1746 paths_filled.append(m.client_side)17471748else:1749# This mapping matched; no need to search any further.1750# But, the mapping could be rejected if the client path1751# has already been claimed by an earlier mapping (i.e.1752# one later in the list, which we are walking backwards).1753 already_mapped_in_client =False1754for f in paths_filled:1755# this is View.Path.match1756if f.match(p):1757 already_mapped_in_client =True1758break1759if not already_mapped_in_client:1760# Include this file, unless it is from a line that1761# explicitly said to exclude it.1762if not m.exclude:1763 client_path = p17641765# a match, even if rejected, always stops the search1766break17671768return client_path17691770classP4Sync(Command, P4UserMap):1771 delete_actions = ("delete","move/delete","purge")17721773def__init__(self):1774 Command.__init__(self)1775 P4UserMap.__init__(self)1776 self.options = [1777 optparse.make_option("--branch", dest="branch"),1778 optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"),1779 optparse.make_option("--changesfile", dest="changesFile"),1780 optparse.make_option("--silent", dest="silent", action="store_true"),1781 optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),1782 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),1783 optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",1784help="Import into refs/heads/ , not refs/remotes"),1785 optparse.make_option("--max-changes", dest="maxChanges"),1786 optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',1787help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),1788 optparse.make_option("--use-client-spec", dest="useClientSpec", action='store_true',1789help="Only sync files that are included in the Perforce Client Spec")1790]1791 self.description ="""Imports from Perforce into a git repository.\n1792 example:1793 //depot/my/project/ -- to import the current head1794 //depot/my/project/@all -- to import everything1795 //depot/my/project/@1,6 -- to import only from revision 1 to 617961797 (a ... is not needed in the path p4 specification, it's added implicitly)"""17981799 self.usage +=" //depot/path[@revRange]"1800 self.silent =False1801 self.createdBranches =set()1802 self.committedChanges =set()1803 self.branch =""1804 self.detectBranches =False1805 self.detectLabels =False1806 self.importLabels =False1807 self.changesFile =""1808 self.syncWithOrigin =True1809 self.importIntoRemotes =True1810 self.maxChanges =""1811 self.isWindows = (platform.system() =="Windows")1812 self.keepRepoPath =False1813 self.depotPaths =None1814 self.p4BranchesInGit = []1815 self.cloneExclude = []1816 self.useClientSpec =False1817 self.useClientSpec_from_options =False1818 self.clientSpecDirs =None1819 self.tempBranches = []1820 self.tempBranchLocation ="git-p4-tmp"18211822ifgitConfig("git-p4.syncFromOrigin") =="false":1823 self.syncWithOrigin =False18241825# Force a checkpoint in fast-import and wait for it to finish1826defcheckpoint(self):1827 self.gitStream.write("checkpoint\n\n")1828 self.gitStream.write("progress checkpoint\n\n")1829 out = self.gitOutput.readline()1830if self.verbose:1831print"checkpoint finished: "+ out18321833defextractFilesFromCommit(self, commit):1834 self.cloneExclude = [re.sub(r"\.\.\.$","", path)1835for path in self.cloneExclude]1836 files = []1837 fnum =01838while commit.has_key("depotFile%s"% fnum):1839 path = commit["depotFile%s"% fnum]18401841if[p for p in self.cloneExclude1842ifp4PathStartsWith(path, p)]:1843 found =False1844else:1845 found = [p for p in self.depotPaths1846ifp4PathStartsWith(path, p)]1847if not found:1848 fnum = fnum +11849continue18501851file= {}1852file["path"] = path1853file["rev"] = commit["rev%s"% fnum]1854file["action"] = commit["action%s"% fnum]1855file["type"] = commit["type%s"% fnum]1856 files.append(file)1857 fnum = fnum +11858return files18591860defstripRepoPath(self, path, prefixes):1861if self.useClientSpec:1862return self.clientSpecDirs.map_in_client(path)18631864if self.keepRepoPath:1865 prefixes = [re.sub("^(//[^/]+/).*", r'\1', prefixes[0])]18661867for p in prefixes:1868ifp4PathStartsWith(path, p):1869 path = path[len(p):]18701871return path18721873defsplitFilesIntoBranches(self, commit):1874 branches = {}1875 fnum =01876while commit.has_key("depotFile%s"% fnum):1877 path = commit["depotFile%s"% fnum]1878 found = [p for p in self.depotPaths1879ifp4PathStartsWith(path, p)]1880if not found:1881 fnum = fnum +11882continue18831884file= {}1885file["path"] = path1886file["rev"] = commit["rev%s"% fnum]1887file["action"] = commit["action%s"% fnum]1888file["type"] = commit["type%s"% fnum]1889 fnum = fnum +118901891 relPath = self.stripRepoPath(path, self.depotPaths)1892 relPath =wildcard_decode(relPath)18931894for branch in self.knownBranches.keys():18951896# add a trailing slash so that a commit into qt/4.2foo doesn't end up in qt/4.21897if relPath.startswith(branch +"/"):1898if branch not in branches:1899 branches[branch] = []1900 branches[branch].append(file)1901break19021903return branches19041905# output one file from the P4 stream1906# - helper for streamP4Files19071908defstreamOneP4File(self,file, contents):1909 relPath = self.stripRepoPath(file['depotFile'], self.branchPrefixes)1910 relPath =wildcard_decode(relPath)1911if verbose:1912 sys.stderr.write("%s\n"% relPath)19131914(type_base, type_mods) =split_p4_type(file["type"])19151916 git_mode ="100644"1917if"x"in type_mods:1918 git_mode ="100755"1919if type_base =="symlink":1920 git_mode ="120000"1921# p4 print on a symlink contains "target\n"; remove the newline1922 data =''.join(contents)1923 contents = [data[:-1]]19241925if type_base =="utf16":1926# p4 delivers different text in the python output to -G1927# than it does when using "print -o", or normal p4 client1928# operations. utf16 is converted to ascii or utf8, perhaps.1929# But ascii text saved as -t utf16 is completely mangled.1930# Invoke print -o to get the real contents.1931 text =p4_read_pipe(['print','-q','-o','-',file['depotFile']])1932 contents = [ text ]19331934if type_base =="apple":1935# Apple filetype files will be streamed as a concatenation of1936# its appledouble header and the contents. This is useless1937# on both macs and non-macs. If using "print -q -o xx", it1938# will create "xx" with the data, and "%xx" with the header.1939# This is also not very useful.1940#1941# Ideally, someday, this script can learn how to generate1942# appledouble files directly and import those to git, but1943# non-mac machines can never find a use for apple filetype.1944print"\nIgnoring apple filetype file%s"%file['depotFile']1945return19461947# Perhaps windows wants unicode, utf16 newlines translated too;1948# but this is not doing it.1949if self.isWindows and type_base =="text":1950 mangled = []1951for data in contents:1952 data = data.replace("\r\n","\n")1953 mangled.append(data)1954 contents = mangled19551956# Note that we do not try to de-mangle keywords on utf16 files,1957# even though in theory somebody may want that.1958 pattern =p4_keywords_regexp_for_type(type_base, type_mods)1959if pattern:1960 regexp = re.compile(pattern, re.VERBOSE)1961 text =''.join(contents)1962 text = regexp.sub(r'$\1$', text)1963 contents = [ text ]19641965 self.gitStream.write("M%sinline%s\n"% (git_mode, relPath))19661967# total length...1968 length =01969for d in contents:1970 length = length +len(d)19711972 self.gitStream.write("data%d\n"% length)1973for d in contents:1974 self.gitStream.write(d)1975 self.gitStream.write("\n")19761977defstreamOneP4Deletion(self,file):1978 relPath = self.stripRepoPath(file['path'], self.branchPrefixes)1979 relPath =wildcard_decode(relPath)1980if verbose:1981 sys.stderr.write("delete%s\n"% relPath)1982 self.gitStream.write("D%s\n"% relPath)19831984# handle another chunk of streaming data1985defstreamP4FilesCb(self, marshalled):19861987if marshalled.has_key('depotFile')and self.stream_have_file_info:1988# start of a new file - output the old one first1989 self.streamOneP4File(self.stream_file, self.stream_contents)1990 self.stream_file = {}1991 self.stream_contents = []1992 self.stream_have_file_info =False19931994# pick up the new file information... for the1995# 'data' field we need to append to our array1996for k in marshalled.keys():1997if k =='data':1998 self.stream_contents.append(marshalled['data'])1999else:2000 self.stream_file[k] = marshalled[k]20012002 self.stream_have_file_info =True20032004# Stream directly from "p4 files" into "git fast-import"2005defstreamP4Files(self, files):2006 filesForCommit = []2007 filesToRead = []2008 filesToDelete = []20092010for f in files:2011# if using a client spec, only add the files that have2012# a path in the client2013if self.clientSpecDirs:2014if self.clientSpecDirs.map_in_client(f['path']) =="":2015continue20162017 filesForCommit.append(f)2018if f['action']in self.delete_actions:2019 filesToDelete.append(f)2020else:2021 filesToRead.append(f)20222023# deleted files...2024for f in filesToDelete:2025 self.streamOneP4Deletion(f)20262027iflen(filesToRead) >0:2028 self.stream_file = {}2029 self.stream_contents = []2030 self.stream_have_file_info =False20312032# curry self argument2033defstreamP4FilesCbSelf(entry):2034 self.streamP4FilesCb(entry)20352036 fileArgs = ['%s#%s'% (f['path'], f['rev'])for f in filesToRead]20372038p4CmdList(["-x","-","print"],2039 stdin=fileArgs,2040 cb=streamP4FilesCbSelf)20412042# do the last chunk2043if self.stream_file.has_key('depotFile'):2044 self.streamOneP4File(self.stream_file, self.stream_contents)20452046defmake_email(self, userid):2047if userid in self.users:2048return self.users[userid]2049else:2050return"%s<a@b>"% userid20512052# Stream a p4 tag2053defstreamTag(self, gitStream, labelName, labelDetails, commit, epoch):2054if verbose:2055print"writing tag%sfor commit%s"% (labelName, commit)2056 gitStream.write("tag%s\n"% labelName)2057 gitStream.write("from%s\n"% commit)20582059if labelDetails.has_key('Owner'):2060 owner = labelDetails["Owner"]2061else:2062 owner =None20632064# Try to use the owner of the p4 label, or failing that,2065# the current p4 user id.2066if owner:2067 email = self.make_email(owner)2068else:2069 email = self.make_email(self.p4UserId())2070 tagger ="%s %s %s"% (email, epoch, self.tz)20712072 gitStream.write("tagger%s\n"% tagger)20732074print"labelDetails=",labelDetails2075if labelDetails.has_key('Description'):2076 description = labelDetails['Description']2077else:2078 description ='Label from git p4'20792080 gitStream.write("data%d\n"%len(description))2081 gitStream.write(description)2082 gitStream.write("\n")20832084defcommit(self, details, files, branch, branchPrefixes, parent =""):2085 epoch = details["time"]2086 author = details["user"]2087 self.branchPrefixes = branchPrefixes20882089if self.verbose:2090print"commit into%s"% branch20912092# start with reading files; if that fails, we should not2093# create a commit.2094 new_files = []2095for f in files:2096if[p for p in branchPrefixes ifp4PathStartsWith(f['path'], p)]:2097 new_files.append(f)2098else:2099 sys.stderr.write("Ignoring file outside of prefix:%s\n"% f['path'])21002101 self.gitStream.write("commit%s\n"% branch)2102# gitStream.write("mark :%s\n" % details["change"])2103 self.committedChanges.add(int(details["change"]))2104 committer =""2105if author not in self.users:2106 self.getUserMapFromPerforceServer()2107 committer ="%s %s %s"% (self.make_email(author), epoch, self.tz)21082109 self.gitStream.write("committer%s\n"% committer)21102111 self.gitStream.write("data <<EOT\n")2112 self.gitStream.write(details["desc"])2113 self.gitStream.write("\n[git-p4: depot-paths =\"%s\": change =%s"2114% (','.join(branchPrefixes), details["change"]))2115iflen(details['options']) >0:2116 self.gitStream.write(": options =%s"% details['options'])2117 self.gitStream.write("]\nEOT\n\n")21182119iflen(parent) >0:2120if self.verbose:2121print"parent%s"% parent2122 self.gitStream.write("from%s\n"% parent)21232124 self.streamP4Files(new_files)2125 self.gitStream.write("\n")21262127 change =int(details["change"])21282129if self.labels.has_key(change):2130 label = self.labels[change]2131 labelDetails = label[0]2132 labelRevisions = label[1]2133if self.verbose:2134print"Change%sis labelled%s"% (change, labelDetails)21352136 files =p4CmdList(["files"] + ["%s...@%s"% (p, change)2137for p in branchPrefixes])21382139iflen(files) ==len(labelRevisions):21402141 cleanedFiles = {}2142for info in files:2143if info["action"]in self.delete_actions:2144continue2145 cleanedFiles[info["depotFile"]] = info["rev"]21462147if cleanedFiles == labelRevisions:2148 self.streamTag(self.gitStream,'tag_%s'% labelDetails['label'], labelDetails, branch, epoch)21492150else:2151if not self.silent:2152print("Tag%sdoes not match with change%s: files do not match."2153% (labelDetails["label"], change))21542155else:2156if not self.silent:2157print("Tag%sdoes not match with change%s: file count is different."2158% (labelDetails["label"], change))21592160# Build a dictionary of changelists and labels, for "detect-labels" option.2161defgetLabels(self):2162 self.labels = {}21632164 l =p4CmdList(["labels"] + ["%s..."% p for p in self.depotPaths])2165iflen(l) >0and not self.silent:2166print"Finding files belonging to labels in%s"% `self.depotPaths`21672168for output in l:2169 label = output["label"]2170 revisions = {}2171 newestChange =02172if self.verbose:2173print"Querying files for label%s"% label2174forfileinp4CmdList(["files"] +2175["%s...@%s"% (p, label)2176for p in self.depotPaths]):2177 revisions[file["depotFile"]] =file["rev"]2178 change =int(file["change"])2179if change > newestChange:2180 newestChange = change21812182 self.labels[newestChange] = [output, revisions]21832184if self.verbose:2185print"Label changes:%s"% self.labels.keys()21862187# Import p4 labels as git tags. A direct mapping does not2188# exist, so assume that if all the files are at the same revision2189# then we can use that, or it's something more complicated we should2190# just ignore.2191defimportP4Labels(self, stream, p4Labels):2192if verbose:2193print"import p4 labels: "+' '.join(p4Labels)21942195 ignoredP4Labels =gitConfigList("git-p4.ignoredP4Labels")2196 validLabelRegexp =gitConfig("git-p4.labelImportRegexp")2197iflen(validLabelRegexp) ==0:2198 validLabelRegexp = defaultLabelRegexp2199 m = re.compile(validLabelRegexp)22002201for name in p4Labels:2202 commitFound =False22032204if not m.match(name):2205if verbose:2206print"label%sdoes not match regexp%s"% (name,validLabelRegexp)2207continue22082209if name in ignoredP4Labels:2210continue22112212 labelDetails =p4CmdList(['label',"-o", name])[0]22132214# get the most recent changelist for each file in this label2215 change =p4Cmd(["changes","-m","1"] + ["%s...@%s"% (p, name)2216for p in self.depotPaths])22172218if change.has_key('change'):2219# find the corresponding git commit; take the oldest commit2220 changelist =int(change['change'])2221 gitCommit =read_pipe(["git","rev-list","--max-count=1",2222"--reverse",":/\[git-p4:.*change =%d\]"% changelist])2223iflen(gitCommit) ==0:2224print"could not find git commit for changelist%d"% changelist2225else:2226 gitCommit = gitCommit.strip()2227 commitFound =True2228# Convert from p4 time format2229try:2230 tmwhen = time.strptime(labelDetails['Update'],"%Y/%m/%d%H:%M:%S")2231exceptValueError:2232print"Could not convert label time%s"% labelDetail['Update']2233 tmwhen =122342235 when =int(time.mktime(tmwhen))2236 self.streamTag(stream, name, labelDetails, gitCommit, when)2237if verbose:2238print"p4 label%smapped to git commit%s"% (name, gitCommit)2239else:2240if verbose:2241print"Label%shas no changelists - possibly deleted?"% name22422243if not commitFound:2244# We can't import this label; don't try again as it will get very2245# expensive repeatedly fetching all the files for labels that will2246# never be imported. If the label is moved in the future, the2247# ignore will need to be removed manually.2248system(["git","config","--add","git-p4.ignoredP4Labels", name])22492250defguessProjectName(self):2251for p in self.depotPaths:2252if p.endswith("/"):2253 p = p[:-1]2254 p = p[p.strip().rfind("/") +1:]2255if not p.endswith("/"):2256 p +="/"2257return p22582259defgetBranchMapping(self):2260 lostAndFoundBranches =set()22612262 user =gitConfig("git-p4.branchUser")2263iflen(user) >0:2264 command ="branches -u%s"% user2265else:2266 command ="branches"22672268for info inp4CmdList(command):2269 details =p4Cmd(["branch","-o", info["branch"]])2270 viewIdx =02271while details.has_key("View%s"% viewIdx):2272 paths = details["View%s"% viewIdx].split(" ")2273 viewIdx = viewIdx +12274# require standard //depot/foo/... //depot/bar/... mapping2275iflen(paths) !=2or not paths[0].endswith("/...")or not paths[1].endswith("/..."):2276continue2277 source = paths[0]2278 destination = paths[1]2279## HACK2280ifp4PathStartsWith(source, self.depotPaths[0])andp4PathStartsWith(destination, self.depotPaths[0]):2281 source = source[len(self.depotPaths[0]):-4]2282 destination = destination[len(self.depotPaths[0]):-4]22832284if destination in self.knownBranches:2285if not self.silent:2286print"p4 branch%sdefines a mapping from%sto%s"% (info["branch"], source, destination)2287print"but there exists another mapping from%sto%salready!"% (self.knownBranches[destination], destination)2288continue22892290 self.knownBranches[destination] = source22912292 lostAndFoundBranches.discard(destination)22932294if source not in self.knownBranches:2295 lostAndFoundBranches.add(source)22962297# Perforce does not strictly require branches to be defined, so we also2298# check git config for a branch list.2299#2300# Example of branch definition in git config file:2301# [git-p4]2302# branchList=main:branchA2303# branchList=main:branchB2304# branchList=branchA:branchC2305 configBranches =gitConfigList("git-p4.branchList")2306for branch in configBranches:2307if branch:2308(source, destination) = branch.split(":")2309 self.knownBranches[destination] = source23102311 lostAndFoundBranches.discard(destination)23122313if source not in self.knownBranches:2314 lostAndFoundBranches.add(source)231523162317for branch in lostAndFoundBranches:2318 self.knownBranches[branch] = branch23192320defgetBranchMappingFromGitBranches(self):2321 branches =p4BranchesInGit(self.importIntoRemotes)2322for branch in branches.keys():2323if branch =="master":2324 branch ="main"2325else:2326 branch = branch[len(self.projectName):]2327 self.knownBranches[branch] = branch23282329deflistExistingP4GitBranches(self):2330# branches holds mapping from name to commit2331 branches =p4BranchesInGit(self.importIntoRemotes)2332 self.p4BranchesInGit = branches.keys()2333for branch in branches.keys():2334 self.initialParents[self.refPrefix + branch] = branches[branch]23352336defupdateOptionDict(self, d):2337 option_keys = {}2338if self.keepRepoPath:2339 option_keys['keepRepoPath'] =123402341 d["options"] =' '.join(sorted(option_keys.keys()))23422343defreadOptions(self, d):2344 self.keepRepoPath = (d.has_key('options')2345and('keepRepoPath'in d['options']))23462347defgitRefForBranch(self, branch):2348if branch =="main":2349return self.refPrefix +"master"23502351iflen(branch) <=0:2352return branch23532354return self.refPrefix + self.projectName + branch23552356defgitCommitByP4Change(self, ref, change):2357if self.verbose:2358print"looking in ref "+ ref +" for change%susing bisect..."% change23592360 earliestCommit =""2361 latestCommit =parseRevision(ref)23622363while True:2364if self.verbose:2365print"trying: earliest%slatest%s"% (earliestCommit, latestCommit)2366 next =read_pipe("git rev-list --bisect%s %s"% (latestCommit, earliestCommit)).strip()2367iflen(next) ==0:2368if self.verbose:2369print"argh"2370return""2371 log =extractLogMessageFromGitCommit(next)2372 settings =extractSettingsGitLog(log)2373 currentChange =int(settings['change'])2374if self.verbose:2375print"current change%s"% currentChange23762377if currentChange == change:2378if self.verbose:2379print"found%s"% next2380return next23812382if currentChange < change:2383 earliestCommit ="^%s"% next2384else:2385 latestCommit ="%s"% next23862387return""23882389defimportNewBranch(self, branch, maxChange):2390# make fast-import flush all changes to disk and update the refs using the checkpoint2391# command so that we can try to find the branch parent in the git history2392 self.gitStream.write("checkpoint\n\n");2393 self.gitStream.flush();2394 branchPrefix = self.depotPaths[0] + branch +"/"2395range="@1,%s"% maxChange2396#print "prefix" + branchPrefix2397 changes =p4ChangesForPaths([branchPrefix],range)2398iflen(changes) <=0:2399return False2400 firstChange = changes[0]2401#print "first change in branch: %s" % firstChange2402 sourceBranch = self.knownBranches[branch]2403 sourceDepotPath = self.depotPaths[0] + sourceBranch2404 sourceRef = self.gitRefForBranch(sourceBranch)2405#print "source " + sourceBranch24062407 branchParentChange =int(p4Cmd(["changes","-m","1","%s...@1,%s"% (sourceDepotPath, firstChange)])["change"])2408#print "branch parent: %s" % branchParentChange2409 gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)2410iflen(gitParent) >0:2411 self.initialParents[self.gitRefForBranch(branch)] = gitParent2412#print "parent git commit: %s" % gitParent24132414 self.importChanges(changes)2415return True24162417defsearchParent(self, parent, branch, target):2418 parentFound =False2419for blob inread_pipe_lines(["git","rev-list","--reverse","--no-merges", parent]):2420 blob = blob.strip()2421iflen(read_pipe(["git","diff-tree", blob, target])) ==0:2422 parentFound =True2423if self.verbose:2424print"Found parent of%sin commit%s"% (branch, blob)2425break2426if parentFound:2427return blob2428else:2429return None24302431defimportChanges(self, changes):2432 cnt =12433for change in changes:2434 description =p4Cmd(["describe",str(change)])2435 self.updateOptionDict(description)24362437if not self.silent:2438 sys.stdout.write("\rImporting revision%s(%s%%)"% (change, cnt *100/len(changes)))2439 sys.stdout.flush()2440 cnt = cnt +124412442try:2443if self.detectBranches:2444 branches = self.splitFilesIntoBranches(description)2445for branch in branches.keys():2446## HACK --hwn2447 branchPrefix = self.depotPaths[0] + branch +"/"24482449 parent =""24502451 filesForCommit = branches[branch]24522453if self.verbose:2454print"branch is%s"% branch24552456 self.updatedBranches.add(branch)24572458if branch not in self.createdBranches:2459 self.createdBranches.add(branch)2460 parent = self.knownBranches[branch]2461if parent == branch:2462 parent =""2463else:2464 fullBranch = self.projectName + branch2465if fullBranch not in self.p4BranchesInGit:2466if not self.silent:2467print("\nImporting new branch%s"% fullBranch);2468if self.importNewBranch(branch, change -1):2469 parent =""2470 self.p4BranchesInGit.append(fullBranch)2471if not self.silent:2472print("\nResuming with change%s"% change);24732474if self.verbose:2475print"parent determined through known branches:%s"% parent24762477 branch = self.gitRefForBranch(branch)2478 parent = self.gitRefForBranch(parent)24792480if self.verbose:2481print"looking for initial parent for%s; current parent is%s"% (branch, parent)24822483iflen(parent) ==0and branch in self.initialParents:2484 parent = self.initialParents[branch]2485del self.initialParents[branch]24862487 blob =None2488iflen(parent) >0:2489 tempBranch = os.path.join(self.tempBranchLocation,"%d"% (change))2490if self.verbose:2491print"Creating temporary branch: "+ tempBranch2492 self.commit(description, filesForCommit, tempBranch, [branchPrefix])2493 self.tempBranches.append(tempBranch)2494 self.checkpoint()2495 blob = self.searchParent(parent, branch, tempBranch)2496if blob:2497 self.commit(description, filesForCommit, branch, [branchPrefix], blob)2498else:2499if self.verbose:2500print"Parent of%snot found. Committing into head of%s"% (branch, parent)2501 self.commit(description, filesForCommit, branch, [branchPrefix], parent)2502else:2503 files = self.extractFilesFromCommit(description)2504 self.commit(description, files, self.branch, self.depotPaths,2505 self.initialParent)2506 self.initialParent =""2507exceptIOError:2508print self.gitError.read()2509 sys.exit(1)25102511defimportHeadRevision(self, revision):2512print"Doing initial import of%sfrom revision%sinto%s"% (' '.join(self.depotPaths), revision, self.branch)25132514 details = {}2515 details["user"] ="git perforce import user"2516 details["desc"] = ("Initial import of%sfrom the state at revision%s\n"2517% (' '.join(self.depotPaths), revision))2518 details["change"] = revision2519 newestRevision =025202521 fileCnt =02522 fileArgs = ["%s...%s"% (p,revision)for p in self.depotPaths]25232524for info inp4CmdList(["files"] + fileArgs):25252526if'code'in info and info['code'] =='error':2527 sys.stderr.write("p4 returned an error:%s\n"2528% info['data'])2529if info['data'].find("must refer to client") >=0:2530 sys.stderr.write("This particular p4 error is misleading.\n")2531 sys.stderr.write("Perhaps the depot path was misspelled.\n");2532 sys.stderr.write("Depot path:%s\n"%" ".join(self.depotPaths))2533 sys.exit(1)2534if'p4ExitCode'in info:2535 sys.stderr.write("p4 exitcode:%s\n"% info['p4ExitCode'])2536 sys.exit(1)253725382539 change =int(info["change"])2540if change > newestRevision:2541 newestRevision = change25422543if info["action"]in self.delete_actions:2544# don't increase the file cnt, otherwise details["depotFile123"] will have gaps!2545#fileCnt = fileCnt + 12546continue25472548for prop in["depotFile","rev","action","type"]:2549 details["%s%s"% (prop, fileCnt)] = info[prop]25502551 fileCnt = fileCnt +125522553 details["change"] = newestRevision25542555# Use time from top-most change so that all git p4 clones of2556# the same p4 repo have the same commit SHA1s.2557 res =p4CmdList("describe -s%d"% newestRevision)2558 newestTime =None2559for r in res:2560if r.has_key('time'):2561 newestTime =int(r['time'])2562if newestTime is None:2563die("\"describe -s\"on newest change%ddid not give a time")2564 details["time"] = newestTime25652566 self.updateOptionDict(details)2567try:2568 self.commit(details, self.extractFilesFromCommit(details), self.branch, self.depotPaths)2569exceptIOError:2570print"IO error with git fast-import. Is your git version recent enough?"2571print self.gitError.read()257225732574defrun(self, args):2575 self.depotPaths = []2576 self.changeRange =""2577 self.initialParent =""2578 self.previousDepotPaths = []25792580# map from branch depot path to parent branch2581 self.knownBranches = {}2582 self.initialParents = {}2583 self.hasOrigin =originP4BranchesExist()2584if not self.syncWithOrigin:2585 self.hasOrigin =False25862587if self.importIntoRemotes:2588 self.refPrefix ="refs/remotes/p4/"2589else:2590 self.refPrefix ="refs/heads/p4/"25912592if self.syncWithOrigin and self.hasOrigin:2593if not self.silent:2594print"Syncing with origin first by calling git fetch origin"2595system("git fetch origin")25962597iflen(self.branch) ==0:2598 self.branch = self.refPrefix +"master"2599ifgitBranchExists("refs/heads/p4")and self.importIntoRemotes:2600system("git update-ref%srefs/heads/p4"% self.branch)2601system("git branch -D p4");2602# create it /after/ importing, when master exists2603if notgitBranchExists(self.refPrefix +"HEAD")and self.importIntoRemotes andgitBranchExists(self.branch):2604system("git symbolic-ref%sHEAD%s"% (self.refPrefix, self.branch))26052606# accept either the command-line option, or the configuration variable2607if self.useClientSpec:2608# will use this after clone to set the variable2609 self.useClientSpec_from_options =True2610else:2611ifgitConfig("git-p4.useclientspec","--bool") =="true":2612 self.useClientSpec =True2613if self.useClientSpec:2614 self.clientSpecDirs =getClientSpec()26152616# TODO: should always look at previous commits,2617# merge with previous imports, if possible.2618if args == []:2619if self.hasOrigin:2620createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)2621 self.listExistingP4GitBranches()26222623iflen(self.p4BranchesInGit) >1:2624if not self.silent:2625print"Importing from/into multiple branches"2626 self.detectBranches =True26272628if self.verbose:2629print"branches:%s"% self.p4BranchesInGit26302631 p4Change =02632for branch in self.p4BranchesInGit:2633 logMsg =extractLogMessageFromGitCommit(self.refPrefix + branch)26342635 settings =extractSettingsGitLog(logMsg)26362637 self.readOptions(settings)2638if(settings.has_key('depot-paths')2639and settings.has_key('change')):2640 change =int(settings['change']) +12641 p4Change =max(p4Change, change)26422643 depotPaths =sorted(settings['depot-paths'])2644if self.previousDepotPaths == []:2645 self.previousDepotPaths = depotPaths2646else:2647 paths = []2648for(prev, cur)inzip(self.previousDepotPaths, depotPaths):2649 prev_list = prev.split("/")2650 cur_list = cur.split("/")2651for i inrange(0,min(len(cur_list),len(prev_list))):2652if cur_list[i] <> prev_list[i]:2653 i = i -12654break26552656 paths.append("/".join(cur_list[:i +1]))26572658 self.previousDepotPaths = paths26592660if p4Change >0:2661 self.depotPaths =sorted(self.previousDepotPaths)2662 self.changeRange ="@%s,#head"% p4Change2663if not self.detectBranches:2664 self.initialParent =parseRevision(self.branch)2665if not self.silent and not self.detectBranches:2666print"Performing incremental import into%sgit branch"% self.branch26672668if not self.branch.startswith("refs/"):2669 self.branch ="refs/heads/"+ self.branch26702671iflen(args) ==0and self.depotPaths:2672if not self.silent:2673print"Depot paths:%s"%' '.join(self.depotPaths)2674else:2675if self.depotPaths and self.depotPaths != args:2676print("previous import used depot path%sand now%swas specified. "2677"This doesn't work!"% (' '.join(self.depotPaths),2678' '.join(args)))2679 sys.exit(1)26802681 self.depotPaths =sorted(args)26822683 revision =""2684 self.users = {}26852686# Make sure no revision specifiers are used when --changesfile2687# is specified.2688 bad_changesfile =False2689iflen(self.changesFile) >0:2690for p in self.depotPaths:2691if p.find("@") >=0or p.find("#") >=0:2692 bad_changesfile =True2693break2694if bad_changesfile:2695die("Option --changesfile is incompatible with revision specifiers")26962697 newPaths = []2698for p in self.depotPaths:2699if p.find("@") != -1:2700 atIdx = p.index("@")2701 self.changeRange = p[atIdx:]2702if self.changeRange =="@all":2703 self.changeRange =""2704elif','not in self.changeRange:2705 revision = self.changeRange2706 self.changeRange =""2707 p = p[:atIdx]2708elif p.find("#") != -1:2709 hashIdx = p.index("#")2710 revision = p[hashIdx:]2711 p = p[:hashIdx]2712elif self.previousDepotPaths == []:2713# pay attention to changesfile, if given, else import2714# the entire p4 tree at the head revision2715iflen(self.changesFile) ==0:2716 revision ="#head"27172718 p = re.sub("\.\.\.$","", p)2719if not p.endswith("/"):2720 p +="/"27212722 newPaths.append(p)27232724 self.depotPaths = newPaths27252726 self.loadUserMapFromCache()2727 self.labels = {}2728if self.detectLabels:2729 self.getLabels();27302731if self.detectBranches:2732## FIXME - what's a P4 projectName ?2733 self.projectName = self.guessProjectName()27342735if self.hasOrigin:2736 self.getBranchMappingFromGitBranches()2737else:2738 self.getBranchMapping()2739if self.verbose:2740print"p4-git branches:%s"% self.p4BranchesInGit2741print"initial parents:%s"% self.initialParents2742for b in self.p4BranchesInGit:2743if b !="master":27442745## FIXME2746 b = b[len(self.projectName):]2747 self.createdBranches.add(b)27482749 self.tz ="%+03d%02d"% (- time.timezone /3600, ((- time.timezone %3600) /60))27502751 importProcess = subprocess.Popen(["git","fast-import"],2752 stdin=subprocess.PIPE, stdout=subprocess.PIPE,2753 stderr=subprocess.PIPE);2754 self.gitOutput = importProcess.stdout2755 self.gitStream = importProcess.stdin2756 self.gitError = importProcess.stderr27572758if revision:2759 self.importHeadRevision(revision)2760else:2761 changes = []27622763iflen(self.changesFile) >0:2764 output =open(self.changesFile).readlines()2765 changeSet =set()2766for line in output:2767 changeSet.add(int(line))27682769for change in changeSet:2770 changes.append(change)27712772 changes.sort()2773else:2774# catch "git p4 sync" with no new branches, in a repo that2775# does not have any existing p4 branches2776iflen(args) ==0and not self.p4BranchesInGit:2777die("No remote p4 branches. Perhaps you never did\"git p4 clone\"in here.");2778if self.verbose:2779print"Getting p4 changes for%s...%s"% (', '.join(self.depotPaths),2780 self.changeRange)2781 changes =p4ChangesForPaths(self.depotPaths, self.changeRange)27822783iflen(self.maxChanges) >0:2784 changes = changes[:min(int(self.maxChanges),len(changes))]27852786iflen(changes) ==0:2787if not self.silent:2788print"No changes to import!"2789else:2790if not self.silent and not self.detectBranches:2791print"Import destination:%s"% self.branch27922793 self.updatedBranches =set()27942795 self.importChanges(changes)27962797if not self.silent:2798print""2799iflen(self.updatedBranches) >0:2800 sys.stdout.write("Updated branches: ")2801for b in self.updatedBranches:2802 sys.stdout.write("%s"% b)2803 sys.stdout.write("\n")28042805ifgitConfig("git-p4.importLabels","--bool") =="true":2806 self.importLabels =True28072808if self.importLabels:2809 p4Labels =getP4Labels(self.depotPaths)2810 gitTags =getGitTags()28112812 missingP4Labels = p4Labels - gitTags2813 self.importP4Labels(self.gitStream, missingP4Labels)28142815 self.gitStream.close()2816if importProcess.wait() !=0:2817die("fast-import failed:%s"% self.gitError.read())2818 self.gitOutput.close()2819 self.gitError.close()28202821# Cleanup temporary branches created during import2822if self.tempBranches != []:2823for branch in self.tempBranches:2824read_pipe("git update-ref -d%s"% branch)2825 os.rmdir(os.path.join(os.environ.get("GIT_DIR",".git"), self.tempBranchLocation))28262827return True28282829classP4Rebase(Command):2830def__init__(self):2831 Command.__init__(self)2832 self.options = [2833 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),2834]2835 self.importLabels =False2836 self.description = ("Fetches the latest revision from perforce and "2837+"rebases the current work (branch) against it")28382839defrun(self, args):2840 sync =P4Sync()2841 sync.importLabels = self.importLabels2842 sync.run([])28432844return self.rebase()28452846defrebase(self):2847if os.system("git update-index --refresh") !=0:2848die("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.");2849iflen(read_pipe("git diff-index HEAD --")) >0:2850die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");28512852[upstream, settings] =findUpstreamBranchPoint()2853iflen(upstream) ==0:2854die("Cannot find upstream branchpoint for rebase")28552856# the branchpoint may be p4/foo~3, so strip off the parent2857 upstream = re.sub("~[0-9]+$","", upstream)28582859print"Rebasing the current branch onto%s"% upstream2860 oldHead =read_pipe("git rev-parse HEAD").strip()2861system("git rebase%s"% upstream)2862system("git diff-tree --stat --summary -M%sHEAD"% oldHead)2863return True28642865classP4Clone(P4Sync):2866def__init__(self):2867 P4Sync.__init__(self)2868 self.description ="Creates a new git repository and imports from Perforce into it"2869 self.usage ="usage: %prog [options] //depot/path[@revRange]"2870 self.options += [2871 optparse.make_option("--destination", dest="cloneDestination",2872 action='store', default=None,2873help="where to leave result of the clone"),2874 optparse.make_option("-/", dest="cloneExclude",2875 action="append",type="string",2876help="exclude depot path"),2877 optparse.make_option("--bare", dest="cloneBare",2878 action="store_true", default=False),2879]2880 self.cloneDestination =None2881 self.needsGit =False2882 self.cloneBare =False28832884# This is required for the "append" cloneExclude action2885defensure_value(self, attr, value):2886if nothasattr(self, attr)orgetattr(self, attr)is None:2887setattr(self, attr, value)2888returngetattr(self, attr)28892890defdefaultDestination(self, args):2891## TODO: use common prefix of args?2892 depotPath = args[0]2893 depotDir = re.sub("(@[^@]*)$","", depotPath)2894 depotDir = re.sub("(#[^#]*)$","", depotDir)2895 depotDir = re.sub(r"\.\.\.$","", depotDir)2896 depotDir = re.sub(r"/$","", depotDir)2897return os.path.split(depotDir)[1]28982899defrun(self, args):2900iflen(args) <1:2901return False29022903if self.keepRepoPath and not self.cloneDestination:2904 sys.stderr.write("Must specify destination for --keep-path\n")2905 sys.exit(1)29062907 depotPaths = args29082909if not self.cloneDestination andlen(depotPaths) >1:2910 self.cloneDestination = depotPaths[-1]2911 depotPaths = depotPaths[:-1]29122913 self.cloneExclude = ["/"+p for p in self.cloneExclude]2914for p in depotPaths:2915if not p.startswith("//"):2916return False29172918if not self.cloneDestination:2919 self.cloneDestination = self.defaultDestination(args)29202921print"Importing from%sinto%s"% (', '.join(depotPaths), self.cloneDestination)29222923if not os.path.exists(self.cloneDestination):2924 os.makedirs(self.cloneDestination)2925chdir(self.cloneDestination)29262927 init_cmd = ["git","init"]2928if self.cloneBare:2929 init_cmd.append("--bare")2930 subprocess.check_call(init_cmd)29312932if not P4Sync.run(self, depotPaths):2933return False2934if self.branch !="master":2935if self.importIntoRemotes:2936 masterbranch ="refs/remotes/p4/master"2937else:2938 masterbranch ="refs/heads/p4/master"2939ifgitBranchExists(masterbranch):2940system("git branch master%s"% masterbranch)2941if not self.cloneBare:2942system("git checkout -f")2943else:2944print"Could not detect main branch. No checkout/master branch created."29452946# auto-set this variable if invoked with --use-client-spec2947if self.useClientSpec_from_options:2948system("git config --bool git-p4.useclientspec true")29492950return True29512952classP4Branches(Command):2953def__init__(self):2954 Command.__init__(self)2955 self.options = [ ]2956 self.description = ("Shows the git branches that hold imports and their "2957+"corresponding perforce depot paths")2958 self.verbose =False29592960defrun(self, args):2961iforiginP4BranchesExist():2962createOrUpdateBranchesFromOrigin()29632964 cmdline ="git rev-parse --symbolic "2965 cmdline +=" --remotes"29662967for line inread_pipe_lines(cmdline):2968 line = line.strip()29692970if not line.startswith('p4/')or line =="p4/HEAD":2971continue2972 branch = line29732974 log =extractLogMessageFromGitCommit("refs/remotes/%s"% branch)2975 settings =extractSettingsGitLog(log)29762977print"%s<=%s(%s)"% (branch,",".join(settings["depot-paths"]), settings["change"])2978return True29792980classHelpFormatter(optparse.IndentedHelpFormatter):2981def__init__(self):2982 optparse.IndentedHelpFormatter.__init__(self)29832984defformat_description(self, description):2985if description:2986return description +"\n"2987else:2988return""29892990defprintUsage(commands):2991print"usage:%s<command> [options]"% sys.argv[0]2992print""2993print"valid commands:%s"%", ".join(commands)2994print""2995print"Try%s<command> --help for command specific help."% sys.argv[0]2996print""29972998commands = {2999"debug": P4Debug,3000"submit": P4Submit,3001"commit": P4Submit,3002"sync": P4Sync,3003"rebase": P4Rebase,3004"clone": P4Clone,3005"rollback": P4RollBack,3006"branches": P4Branches3007}300830093010defmain():3011iflen(sys.argv[1:]) ==0:3012printUsage(commands.keys())3013 sys.exit(2)30143015 cmd =""3016 cmdName = sys.argv[1]3017try:3018 klass = commands[cmdName]3019 cmd =klass()3020exceptKeyError:3021print"unknown command%s"% cmdName3022print""3023printUsage(commands.keys())3024 sys.exit(2)30253026 options = cmd.options3027 cmd.gitdir = os.environ.get("GIT_DIR",None)30283029 args = sys.argv[2:]30303031 options.append(optparse.make_option("--verbose","-v", dest="verbose", action="store_true"))3032if cmd.needsGit:3033 options.append(optparse.make_option("--git-dir", dest="gitdir"))30343035 parser = optparse.OptionParser(cmd.usage.replace("%prog","%prog "+ cmdName),3036 options,3037 description = cmd.description,3038 formatter =HelpFormatter())30393040(cmd, args) = parser.parse_args(sys.argv[2:], cmd);3041global verbose3042 verbose = cmd.verbose3043if cmd.needsGit:3044if cmd.gitdir ==None:3045 cmd.gitdir = os.path.abspath(".git")3046if notisValidGitDir(cmd.gitdir):3047 cmd.gitdir =read_pipe("git rev-parse --git-dir").strip()3048if os.path.exists(cmd.gitdir):3049 cdup =read_pipe("git rev-parse --show-cdup").strip()3050iflen(cdup) >0:3051chdir(cdup);30523053if notisValidGitDir(cmd.gitdir):3054ifisValidGitDir(cmd.gitdir +"/.git"):3055 cmd.gitdir +="/.git"3056else:3057die("fatal: cannot locate git repository at%s"% cmd.gitdir)30583059 os.environ["GIT_DIR"] = cmd.gitdir30603061if not cmd.run(args):3062 parser.print_help()3063 sys.exit(2)306430653066if __name__ =='__main__':3067main()