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)13071308 os.remove(fileName)1309return ret13101311# Export git tags as p4 labels. Create a p4 label and then tag1312# with that.1313defexportGitTags(self, gitTags):1314 validLabelRegexp =gitConfig("git-p4.labelExportRegexp")1315iflen(validLabelRegexp) ==0:1316 validLabelRegexp = defaultLabelRegexp1317 m = re.compile(validLabelRegexp)13181319for name in gitTags:13201321if not m.match(name):1322if verbose:1323print"tag%sdoes not match regexp%s"% (name, validLabelRegexp)1324continue13251326# Get the p4 commit this corresponds to1327 logMessage =extractLogMessageFromGitCommit(name)1328 values =extractSettingsGitLog(logMessage)13291330if not values.has_key('change'):1331# a tag pointing to something not sent to p4; ignore1332if verbose:1333print"git tag%sdoes not give a p4 commit"% name1334continue1335else:1336 changelist = values['change']13371338# Get the tag details.1339 inHeader =True1340 isAnnotated =False1341 body = []1342for l inread_pipe_lines(["git","cat-file","-p", name]):1343 l = l.strip()1344if inHeader:1345if re.match(r'tag\s+', l):1346 isAnnotated =True1347elif re.match(r'\s*$', l):1348 inHeader =False1349continue1350else:1351 body.append(l)13521353if not isAnnotated:1354 body = ["lightweight tag imported by git p4\n"]13551356# Create the label - use the same view as the client spec we are using1357 clientSpec =getClientSpec()13581359 labelTemplate ="Label:%s\n"% name1360 labelTemplate +="Description:\n"1361for b in body:1362 labelTemplate +="\t"+ b +"\n"1363 labelTemplate +="View:\n"1364for mapping in clientSpec.mappings:1365 labelTemplate +="\t%s\n"% mapping.depot_side.path13661367p4_write_pipe(["label","-i"], labelTemplate)13681369# Use the label1370p4_system(["tag","-l", name] +1371["%s@%s"% (mapping.depot_side.path, changelist)for mapping in clientSpec.mappings])13721373if verbose:1374print"created p4 label for tag%s"% name13751376defrun(self, args):1377iflen(args) ==0:1378 self.master =currentGitBranch()1379iflen(self.master) ==0or notgitBranchExists("refs/heads/%s"% self.master):1380die("Detecting current git branch failed!")1381eliflen(args) ==1:1382 self.master = args[0]1383if notbranchExists(self.master):1384die("Branch%sdoes not exist"% self.master)1385else:1386return False13871388 allowSubmit =gitConfig("git-p4.allowSubmit")1389iflen(allowSubmit) >0and not self.master in allowSubmit.split(","):1390die("%sis not in git-p4.allowSubmit"% self.master)13911392[upstream, settings] =findUpstreamBranchPoint()1393 self.depotPath = settings['depot-paths'][0]1394iflen(self.origin) ==0:1395 self.origin = upstream13961397if self.preserveUser:1398if not self.canChangeChangelists():1399die("Cannot preserve user names without p4 super-user or admin permissions")14001401if self.verbose:1402print"Origin branch is "+ self.origin14031404iflen(self.depotPath) ==0:1405print"Internal error: cannot locate perforce depot path from existing branches"1406 sys.exit(128)14071408 self.useClientSpec =False1409ifgitConfig("git-p4.useclientspec","--bool") =="true":1410 self.useClientSpec =True1411if self.useClientSpec:1412 self.clientSpecDirs =getClientSpec()14131414if self.useClientSpec:1415# all files are relative to the client spec1416 self.clientPath =getClientRoot()1417else:1418 self.clientPath =p4Where(self.depotPath)14191420if self.clientPath =="":1421die("Error: Cannot locate perforce checkout of%sin client view"% self.depotPath)14221423print"Perforce checkout for depot path%slocated at%s"% (self.depotPath, self.clientPath)1424 self.oldWorkingDirectory = os.getcwd()14251426# ensure the clientPath exists1427 new_client_dir =False1428if not os.path.exists(self.clientPath):1429 new_client_dir =True1430 os.makedirs(self.clientPath)14311432chdir(self.clientPath)1433print"Synchronizing p4 checkout..."1434if new_client_dir:1435# old one was destroyed, and maybe nobody told p41436p4_sync("...","-f")1437else:1438p4_sync("...")1439 self.check()14401441 commits = []1442for line inread_pipe_lines("git rev-list --no-merges%s..%s"% (self.origin, self.master)):1443 commits.append(line.strip())1444 commits.reverse()14451446if self.preserveUser or(gitConfig("git-p4.skipUserNameCheck") =="true"):1447 self.checkAuthorship =False1448else:1449 self.checkAuthorship =True14501451if self.preserveUser:1452 self.checkValidP4Users(commits)14531454#1455# Build up a set of options to be passed to diff when1456# submitting each commit to p4.1457#1458if self.detectRenames:1459# command-line -M arg1460 self.diffOpts ="-M"1461else:1462# If not explicitly set check the config variable1463 detectRenames =gitConfig("git-p4.detectRenames")14641465if detectRenames.lower() =="false"or detectRenames =="":1466 self.diffOpts =""1467elif detectRenames.lower() =="true":1468 self.diffOpts ="-M"1469else:1470 self.diffOpts ="-M%s"% detectRenames14711472# no command-line arg for -C or --find-copies-harder, just1473# config variables1474 detectCopies =gitConfig("git-p4.detectCopies")1475if detectCopies.lower() =="false"or detectCopies =="":1476pass1477elif detectCopies.lower() =="true":1478 self.diffOpts +=" -C"1479else:1480 self.diffOpts +=" -C%s"% detectCopies14811482ifgitConfig("git-p4.detectCopiesHarder","--bool") =="true":1483 self.diffOpts +=" --find-copies-harder"14841485#1486# Apply the commits, one at a time. On failure, ask if should1487# continue to try the rest of the patches, or quit.1488#1489 applied = []1490 last =len(commits) -11491for i, commit inenumerate(commits):1492 ok = self.applyCommit(commit)1493if ok:1494 applied.append(commit)1495else:1496if i < last:1497 quit =False1498while True:1499print"What do you want to do?"1500 response =raw_input("[s]kip this commit but apply"1501" the rest, or [q]uit? ")1502if not response:1503continue1504if response[0] =="s":1505print"Skipping this commit, but applying the rest"1506break1507if response[0] =="q":1508print"Quitting"1509 quit =True1510break1511if quit:1512break15131514chdir(self.oldWorkingDirectory)15151516iflen(commits) ==len(applied):1517print"All commits applied!"15181519 sync =P4Sync()1520 sync.run([])15211522 rebase =P4Rebase()1523 rebase.rebase()15241525else:1526iflen(applied) ==0:1527print"No commits applied."1528else:1529print"Applied only the commits marked with '*':"1530for c in commits:1531if c in applied:1532 star ="*"1533else:1534 star =" "1535print star,read_pipe(["git","show","-s",1536"--format=format:%h%s", c])1537print"You will have to do 'git p4 sync' and rebase."15381539ifgitConfig("git-p4.exportLabels","--bool") =="true":1540 self.exportLabels =True15411542if self.exportLabels:1543 p4Labels =getP4Labels(self.depotPath)1544 gitTags =getGitTags()15451546 missingGitTags = gitTags - p4Labels1547 self.exportGitTags(missingGitTags)15481549# exit with error unless everything applied perfecly1550iflen(commits) !=len(applied):1551 sys.exit(1)15521553return True15541555classView(object):1556"""Represent a p4 view ("p4 help views"), and map files in a1557 repo according to the view."""15581559classPath(object):1560"""A depot or client path, possibly containing wildcards.1561 The only one supported is ... at the end, currently.1562 Initialize with the full path, with //depot or //client."""15631564def__init__(self, path, is_depot):1565 self.path = path1566 self.is_depot = is_depot1567 self.find_wildcards()1568# remember the prefix bit, useful for relative mappings1569 m = re.match("(//[^/]+/)", self.path)1570if not m:1571die("Path%sdoes not start with //prefix/"% self.path)1572 prefix = m.group(1)1573if not self.is_depot:1574# strip //client/ on client paths1575 self.path = self.path[len(prefix):]15761577deffind_wildcards(self):1578"""Make sure wildcards are valid, and set up internal1579 variables."""15801581 self.ends_triple_dot =False1582# There are three wildcards allowed in p4 views1583# (see "p4 help views"). This code knows how to1584# handle "..." (only at the end), but cannot deal with1585# "%%n" or "*". Only check the depot_side, as p4 should1586# validate that the client_side matches too.1587if re.search(r'%%[1-9]', self.path):1588die("Can't handle%%n wildcards in view:%s"% self.path)1589if self.path.find("*") >=0:1590die("Can't handle * wildcards in view:%s"% self.path)1591 triple_dot_index = self.path.find("...")1592if triple_dot_index >=0:1593if triple_dot_index !=len(self.path) -3:1594die("Can handle only single ... wildcard, at end:%s"%1595 self.path)1596 self.ends_triple_dot =True15971598defensure_compatible(self, other_path):1599"""Make sure the wildcards agree."""1600if self.ends_triple_dot != other_path.ends_triple_dot:1601die("Both paths must end with ... if either does;\n"+1602"paths:%s %s"% (self.path, other_path.path))16031604defmatch_wildcards(self, test_path):1605"""See if this test_path matches us, and fill in the value1606 of the wildcards if so. Returns a tuple of1607 (True|False, wildcards[]). For now, only the ... at end1608 is supported, so at most one wildcard."""1609if self.ends_triple_dot:1610 dotless = self.path[:-3]1611if test_path.startswith(dotless):1612 wildcard = test_path[len(dotless):]1613return(True, [ wildcard ])1614else:1615if test_path == self.path:1616return(True, [])1617return(False, [])16181619defmatch(self, test_path):1620"""Just return if it matches; don't bother with the wildcards."""1621 b, _ = self.match_wildcards(test_path)1622return b16231624deffill_in_wildcards(self, wildcards):1625"""Return the relative path, with the wildcards filled in1626 if there are any."""1627if self.ends_triple_dot:1628return self.path[:-3] + wildcards[0]1629else:1630return self.path16311632classMapping(object):1633def__init__(self, depot_side, client_side, overlay, exclude):1634# depot_side is without the trailing /... if it had one1635 self.depot_side = View.Path(depot_side, is_depot=True)1636 self.client_side = View.Path(client_side, is_depot=False)1637 self.overlay = overlay # started with "+"1638 self.exclude = exclude # started with "-"1639assert not(self.overlay and self.exclude)1640 self.depot_side.ensure_compatible(self.client_side)16411642def__str__(self):1643 c =" "1644if self.overlay:1645 c ="+"1646if self.exclude:1647 c ="-"1648return"View.Mapping:%s%s->%s"% \1649(c, self.depot_side.path, self.client_side.path)16501651defmap_depot_to_client(self, depot_path):1652"""Calculate the client path if using this mapping on the1653 given depot path; does not consider the effect of other1654 mappings in a view. Even excluded mappings are returned."""1655 matches, wildcards = self.depot_side.match_wildcards(depot_path)1656if not matches:1657return""1658 client_path = self.client_side.fill_in_wildcards(wildcards)1659return client_path16601661#1662# View methods1663#1664def__init__(self):1665 self.mappings = []16661667defappend(self, view_line):1668"""Parse a view line, splitting it into depot and client1669 sides. Append to self.mappings, preserving order."""16701671# Split the view line into exactly two words. P4 enforces1672# structure on these lines that simplifies this quite a bit.1673#1674# Either or both words may be double-quoted.1675# Single quotes do not matter.1676# Double-quote marks cannot occur inside the words.1677# A + or - prefix is also inside the quotes.1678# There are no quotes unless they contain a space.1679# The line is already white-space stripped.1680# The two words are separated by a single space.1681#1682if view_line[0] =='"':1683# First word is double quoted. Find its end.1684 close_quote_index = view_line.find('"',1)1685if close_quote_index <=0:1686die("No first-word closing quote found:%s"% view_line)1687 depot_side = view_line[1:close_quote_index]1688# skip closing quote and space1689 rhs_index = close_quote_index +1+11690else:1691 space_index = view_line.find(" ")1692if space_index <=0:1693die("No word-splitting space found:%s"% view_line)1694 depot_side = view_line[0:space_index]1695 rhs_index = space_index +116961697if view_line[rhs_index] =='"':1698# Second word is double quoted. Make sure there is a1699# double quote at the end too.1700if not view_line.endswith('"'):1701die("View line with rhs quote should end with one:%s"%1702 view_line)1703# skip the quotes1704 client_side = view_line[rhs_index+1:-1]1705else:1706 client_side = view_line[rhs_index:]17071708# prefix + means overlay on previous mapping1709 overlay =False1710if depot_side.startswith("+"):1711 overlay =True1712 depot_side = depot_side[1:]17131714# prefix - means exclude this path1715 exclude =False1716if depot_side.startswith("-"):1717 exclude =True1718 depot_side = depot_side[1:]17191720 m = View.Mapping(depot_side, client_side, overlay, exclude)1721 self.mappings.append(m)17221723defmap_in_client(self, depot_path):1724"""Return the relative location in the client where this1725 depot file should live. Returns "" if the file should1726 not be mapped in the client."""17271728 paths_filled = []1729 client_path =""17301731# look at later entries first1732for m in self.mappings[::-1]:17331734# see where will this path end up in the client1735 p = m.map_depot_to_client(depot_path)17361737if p =="":1738# Depot path does not belong in client. Must remember1739# this, as previous items should not cause files to1740# exist in this path either. Remember that the list is1741# being walked from the end, which has higher precedence.1742# Overlap mappings do not exclude previous mappings.1743if not m.overlay:1744 paths_filled.append(m.client_side)17451746else:1747# This mapping matched; no need to search any further.1748# But, the mapping could be rejected if the client path1749# has already been claimed by an earlier mapping (i.e.1750# one later in the list, which we are walking backwards).1751 already_mapped_in_client =False1752for f in paths_filled:1753# this is View.Path.match1754if f.match(p):1755 already_mapped_in_client =True1756break1757if not already_mapped_in_client:1758# Include this file, unless it is from a line that1759# explicitly said to exclude it.1760if not m.exclude:1761 client_path = p17621763# a match, even if rejected, always stops the search1764break17651766return client_path17671768classP4Sync(Command, P4UserMap):1769 delete_actions = ("delete","move/delete","purge")17701771def__init__(self):1772 Command.__init__(self)1773 P4UserMap.__init__(self)1774 self.options = [1775 optparse.make_option("--branch", dest="branch"),1776 optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"),1777 optparse.make_option("--changesfile", dest="changesFile"),1778 optparse.make_option("--silent", dest="silent", action="store_true"),1779 optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),1780 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),1781 optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",1782help="Import into refs/heads/ , not refs/remotes"),1783 optparse.make_option("--max-changes", dest="maxChanges"),1784 optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',1785help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),1786 optparse.make_option("--use-client-spec", dest="useClientSpec", action='store_true',1787help="Only sync files that are included in the Perforce Client Spec")1788]1789 self.description ="""Imports from Perforce into a git repository.\n1790 example:1791 //depot/my/project/ -- to import the current head1792 //depot/my/project/@all -- to import everything1793 //depot/my/project/@1,6 -- to import only from revision 1 to 617941795 (a ... is not needed in the path p4 specification, it's added implicitly)"""17961797 self.usage +=" //depot/path[@revRange]"1798 self.silent =False1799 self.createdBranches =set()1800 self.committedChanges =set()1801 self.branch =""1802 self.detectBranches =False1803 self.detectLabels =False1804 self.importLabels =False1805 self.changesFile =""1806 self.syncWithOrigin =True1807 self.importIntoRemotes =True1808 self.maxChanges =""1809 self.isWindows = (platform.system() =="Windows")1810 self.keepRepoPath =False1811 self.depotPaths =None1812 self.p4BranchesInGit = []1813 self.cloneExclude = []1814 self.useClientSpec =False1815 self.useClientSpec_from_options =False1816 self.clientSpecDirs =None1817 self.tempBranches = []1818 self.tempBranchLocation ="git-p4-tmp"18191820ifgitConfig("git-p4.syncFromOrigin") =="false":1821 self.syncWithOrigin =False18221823# Force a checkpoint in fast-import and wait for it to finish1824defcheckpoint(self):1825 self.gitStream.write("checkpoint\n\n")1826 self.gitStream.write("progress checkpoint\n\n")1827 out = self.gitOutput.readline()1828if self.verbose:1829print"checkpoint finished: "+ out18301831defextractFilesFromCommit(self, commit):1832 self.cloneExclude = [re.sub(r"\.\.\.$","", path)1833for path in self.cloneExclude]1834 files = []1835 fnum =01836while commit.has_key("depotFile%s"% fnum):1837 path = commit["depotFile%s"% fnum]18381839if[p for p in self.cloneExclude1840ifp4PathStartsWith(path, p)]:1841 found =False1842else:1843 found = [p for p in self.depotPaths1844ifp4PathStartsWith(path, p)]1845if not found:1846 fnum = fnum +11847continue18481849file= {}1850file["path"] = path1851file["rev"] = commit["rev%s"% fnum]1852file["action"] = commit["action%s"% fnum]1853file["type"] = commit["type%s"% fnum]1854 files.append(file)1855 fnum = fnum +11856return files18571858defstripRepoPath(self, path, prefixes):1859if self.useClientSpec:1860return self.clientSpecDirs.map_in_client(path)18611862if self.keepRepoPath:1863 prefixes = [re.sub("^(//[^/]+/).*", r'\1', prefixes[0])]18641865for p in prefixes:1866ifp4PathStartsWith(path, p):1867 path = path[len(p):]18681869return path18701871defsplitFilesIntoBranches(self, commit):1872 branches = {}1873 fnum =01874while commit.has_key("depotFile%s"% fnum):1875 path = commit["depotFile%s"% fnum]1876 found = [p for p in self.depotPaths1877ifp4PathStartsWith(path, p)]1878if not found:1879 fnum = fnum +11880continue18811882file= {}1883file["path"] = path1884file["rev"] = commit["rev%s"% fnum]1885file["action"] = commit["action%s"% fnum]1886file["type"] = commit["type%s"% fnum]1887 fnum = fnum +118881889 relPath = self.stripRepoPath(path, self.depotPaths)1890 relPath =wildcard_decode(relPath)18911892for branch in self.knownBranches.keys():18931894# add a trailing slash so that a commit into qt/4.2foo doesn't end up in qt/4.21895if relPath.startswith(branch +"/"):1896if branch not in branches:1897 branches[branch] = []1898 branches[branch].append(file)1899break19001901return branches19021903# output one file from the P4 stream1904# - helper for streamP4Files19051906defstreamOneP4File(self,file, contents):1907 relPath = self.stripRepoPath(file['depotFile'], self.branchPrefixes)1908 relPath =wildcard_decode(relPath)1909if verbose:1910 sys.stderr.write("%s\n"% relPath)19111912(type_base, type_mods) =split_p4_type(file["type"])19131914 git_mode ="100644"1915if"x"in type_mods:1916 git_mode ="100755"1917if type_base =="symlink":1918 git_mode ="120000"1919# p4 print on a symlink contains "target\n"; remove the newline1920 data =''.join(contents)1921 contents = [data[:-1]]19221923if type_base =="utf16":1924# p4 delivers different text in the python output to -G1925# than it does when using "print -o", or normal p4 client1926# operations. utf16 is converted to ascii or utf8, perhaps.1927# But ascii text saved as -t utf16 is completely mangled.1928# Invoke print -o to get the real contents.1929 text =p4_read_pipe(['print','-q','-o','-',file['depotFile']])1930 contents = [ text ]19311932if type_base =="apple":1933# Apple filetype files will be streamed as a concatenation of1934# its appledouble header and the contents. This is useless1935# on both macs and non-macs. If using "print -q -o xx", it1936# will create "xx" with the data, and "%xx" with the header.1937# This is also not very useful.1938#1939# Ideally, someday, this script can learn how to generate1940# appledouble files directly and import those to git, but1941# non-mac machines can never find a use for apple filetype.1942print"\nIgnoring apple filetype file%s"%file['depotFile']1943return19441945# Perhaps windows wants unicode, utf16 newlines translated too;1946# but this is not doing it.1947if self.isWindows and type_base =="text":1948 mangled = []1949for data in contents:1950 data = data.replace("\r\n","\n")1951 mangled.append(data)1952 contents = mangled19531954# Note that we do not try to de-mangle keywords on utf16 files,1955# even though in theory somebody may want that.1956 pattern =p4_keywords_regexp_for_type(type_base, type_mods)1957if pattern:1958 regexp = re.compile(pattern, re.VERBOSE)1959 text =''.join(contents)1960 text = regexp.sub(r'$\1$', text)1961 contents = [ text ]19621963 self.gitStream.write("M%sinline%s\n"% (git_mode, relPath))19641965# total length...1966 length =01967for d in contents:1968 length = length +len(d)19691970 self.gitStream.write("data%d\n"% length)1971for d in contents:1972 self.gitStream.write(d)1973 self.gitStream.write("\n")19741975defstreamOneP4Deletion(self,file):1976 relPath = self.stripRepoPath(file['path'], self.branchPrefixes)1977 relPath =wildcard_decode(relPath)1978if verbose:1979 sys.stderr.write("delete%s\n"% relPath)1980 self.gitStream.write("D%s\n"% relPath)19811982# handle another chunk of streaming data1983defstreamP4FilesCb(self, marshalled):19841985if marshalled.has_key('depotFile')and self.stream_have_file_info:1986# start of a new file - output the old one first1987 self.streamOneP4File(self.stream_file, self.stream_contents)1988 self.stream_file = {}1989 self.stream_contents = []1990 self.stream_have_file_info =False19911992# pick up the new file information... for the1993# 'data' field we need to append to our array1994for k in marshalled.keys():1995if k =='data':1996 self.stream_contents.append(marshalled['data'])1997else:1998 self.stream_file[k] = marshalled[k]19992000 self.stream_have_file_info =True20012002# Stream directly from "p4 files" into "git fast-import"2003defstreamP4Files(self, files):2004 filesForCommit = []2005 filesToRead = []2006 filesToDelete = []20072008for f in files:2009# if using a client spec, only add the files that have2010# a path in the client2011if self.clientSpecDirs:2012if self.clientSpecDirs.map_in_client(f['path']) =="":2013continue20142015 filesForCommit.append(f)2016if f['action']in self.delete_actions:2017 filesToDelete.append(f)2018else:2019 filesToRead.append(f)20202021# deleted files...2022for f in filesToDelete:2023 self.streamOneP4Deletion(f)20242025iflen(filesToRead) >0:2026 self.stream_file = {}2027 self.stream_contents = []2028 self.stream_have_file_info =False20292030# curry self argument2031defstreamP4FilesCbSelf(entry):2032 self.streamP4FilesCb(entry)20332034 fileArgs = ['%s#%s'% (f['path'], f['rev'])for f in filesToRead]20352036p4CmdList(["-x","-","print"],2037 stdin=fileArgs,2038 cb=streamP4FilesCbSelf)20392040# do the last chunk2041if self.stream_file.has_key('depotFile'):2042 self.streamOneP4File(self.stream_file, self.stream_contents)20432044defmake_email(self, userid):2045if userid in self.users:2046return self.users[userid]2047else:2048return"%s<a@b>"% userid20492050# Stream a p4 tag2051defstreamTag(self, gitStream, labelName, labelDetails, commit, epoch):2052if verbose:2053print"writing tag%sfor commit%s"% (labelName, commit)2054 gitStream.write("tag%s\n"% labelName)2055 gitStream.write("from%s\n"% commit)20562057if labelDetails.has_key('Owner'):2058 owner = labelDetails["Owner"]2059else:2060 owner =None20612062# Try to use the owner of the p4 label, or failing that,2063# the current p4 user id.2064if owner:2065 email = self.make_email(owner)2066else:2067 email = self.make_email(self.p4UserId())2068 tagger ="%s %s %s"% (email, epoch, self.tz)20692070 gitStream.write("tagger%s\n"% tagger)20712072print"labelDetails=",labelDetails2073if labelDetails.has_key('Description'):2074 description = labelDetails['Description']2075else:2076 description ='Label from git p4'20772078 gitStream.write("data%d\n"%len(description))2079 gitStream.write(description)2080 gitStream.write("\n")20812082defcommit(self, details, files, branch, branchPrefixes, parent =""):2083 epoch = details["time"]2084 author = details["user"]2085 self.branchPrefixes = branchPrefixes20862087if self.verbose:2088print"commit into%s"% branch20892090# start with reading files; if that fails, we should not2091# create a commit.2092 new_files = []2093for f in files:2094if[p for p in branchPrefixes ifp4PathStartsWith(f['path'], p)]:2095 new_files.append(f)2096else:2097 sys.stderr.write("Ignoring file outside of prefix:%s\n"% f['path'])20982099 self.gitStream.write("commit%s\n"% branch)2100# gitStream.write("mark :%s\n" % details["change"])2101 self.committedChanges.add(int(details["change"]))2102 committer =""2103if author not in self.users:2104 self.getUserMapFromPerforceServer()2105 committer ="%s %s %s"% (self.make_email(author), epoch, self.tz)21062107 self.gitStream.write("committer%s\n"% committer)21082109 self.gitStream.write("data <<EOT\n")2110 self.gitStream.write(details["desc"])2111 self.gitStream.write("\n[git-p4: depot-paths =\"%s\": change =%s"2112% (','.join(branchPrefixes), details["change"]))2113iflen(details['options']) >0:2114 self.gitStream.write(": options =%s"% details['options'])2115 self.gitStream.write("]\nEOT\n\n")21162117iflen(parent) >0:2118if self.verbose:2119print"parent%s"% parent2120 self.gitStream.write("from%s\n"% parent)21212122 self.streamP4Files(new_files)2123 self.gitStream.write("\n")21242125 change =int(details["change"])21262127if self.labels.has_key(change):2128 label = self.labels[change]2129 labelDetails = label[0]2130 labelRevisions = label[1]2131if self.verbose:2132print"Change%sis labelled%s"% (change, labelDetails)21332134 files =p4CmdList(["files"] + ["%s...@%s"% (p, change)2135for p in branchPrefixes])21362137iflen(files) ==len(labelRevisions):21382139 cleanedFiles = {}2140for info in files:2141if info["action"]in self.delete_actions:2142continue2143 cleanedFiles[info["depotFile"]] = info["rev"]21442145if cleanedFiles == labelRevisions:2146 self.streamTag(self.gitStream,'tag_%s'% labelDetails['label'], labelDetails, branch, epoch)21472148else:2149if not self.silent:2150print("Tag%sdoes not match with change%s: files do not match."2151% (labelDetails["label"], change))21522153else:2154if not self.silent:2155print("Tag%sdoes not match with change%s: file count is different."2156% (labelDetails["label"], change))21572158# Build a dictionary of changelists and labels, for "detect-labels" option.2159defgetLabels(self):2160 self.labels = {}21612162 l =p4CmdList(["labels"] + ["%s..."% p for p in self.depotPaths])2163iflen(l) >0and not self.silent:2164print"Finding files belonging to labels in%s"% `self.depotPaths`21652166for output in l:2167 label = output["label"]2168 revisions = {}2169 newestChange =02170if self.verbose:2171print"Querying files for label%s"% label2172forfileinp4CmdList(["files"] +2173["%s...@%s"% (p, label)2174for p in self.depotPaths]):2175 revisions[file["depotFile"]] =file["rev"]2176 change =int(file["change"])2177if change > newestChange:2178 newestChange = change21792180 self.labels[newestChange] = [output, revisions]21812182if self.verbose:2183print"Label changes:%s"% self.labels.keys()21842185# Import p4 labels as git tags. A direct mapping does not2186# exist, so assume that if all the files are at the same revision2187# then we can use that, or it's something more complicated we should2188# just ignore.2189defimportP4Labels(self, stream, p4Labels):2190if verbose:2191print"import p4 labels: "+' '.join(p4Labels)21922193 ignoredP4Labels =gitConfigList("git-p4.ignoredP4Labels")2194 validLabelRegexp =gitConfig("git-p4.labelImportRegexp")2195iflen(validLabelRegexp) ==0:2196 validLabelRegexp = defaultLabelRegexp2197 m = re.compile(validLabelRegexp)21982199for name in p4Labels:2200 commitFound =False22012202if not m.match(name):2203if verbose:2204print"label%sdoes not match regexp%s"% (name,validLabelRegexp)2205continue22062207if name in ignoredP4Labels:2208continue22092210 labelDetails =p4CmdList(['label',"-o", name])[0]22112212# get the most recent changelist for each file in this label2213 change =p4Cmd(["changes","-m","1"] + ["%s...@%s"% (p, name)2214for p in self.depotPaths])22152216if change.has_key('change'):2217# find the corresponding git commit; take the oldest commit2218 changelist =int(change['change'])2219 gitCommit =read_pipe(["git","rev-list","--max-count=1",2220"--reverse",":/\[git-p4:.*change =%d\]"% changelist])2221iflen(gitCommit) ==0:2222print"could not find git commit for changelist%d"% changelist2223else:2224 gitCommit = gitCommit.strip()2225 commitFound =True2226# Convert from p4 time format2227try:2228 tmwhen = time.strptime(labelDetails['Update'],"%Y/%m/%d%H:%M:%S")2229exceptValueError:2230print"Could not convert label time%s"% labelDetail['Update']2231 tmwhen =122322233 when =int(time.mktime(tmwhen))2234 self.streamTag(stream, name, labelDetails, gitCommit, when)2235if verbose:2236print"p4 label%smapped to git commit%s"% (name, gitCommit)2237else:2238if verbose:2239print"Label%shas no changelists - possibly deleted?"% name22402241if not commitFound:2242# We can't import this label; don't try again as it will get very2243# expensive repeatedly fetching all the files for labels that will2244# never be imported. If the label is moved in the future, the2245# ignore will need to be removed manually.2246system(["git","config","--add","git-p4.ignoredP4Labels", name])22472248defguessProjectName(self):2249for p in self.depotPaths:2250if p.endswith("/"):2251 p = p[:-1]2252 p = p[p.strip().rfind("/") +1:]2253if not p.endswith("/"):2254 p +="/"2255return p22562257defgetBranchMapping(self):2258 lostAndFoundBranches =set()22592260 user =gitConfig("git-p4.branchUser")2261iflen(user) >0:2262 command ="branches -u%s"% user2263else:2264 command ="branches"22652266for info inp4CmdList(command):2267 details =p4Cmd(["branch","-o", info["branch"]])2268 viewIdx =02269while details.has_key("View%s"% viewIdx):2270 paths = details["View%s"% viewIdx].split(" ")2271 viewIdx = viewIdx +12272# require standard //depot/foo/... //depot/bar/... mapping2273iflen(paths) !=2or not paths[0].endswith("/...")or not paths[1].endswith("/..."):2274continue2275 source = paths[0]2276 destination = paths[1]2277## HACK2278ifp4PathStartsWith(source, self.depotPaths[0])andp4PathStartsWith(destination, self.depotPaths[0]):2279 source = source[len(self.depotPaths[0]):-4]2280 destination = destination[len(self.depotPaths[0]):-4]22812282if destination in self.knownBranches:2283if not self.silent:2284print"p4 branch%sdefines a mapping from%sto%s"% (info["branch"], source, destination)2285print"but there exists another mapping from%sto%salready!"% (self.knownBranches[destination], destination)2286continue22872288 self.knownBranches[destination] = source22892290 lostAndFoundBranches.discard(destination)22912292if source not in self.knownBranches:2293 lostAndFoundBranches.add(source)22942295# Perforce does not strictly require branches to be defined, so we also2296# check git config for a branch list.2297#2298# Example of branch definition in git config file:2299# [git-p4]2300# branchList=main:branchA2301# branchList=main:branchB2302# branchList=branchA:branchC2303 configBranches =gitConfigList("git-p4.branchList")2304for branch in configBranches:2305if branch:2306(source, destination) = branch.split(":")2307 self.knownBranches[destination] = source23082309 lostAndFoundBranches.discard(destination)23102311if source not in self.knownBranches:2312 lostAndFoundBranches.add(source)231323142315for branch in lostAndFoundBranches:2316 self.knownBranches[branch] = branch23172318defgetBranchMappingFromGitBranches(self):2319 branches =p4BranchesInGit(self.importIntoRemotes)2320for branch in branches.keys():2321if branch =="master":2322 branch ="main"2323else:2324 branch = branch[len(self.projectName):]2325 self.knownBranches[branch] = branch23262327deflistExistingP4GitBranches(self):2328# branches holds mapping from name to commit2329 branches =p4BranchesInGit(self.importIntoRemotes)2330 self.p4BranchesInGit = branches.keys()2331for branch in branches.keys():2332 self.initialParents[self.refPrefix + branch] = branches[branch]23332334defupdateOptionDict(self, d):2335 option_keys = {}2336if self.keepRepoPath:2337 option_keys['keepRepoPath'] =123382339 d["options"] =' '.join(sorted(option_keys.keys()))23402341defreadOptions(self, d):2342 self.keepRepoPath = (d.has_key('options')2343and('keepRepoPath'in d['options']))23442345defgitRefForBranch(self, branch):2346if branch =="main":2347return self.refPrefix +"master"23482349iflen(branch) <=0:2350return branch23512352return self.refPrefix + self.projectName + branch23532354defgitCommitByP4Change(self, ref, change):2355if self.verbose:2356print"looking in ref "+ ref +" for change%susing bisect..."% change23572358 earliestCommit =""2359 latestCommit =parseRevision(ref)23602361while True:2362if self.verbose:2363print"trying: earliest%slatest%s"% (earliestCommit, latestCommit)2364 next =read_pipe("git rev-list --bisect%s %s"% (latestCommit, earliestCommit)).strip()2365iflen(next) ==0:2366if self.verbose:2367print"argh"2368return""2369 log =extractLogMessageFromGitCommit(next)2370 settings =extractSettingsGitLog(log)2371 currentChange =int(settings['change'])2372if self.verbose:2373print"current change%s"% currentChange23742375if currentChange == change:2376if self.verbose:2377print"found%s"% next2378return next23792380if currentChange < change:2381 earliestCommit ="^%s"% next2382else:2383 latestCommit ="%s"% next23842385return""23862387defimportNewBranch(self, branch, maxChange):2388# make fast-import flush all changes to disk and update the refs using the checkpoint2389# command so that we can try to find the branch parent in the git history2390 self.gitStream.write("checkpoint\n\n");2391 self.gitStream.flush();2392 branchPrefix = self.depotPaths[0] + branch +"/"2393range="@1,%s"% maxChange2394#print "prefix" + branchPrefix2395 changes =p4ChangesForPaths([branchPrefix],range)2396iflen(changes) <=0:2397return False2398 firstChange = changes[0]2399#print "first change in branch: %s" % firstChange2400 sourceBranch = self.knownBranches[branch]2401 sourceDepotPath = self.depotPaths[0] + sourceBranch2402 sourceRef = self.gitRefForBranch(sourceBranch)2403#print "source " + sourceBranch24042405 branchParentChange =int(p4Cmd(["changes","-m","1","%s...@1,%s"% (sourceDepotPath, firstChange)])["change"])2406#print "branch parent: %s" % branchParentChange2407 gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)2408iflen(gitParent) >0:2409 self.initialParents[self.gitRefForBranch(branch)] = gitParent2410#print "parent git commit: %s" % gitParent24112412 self.importChanges(changes)2413return True24142415defsearchParent(self, parent, branch, target):2416 parentFound =False2417for blob inread_pipe_lines(["git","rev-list","--reverse","--no-merges", parent]):2418 blob = blob.strip()2419iflen(read_pipe(["git","diff-tree", blob, target])) ==0:2420 parentFound =True2421if self.verbose:2422print"Found parent of%sin commit%s"% (branch, blob)2423break2424if parentFound:2425return blob2426else:2427return None24282429defimportChanges(self, changes):2430 cnt =12431for change in changes:2432 description =p4Cmd(["describe",str(change)])2433 self.updateOptionDict(description)24342435if not self.silent:2436 sys.stdout.write("\rImporting revision%s(%s%%)"% (change, cnt *100/len(changes)))2437 sys.stdout.flush()2438 cnt = cnt +124392440try:2441if self.detectBranches:2442 branches = self.splitFilesIntoBranches(description)2443for branch in branches.keys():2444## HACK --hwn2445 branchPrefix = self.depotPaths[0] + branch +"/"24462447 parent =""24482449 filesForCommit = branches[branch]24502451if self.verbose:2452print"branch is%s"% branch24532454 self.updatedBranches.add(branch)24552456if branch not in self.createdBranches:2457 self.createdBranches.add(branch)2458 parent = self.knownBranches[branch]2459if parent == branch:2460 parent =""2461else:2462 fullBranch = self.projectName + branch2463if fullBranch not in self.p4BranchesInGit:2464if not self.silent:2465print("\nImporting new branch%s"% fullBranch);2466if self.importNewBranch(branch, change -1):2467 parent =""2468 self.p4BranchesInGit.append(fullBranch)2469if not self.silent:2470print("\nResuming with change%s"% change);24712472if self.verbose:2473print"parent determined through known branches:%s"% parent24742475 branch = self.gitRefForBranch(branch)2476 parent = self.gitRefForBranch(parent)24772478if self.verbose:2479print"looking for initial parent for%s; current parent is%s"% (branch, parent)24802481iflen(parent) ==0and branch in self.initialParents:2482 parent = self.initialParents[branch]2483del self.initialParents[branch]24842485 blob =None2486iflen(parent) >0:2487 tempBranch = os.path.join(self.tempBranchLocation,"%d"% (change))2488if self.verbose:2489print"Creating temporary branch: "+ tempBranch2490 self.commit(description, filesForCommit, tempBranch, [branchPrefix])2491 self.tempBranches.append(tempBranch)2492 self.checkpoint()2493 blob = self.searchParent(parent, branch, tempBranch)2494if blob:2495 self.commit(description, filesForCommit, branch, [branchPrefix], blob)2496else:2497if self.verbose:2498print"Parent of%snot found. Committing into head of%s"% (branch, parent)2499 self.commit(description, filesForCommit, branch, [branchPrefix], parent)2500else:2501 files = self.extractFilesFromCommit(description)2502 self.commit(description, files, self.branch, self.depotPaths,2503 self.initialParent)2504 self.initialParent =""2505exceptIOError:2506print self.gitError.read()2507 sys.exit(1)25082509defimportHeadRevision(self, revision):2510print"Doing initial import of%sfrom revision%sinto%s"% (' '.join(self.depotPaths), revision, self.branch)25112512 details = {}2513 details["user"] ="git perforce import user"2514 details["desc"] = ("Initial import of%sfrom the state at revision%s\n"2515% (' '.join(self.depotPaths), revision))2516 details["change"] = revision2517 newestRevision =025182519 fileCnt =02520 fileArgs = ["%s...%s"% (p,revision)for p in self.depotPaths]25212522for info inp4CmdList(["files"] + fileArgs):25232524if'code'in info and info['code'] =='error':2525 sys.stderr.write("p4 returned an error:%s\n"2526% info['data'])2527if info['data'].find("must refer to client") >=0:2528 sys.stderr.write("This particular p4 error is misleading.\n")2529 sys.stderr.write("Perhaps the depot path was misspelled.\n");2530 sys.stderr.write("Depot path:%s\n"%" ".join(self.depotPaths))2531 sys.exit(1)2532if'p4ExitCode'in info:2533 sys.stderr.write("p4 exitcode:%s\n"% info['p4ExitCode'])2534 sys.exit(1)253525362537 change =int(info["change"])2538if change > newestRevision:2539 newestRevision = change25402541if info["action"]in self.delete_actions:2542# don't increase the file cnt, otherwise details["depotFile123"] will have gaps!2543#fileCnt = fileCnt + 12544continue25452546for prop in["depotFile","rev","action","type"]:2547 details["%s%s"% (prop, fileCnt)] = info[prop]25482549 fileCnt = fileCnt +125502551 details["change"] = newestRevision25522553# Use time from top-most change so that all git p4 clones of2554# the same p4 repo have the same commit SHA1s.2555 res =p4CmdList("describe -s%d"% newestRevision)2556 newestTime =None2557for r in res:2558if r.has_key('time'):2559 newestTime =int(r['time'])2560if newestTime is None:2561die("\"describe -s\"on newest change%ddid not give a time")2562 details["time"] = newestTime25632564 self.updateOptionDict(details)2565try:2566 self.commit(details, self.extractFilesFromCommit(details), self.branch, self.depotPaths)2567exceptIOError:2568print"IO error with git fast-import. Is your git version recent enough?"2569print self.gitError.read()257025712572defrun(self, args):2573 self.depotPaths = []2574 self.changeRange =""2575 self.initialParent =""2576 self.previousDepotPaths = []25772578# map from branch depot path to parent branch2579 self.knownBranches = {}2580 self.initialParents = {}2581 self.hasOrigin =originP4BranchesExist()2582if not self.syncWithOrigin:2583 self.hasOrigin =False25842585if self.importIntoRemotes:2586 self.refPrefix ="refs/remotes/p4/"2587else:2588 self.refPrefix ="refs/heads/p4/"25892590if self.syncWithOrigin and self.hasOrigin:2591if not self.silent:2592print"Syncing with origin first by calling git fetch origin"2593system("git fetch origin")25942595iflen(self.branch) ==0:2596 self.branch = self.refPrefix +"master"2597ifgitBranchExists("refs/heads/p4")and self.importIntoRemotes:2598system("git update-ref%srefs/heads/p4"% self.branch)2599system("git branch -D p4");2600# create it /after/ importing, when master exists2601if notgitBranchExists(self.refPrefix +"HEAD")and self.importIntoRemotes andgitBranchExists(self.branch):2602system("git symbolic-ref%sHEAD%s"% (self.refPrefix, self.branch))26032604# accept either the command-line option, or the configuration variable2605if self.useClientSpec:2606# will use this after clone to set the variable2607 self.useClientSpec_from_options =True2608else:2609ifgitConfig("git-p4.useclientspec","--bool") =="true":2610 self.useClientSpec =True2611if self.useClientSpec:2612 self.clientSpecDirs =getClientSpec()26132614# TODO: should always look at previous commits,2615# merge with previous imports, if possible.2616if args == []:2617if self.hasOrigin:2618createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)2619 self.listExistingP4GitBranches()26202621iflen(self.p4BranchesInGit) >1:2622if not self.silent:2623print"Importing from/into multiple branches"2624 self.detectBranches =True26252626if self.verbose:2627print"branches:%s"% self.p4BranchesInGit26282629 p4Change =02630for branch in self.p4BranchesInGit:2631 logMsg =extractLogMessageFromGitCommit(self.refPrefix + branch)26322633 settings =extractSettingsGitLog(logMsg)26342635 self.readOptions(settings)2636if(settings.has_key('depot-paths')2637and settings.has_key('change')):2638 change =int(settings['change']) +12639 p4Change =max(p4Change, change)26402641 depotPaths =sorted(settings['depot-paths'])2642if self.previousDepotPaths == []:2643 self.previousDepotPaths = depotPaths2644else:2645 paths = []2646for(prev, cur)inzip(self.previousDepotPaths, depotPaths):2647 prev_list = prev.split("/")2648 cur_list = cur.split("/")2649for i inrange(0,min(len(cur_list),len(prev_list))):2650if cur_list[i] <> prev_list[i]:2651 i = i -12652break26532654 paths.append("/".join(cur_list[:i +1]))26552656 self.previousDepotPaths = paths26572658if p4Change >0:2659 self.depotPaths =sorted(self.previousDepotPaths)2660 self.changeRange ="@%s,#head"% p4Change2661if not self.detectBranches:2662 self.initialParent =parseRevision(self.branch)2663if not self.silent and not self.detectBranches:2664print"Performing incremental import into%sgit branch"% self.branch26652666if not self.branch.startswith("refs/"):2667 self.branch ="refs/heads/"+ self.branch26682669iflen(args) ==0and self.depotPaths:2670if not self.silent:2671print"Depot paths:%s"%' '.join(self.depotPaths)2672else:2673if self.depotPaths and self.depotPaths != args:2674print("previous import used depot path%sand now%swas specified. "2675"This doesn't work!"% (' '.join(self.depotPaths),2676' '.join(args)))2677 sys.exit(1)26782679 self.depotPaths =sorted(args)26802681 revision =""2682 self.users = {}26832684# Make sure no revision specifiers are used when --changesfile2685# is specified.2686 bad_changesfile =False2687iflen(self.changesFile) >0:2688for p in self.depotPaths:2689if p.find("@") >=0or p.find("#") >=0:2690 bad_changesfile =True2691break2692if bad_changesfile:2693die("Option --changesfile is incompatible with revision specifiers")26942695 newPaths = []2696for p in self.depotPaths:2697if p.find("@") != -1:2698 atIdx = p.index("@")2699 self.changeRange = p[atIdx:]2700if self.changeRange =="@all":2701 self.changeRange =""2702elif','not in self.changeRange:2703 revision = self.changeRange2704 self.changeRange =""2705 p = p[:atIdx]2706elif p.find("#") != -1:2707 hashIdx = p.index("#")2708 revision = p[hashIdx:]2709 p = p[:hashIdx]2710elif self.previousDepotPaths == []:2711# pay attention to changesfile, if given, else import2712# the entire p4 tree at the head revision2713iflen(self.changesFile) ==0:2714 revision ="#head"27152716 p = re.sub("\.\.\.$","", p)2717if not p.endswith("/"):2718 p +="/"27192720 newPaths.append(p)27212722 self.depotPaths = newPaths27232724 self.loadUserMapFromCache()2725 self.labels = {}2726if self.detectLabels:2727 self.getLabels();27282729if self.detectBranches:2730## FIXME - what's a P4 projectName ?2731 self.projectName = self.guessProjectName()27322733if self.hasOrigin:2734 self.getBranchMappingFromGitBranches()2735else:2736 self.getBranchMapping()2737if self.verbose:2738print"p4-git branches:%s"% self.p4BranchesInGit2739print"initial parents:%s"% self.initialParents2740for b in self.p4BranchesInGit:2741if b !="master":27422743## FIXME2744 b = b[len(self.projectName):]2745 self.createdBranches.add(b)27462747 self.tz ="%+03d%02d"% (- time.timezone /3600, ((- time.timezone %3600) /60))27482749 importProcess = subprocess.Popen(["git","fast-import"],2750 stdin=subprocess.PIPE, stdout=subprocess.PIPE,2751 stderr=subprocess.PIPE);2752 self.gitOutput = importProcess.stdout2753 self.gitStream = importProcess.stdin2754 self.gitError = importProcess.stderr27552756if revision:2757 self.importHeadRevision(revision)2758else:2759 changes = []27602761iflen(self.changesFile) >0:2762 output =open(self.changesFile).readlines()2763 changeSet =set()2764for line in output:2765 changeSet.add(int(line))27662767for change in changeSet:2768 changes.append(change)27692770 changes.sort()2771else:2772# catch "git p4 sync" with no new branches, in a repo that2773# does not have any existing p4 branches2774iflen(args) ==0and not self.p4BranchesInGit:2775die("No remote p4 branches. Perhaps you never did\"git p4 clone\"in here.");2776if self.verbose:2777print"Getting p4 changes for%s...%s"% (', '.join(self.depotPaths),2778 self.changeRange)2779 changes =p4ChangesForPaths(self.depotPaths, self.changeRange)27802781iflen(self.maxChanges) >0:2782 changes = changes[:min(int(self.maxChanges),len(changes))]27832784iflen(changes) ==0:2785if not self.silent:2786print"No changes to import!"2787else:2788if not self.silent and not self.detectBranches:2789print"Import destination:%s"% self.branch27902791 self.updatedBranches =set()27922793 self.importChanges(changes)27942795if not self.silent:2796print""2797iflen(self.updatedBranches) >0:2798 sys.stdout.write("Updated branches: ")2799for b in self.updatedBranches:2800 sys.stdout.write("%s"% b)2801 sys.stdout.write("\n")28022803ifgitConfig("git-p4.importLabels","--bool") =="true":2804 self.importLabels =True28052806if self.importLabels:2807 p4Labels =getP4Labels(self.depotPaths)2808 gitTags =getGitTags()28092810 missingP4Labels = p4Labels - gitTags2811 self.importP4Labels(self.gitStream, missingP4Labels)28122813 self.gitStream.close()2814if importProcess.wait() !=0:2815die("fast-import failed:%s"% self.gitError.read())2816 self.gitOutput.close()2817 self.gitError.close()28182819# Cleanup temporary branches created during import2820if self.tempBranches != []:2821for branch in self.tempBranches:2822read_pipe("git update-ref -d%s"% branch)2823 os.rmdir(os.path.join(os.environ.get("GIT_DIR",".git"), self.tempBranchLocation))28242825return True28262827classP4Rebase(Command):2828def__init__(self):2829 Command.__init__(self)2830 self.options = [2831 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),2832]2833 self.importLabels =False2834 self.description = ("Fetches the latest revision from perforce and "2835+"rebases the current work (branch) against it")28362837defrun(self, args):2838 sync =P4Sync()2839 sync.importLabels = self.importLabels2840 sync.run([])28412842return self.rebase()28432844defrebase(self):2845if os.system("git update-index --refresh") !=0:2846die("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.");2847iflen(read_pipe("git diff-index HEAD --")) >0:2848die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");28492850[upstream, settings] =findUpstreamBranchPoint()2851iflen(upstream) ==0:2852die("Cannot find upstream branchpoint for rebase")28532854# the branchpoint may be p4/foo~3, so strip off the parent2855 upstream = re.sub("~[0-9]+$","", upstream)28562857print"Rebasing the current branch onto%s"% upstream2858 oldHead =read_pipe("git rev-parse HEAD").strip()2859system("git rebase%s"% upstream)2860system("git diff-tree --stat --summary -M%sHEAD"% oldHead)2861return True28622863classP4Clone(P4Sync):2864def__init__(self):2865 P4Sync.__init__(self)2866 self.description ="Creates a new git repository and imports from Perforce into it"2867 self.usage ="usage: %prog [options] //depot/path[@revRange]"2868 self.options += [2869 optparse.make_option("--destination", dest="cloneDestination",2870 action='store', default=None,2871help="where to leave result of the clone"),2872 optparse.make_option("-/", dest="cloneExclude",2873 action="append",type="string",2874help="exclude depot path"),2875 optparse.make_option("--bare", dest="cloneBare",2876 action="store_true", default=False),2877]2878 self.cloneDestination =None2879 self.needsGit =False2880 self.cloneBare =False28812882# This is required for the "append" cloneExclude action2883defensure_value(self, attr, value):2884if nothasattr(self, attr)orgetattr(self, attr)is None:2885setattr(self, attr, value)2886returngetattr(self, attr)28872888defdefaultDestination(self, args):2889## TODO: use common prefix of args?2890 depotPath = args[0]2891 depotDir = re.sub("(@[^@]*)$","", depotPath)2892 depotDir = re.sub("(#[^#]*)$","", depotDir)2893 depotDir = re.sub(r"\.\.\.$","", depotDir)2894 depotDir = re.sub(r"/$","", depotDir)2895return os.path.split(depotDir)[1]28962897defrun(self, args):2898iflen(args) <1:2899return False29002901if self.keepRepoPath and not self.cloneDestination:2902 sys.stderr.write("Must specify destination for --keep-path\n")2903 sys.exit(1)29042905 depotPaths = args29062907if not self.cloneDestination andlen(depotPaths) >1:2908 self.cloneDestination = depotPaths[-1]2909 depotPaths = depotPaths[:-1]29102911 self.cloneExclude = ["/"+p for p in self.cloneExclude]2912for p in depotPaths:2913if not p.startswith("//"):2914return False29152916if not self.cloneDestination:2917 self.cloneDestination = self.defaultDestination(args)29182919print"Importing from%sinto%s"% (', '.join(depotPaths), self.cloneDestination)29202921if not os.path.exists(self.cloneDestination):2922 os.makedirs(self.cloneDestination)2923chdir(self.cloneDestination)29242925 init_cmd = ["git","init"]2926if self.cloneBare:2927 init_cmd.append("--bare")2928 subprocess.check_call(init_cmd)29292930if not P4Sync.run(self, depotPaths):2931return False2932if self.branch !="master":2933if self.importIntoRemotes:2934 masterbranch ="refs/remotes/p4/master"2935else:2936 masterbranch ="refs/heads/p4/master"2937ifgitBranchExists(masterbranch):2938system("git branch master%s"% masterbranch)2939if not self.cloneBare:2940system("git checkout -f")2941else:2942print"Could not detect main branch. No checkout/master branch created."29432944# auto-set this variable if invoked with --use-client-spec2945if self.useClientSpec_from_options:2946system("git config --bool git-p4.useclientspec true")29472948return True29492950classP4Branches(Command):2951def__init__(self):2952 Command.__init__(self)2953 self.options = [ ]2954 self.description = ("Shows the git branches that hold imports and their "2955+"corresponding perforce depot paths")2956 self.verbose =False29572958defrun(self, args):2959iforiginP4BranchesExist():2960createOrUpdateBranchesFromOrigin()29612962 cmdline ="git rev-parse --symbolic "2963 cmdline +=" --remotes"29642965for line inread_pipe_lines(cmdline):2966 line = line.strip()29672968if not line.startswith('p4/')or line =="p4/HEAD":2969continue2970 branch = line29712972 log =extractLogMessageFromGitCommit("refs/remotes/%s"% branch)2973 settings =extractSettingsGitLog(log)29742975print"%s<=%s(%s)"% (branch,",".join(settings["depot-paths"]), settings["change"])2976return True29772978classHelpFormatter(optparse.IndentedHelpFormatter):2979def__init__(self):2980 optparse.IndentedHelpFormatter.__init__(self)29812982defformat_description(self, description):2983if description:2984return description +"\n"2985else:2986return""29872988defprintUsage(commands):2989print"usage:%s<command> [options]"% sys.argv[0]2990print""2991print"valid commands:%s"%", ".join(commands)2992print""2993print"Try%s<command> --help for command specific help."% sys.argv[0]2994print""29952996commands = {2997"debug": P4Debug,2998"submit": P4Submit,2999"commit": P4Submit,3000"sync": P4Sync,3001"rebase": P4Rebase,3002"clone": P4Clone,3003"rollback": P4RollBack,3004"branches": P4Branches3005}300630073008defmain():3009iflen(sys.argv[1:]) ==0:3010printUsage(commands.keys())3011 sys.exit(2)30123013 cmd =""3014 cmdName = sys.argv[1]3015try:3016 klass = commands[cmdName]3017 cmd =klass()3018exceptKeyError:3019print"unknown command%s"% cmdName3020print""3021printUsage(commands.keys())3022 sys.exit(2)30233024 options = cmd.options3025 cmd.gitdir = os.environ.get("GIT_DIR",None)30263027 args = sys.argv[2:]30283029 options.append(optparse.make_option("--verbose", dest="verbose", action="store_true"))3030if cmd.needsGit:3031 options.append(optparse.make_option("--git-dir", dest="gitdir"))30323033 parser = optparse.OptionParser(cmd.usage.replace("%prog","%prog "+ cmdName),3034 options,3035 description = cmd.description,3036 formatter =HelpFormatter())30373038(cmd, args) = parser.parse_args(sys.argv[2:], cmd);3039global verbose3040 verbose = cmd.verbose3041if cmd.needsGit:3042if cmd.gitdir ==None:3043 cmd.gitdir = os.path.abspath(".git")3044if notisValidGitDir(cmd.gitdir):3045 cmd.gitdir =read_pipe("git rev-parse --git-dir").strip()3046if os.path.exists(cmd.gitdir):3047 cdup =read_pipe("git rev-parse --show-cdup").strip()3048iflen(cdup) >0:3049chdir(cdup);30503051if notisValidGitDir(cmd.gitdir):3052ifisValidGitDir(cmd.gitdir +"/.git"):3053 cmd.gitdir +="/.git"3054else:3055die("fatal: cannot locate git repository at%s"% cmd.gitdir)30563057 os.environ["GIT_DIR"] = cmd.gitdir30583059if not cmd.run(args):3060 parser.print_help()3061 sys.exit(2)306230633064if __name__ =='__main__':3065main()