git p4: do wildcard decoding in stripRepoPath
[git/git.git] / git-p4.py
CommitLineData
86949eef
SH
1#!/usr/bin/env python
2#
3# git-p4.py -- A tool for bidirectional operation between a Perforce depot and git.
4#
c8cbbee9
SH
5# Author: Simon Hausmann <simon@lst.de>
6# Copyright: 2007 Simon Hausmann <simon@lst.de>
83dce55a 7# 2007 Trolltech ASA
86949eef
SH
8# License: MIT <http://www.opensource.org/licenses/mit-license.php>
9#
10
1d7367dc
RG
11import optparse, sys, os, marshal, subprocess, shelve
12import tempfile, getopt, os.path, time, platform
60df071c 13import re, shutil
8b41a97f 14
4addad22 15verbose = False
86949eef 16
06804c76 17# Only labels/tags matching this will be imported/exported
c8942a22 18defaultLabelRegexp = r'[a-zA-Z0-9_\-.]+$'
21a50753
AK
19
20def p4_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 """
6de040df 27 real_cmd = ["p4"]
abcaf073
AK
28
29 user = gitConfig("git-p4.user")
30 if len(user) > 0:
6de040df 31 real_cmd += ["-u",user]
abcaf073
AK
32
33 password = gitConfig("git-p4.password")
34 if len(password) > 0:
6de040df 35 real_cmd += ["-P", password]
abcaf073
AK
36
37 port = gitConfig("git-p4.port")
38 if len(port) > 0:
6de040df 39 real_cmd += ["-p", port]
abcaf073
AK
40
41 host = gitConfig("git-p4.host")
42 if len(host) > 0:
41799aa2 43 real_cmd += ["-H", host]
abcaf073
AK
44
45 client = gitConfig("git-p4.client")
46 if len(client) > 0:
6de040df 47 real_cmd += ["-c", client]
abcaf073 48
6de040df
LD
49
50 if isinstance(cmd,basestring):
51 real_cmd = ' '.join(real_cmd) + ' ' + cmd
52 else:
53 real_cmd += cmd
21a50753
AK
54 return real_cmd
55
053fd0c1 56def chdir(dir):
6de040df 57 # P4 uses the PWD environment variable rather than getcwd(). Since we're
bf1d68ff
GG
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.
053fd0c1 60 os.chdir(dir)
bf1d68ff 61 os.environ['PWD'] = os.getcwd()
053fd0c1 62
86dff6b6
HWN
63def die(msg):
64 if verbose:
65 raise Exception(msg)
66 else:
67 sys.stderr.write(msg + "\n")
68 sys.exit(1)
69
6de040df 70def write_pipe(c, stdin):
4addad22 71 if verbose:
6de040df 72 sys.stderr.write('Writing pipe: %s\n' % str(c))
b016d397 73
6de040df
LD
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()
79 if p.wait():
80 die('Command failed: %s' % str(c))
b016d397
HWN
81
82 return val
83
6de040df 84def p4_write_pipe(c, stdin):
d9429194 85 real_cmd = p4_build_cmd(c)
6de040df 86 return write_pipe(real_cmd, stdin)
d9429194 87
4addad22
HWN
88def read_pipe(c, ignore_error=False):
89 if verbose:
6de040df 90 sys.stderr.write('Reading pipe: %s\n' % str(c))
8b41a97f 91
6de040df
LD
92 expand = isinstance(c,basestring)
93 p = subprocess.Popen(c, stdout=subprocess.PIPE, shell=expand)
94 pipe = p.stdout
b016d397 95 val = pipe.read()
6de040df
LD
96 if p.wait() and not ignore_error:
97 die('Command failed: %s' % str(c))
b016d397
HWN
98
99 return val
100
d9429194
AK
101def p4_read_pipe(c, ignore_error=False):
102 real_cmd = p4_build_cmd(c)
103 return read_pipe(real_cmd, ignore_error)
b016d397 104
bce4c5fc 105def read_pipe_lines(c):
4addad22 106 if verbose:
6de040df
LD
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
b016d397 112 val = pipe.readlines()
6de040df
LD
113 if pipe.close() or p.wait():
114 die('Command failed: %s' % str(c))
b016d397
HWN
115
116 return val
caace111 117
2318121b
AK
118def p4_read_pipe_lines(c):
119 """Specifically invoke p4 on the command supplied. """
155af834 120 real_cmd = p4_build_cmd(c)
2318121b
AK
121 return read_pipe_lines(real_cmd)
122
8e9497c2
GG
123def p4_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()
130 return p.returncode == 0
131
6754a299 132def system(cmd):
6de040df 133 expand = isinstance(cmd,basestring)
4addad22 134 if verbose:
6de040df
LD
135 sys.stderr.write("executing %s\n" % str(cmd))
136 subprocess.check_call(cmd, shell=expand)
6754a299 137
bf9320f1
AK
138def p4_system(cmd):
139 """Specifically invoke p4 as the system command. """
155af834 140 real_cmd = p4_build_cmd(cmd)
6de040df
LD
141 expand = isinstance(real_cmd, basestring)
142 subprocess.check_call(real_cmd, shell=expand)
143
144def p4_integrate(src, dest):
9d7d446a 145 p4_system(["integrate", "-Dt", wildcard_encode(src), wildcard_encode(dest)])
6de040df 146
8d7ec362 147def p4_sync(f, *options):
9d7d446a 148 p4_system(["sync"] + list(options) + [wildcard_encode(f)])
6de040df
LD
149
150def p4_add(f):
9d7d446a
PW
151 # forcibly add file names with wildcards
152 if wildcard_present(f):
153 p4_system(["add", "-f", f])
154 else:
155 p4_system(["add", f])
6de040df
LD
156
157def p4_delete(f):
9d7d446a 158 p4_system(["delete", wildcard_encode(f)])
6de040df
LD
159
160def p4_edit(f):
9d7d446a 161 p4_system(["edit", wildcard_encode(f)])
6de040df
LD
162
163def p4_revert(f):
9d7d446a 164 p4_system(["revert", wildcard_encode(f)])
6de040df 165
9d7d446a
PW
166def p4_reopen(type, f):
167 p4_system(["reopen", "-t", type, wildcard_encode(f)])
bf9320f1 168
8e9497c2
GG
169def p4_move(src, dest):
170 p4_system(["move", "-k", wildcard_encode(src), wildcard_encode(dest)])
171
9cffb8c8
PW
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#
177def split_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 }
197 if p4type in p4_filetypes_historical:
198 p4type = p4_filetypes_historical[p4type]
199 mods = ""
200 s = p4type.split("+")
201 base = s[0]
202 mods = ""
203 if len(s) > 1:
204 mods = s[1]
205 return (base, mods)
b9fc6ea9 206
60df071c
LD
207#
208# return the raw p4 type of a file (text, text+ko, etc)
209#
210def p4_type(file):
211 results = p4CmdList(["fstat", "-T", "headType", file])
212 return 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#
218def p4_keywords_regexp_for_type(base, type_mods):
219 if base in ("text", "unicode", "binary"):
220 kwords = None
221 if "ko" in type_mods:
222 kwords = 'Id|Header'
223 elif "k" in type_mods:
224 kwords = 'Id|Header|Author|Date|DateTime|Change|File|Revision'
225 else:
226 return 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
233 return pattern
234 else:
235 return 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#
242def p4_keywords_regexp_for_file(file):
243 if not os.path.exists(file):
244 return None
245 else:
246 (type_base, type_mods) = split_p4_type(p4_type(file))
247 return p4_keywords_regexp_for_type(type_base, type_mods)
b9fc6ea9 248
c65b670e
CP
249def setP4ExecBit(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
255 if not isModeExec(mode):
256 p4Type = getP4OpenedType(file)
257 p4Type = re.sub('^([cku]?)x(.*)', '\\1\\2', p4Type)
258 p4Type = re.sub('(.*?\+.*?)x(.*?)', '\\1\\2', p4Type)
259 if p4Type[-1] == "+":
260 p4Type = p4Type[0:-1]
261
6de040df 262 p4_reopen(p4Type, file)
c65b670e
CP
263
264def getP4OpenedType(file):
265 # Returns the perforce file type for the given file.
266
9d7d446a 267 result = p4_read_pipe(["opened", wildcard_encode(file)])
f3e5ae4f 268 match = re.match(".*\((.+)\)\r?$", result)
c65b670e
CP
269 if match:
270 return match.group(1)
271 else:
f3e5ae4f 272 die("Could not determine file type for %s (result: '%s')" % (file, result))
c65b670e 273
06804c76
LD
274# Return the set of all p4 labels
275def getP4Labels(depotPaths):
276 labels = set()
277 if isinstance(depotPaths,basestring):
278 depotPaths = [depotPaths]
279
280 for l in p4CmdList(["labels"] + ["%s..." % p for p in depotPaths]):
281 label = l['label']
282 labels.add(label)
283
284 return labels
285
286# Return the set of all git tags
287def getGitTags():
288 gitTags = set()
289 for line in read_pipe_lines(["git", "tag"]):
290 tag = line.strip()
291 gitTags.add(tag)
292 return gitTags
293
b43b0a3c
CP
294def diffTreePattern():
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(.*))|$)')
298 while True:
299 yield pattern
300
301def parseDiffTreeEntry(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)
321 if match:
322 return {
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 }
332 return None
333
c65b670e
CP
334def isModeExec(mode):
335 # Returns True if the given git mode represents an executable file,
336 # otherwise False.
337 return mode[-3:] == "755"
338
339def isModeExecChanged(src_mode, dst_mode):
340 return isModeExec(src_mode) != isModeExec(dst_mode)
341
b932705b 342def p4CmdList(cmd, stdin=None, stdin_mode='w+b', cb=None):
6de040df
LD
343
344 if isinstance(cmd,basestring):
345 cmd = "-G " + cmd
346 expand = True
347 else:
348 cmd = ["-G"] + cmd
349 expand = False
350
351 cmd = p4_build_cmd(cmd)
6a49f8e2 352 if verbose:
6de040df 353 sys.stderr.write("Opening pipe: %s\n" % str(cmd))
9f90c733
SL
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
359 if stdin is not None:
360 stdin_file = tempfile.TemporaryFile(prefix='p4-stdin', mode=stdin_mode)
6de040df
LD
361 if isinstance(stdin,basestring):
362 stdin_file.write(stdin)
363 else:
364 for i in stdin:
365 stdin_file.write(i + '\n')
9f90c733
SL
366 stdin_file.flush()
367 stdin_file.seek(0)
368
6de040df
LD
369 p4 = subprocess.Popen(cmd,
370 shell=expand,
9f90c733
SL
371 stdin=stdin_file,
372 stdout=subprocess.PIPE)
86949eef
SH
373
374 result = []
375 try:
376 while True:
9f90c733 377 entry = marshal.load(p4.stdout)
c3f6163b
AG
378 if cb is not None:
379 cb(entry)
380 else:
381 result.append(entry)
86949eef
SH
382 except EOFError:
383 pass
9f90c733
SL
384 exitCode = p4.wait()
385 if exitCode != 0:
ac3e0d79
SH
386 entry = {}
387 entry["p4ExitCode"] = exitCode
388 result.append(entry)
86949eef
SH
389
390 return result
391
392def p4Cmd(cmd):
393 list = p4CmdList(cmd)
394 result = {}
395 for entry in list:
396 result.update(entry)
397 return result;
398
cb2c9db5
SH
399def p4Where(depotPath):
400 if not depotPath.endswith("/"):
401 depotPath += "/"
7f705dc3 402 depotPath = depotPath + "..."
6de040df 403 outputList = p4CmdList(["where", depotPath])
7f705dc3
TAL
404 output = None
405 for entry in outputList:
75bc9573
TAL
406 if "depotFile" in entry:
407 if entry["depotFile"] == depotPath:
408 output = entry
409 break
410 elif "data" in entry:
411 data = entry.get("data")
412 space = data.find(" ")
413 if data[:space] == depotPath:
414 output = entry
415 break
7f705dc3
TAL
416 if output == None:
417 return ""
dc524036
SH
418 if output["code"] == "error":
419 return ""
cb2c9db5
SH
420 clientPath = ""
421 if "path" in output:
422 clientPath = output.get("path")
423 elif "data" in output:
424 data = output.get("data")
425 lastSpace = data.rfind(" ")
426 clientPath = data[lastSpace + 1:]
427
428 if clientPath.endswith("..."):
429 clientPath = clientPath[:-3]
430 return clientPath
431
86949eef 432def currentGitBranch():
b25b2065 433 return read_pipe("git name-rev HEAD").split(" ")[1].strip()
86949eef 434
4f5cf76a 435def isValidGitDir(path):
bb6e09b2
HWN
436 if (os.path.exists(path + "/HEAD")
437 and os.path.exists(path + "/refs") and os.path.exists(path + "/objects")):
4f5cf76a
SH
438 return True;
439 return False
440
463e8af6 441def parseRevision(ref):
b25b2065 442 return read_pipe("git rev-parse %s" % ref).strip()
463e8af6 443
28755dba
PW
444def branchExists(ref):
445 rev = read_pipe(["git", "rev-parse", "-q", "--verify", ref],
446 ignore_error=True)
447 return len(rev) > 0
448
6ae8de88
SH
449def extractLogMessageFromGitCommit(commit):
450 logMessage = ""
b016d397
HWN
451
452 ## fixme: title is first line of commit, not 1st paragraph.
6ae8de88 453 foundTitle = False
b016d397 454 for log in read_pipe_lines("git cat-file commit %s" % commit):
6ae8de88
SH
455 if not foundTitle:
456 if len(log) == 1:
1c094184 457 foundTitle = True
6ae8de88
SH
458 continue
459
460 logMessage += log
461 return logMessage
462
bb6e09b2 463def extractSettingsGitLog(log):
6ae8de88
SH
464 values = {}
465 for line in log.split("\n"):
466 line = line.strip()
6326aa58
HWN
467 m = re.search (r"^ *\[git-p4: (.*)\]$", line)
468 if not m:
469 continue
470
471 assignments = m.group(1).split (':')
472 for a in assignments:
473 vals = a.split ('=')
474 key = vals[0].strip()
475 val = ('='.join (vals[1:])).strip()
476 if val.endswith ('\"') and val.startswith('"'):
477 val = val[1:-1]
478
479 values[key] = val
480
845b42cb
SH
481 paths = values.get("depot-paths")
482 if not paths:
483 paths = values.get("depot-path")
a3fdd579
SH
484 if paths:
485 values['depot-paths'] = paths.split(',')
bb6e09b2 486 return values
6ae8de88 487
8136a639 488def gitBranchExists(branch):
bb6e09b2
HWN
489 proc = subprocess.Popen(["git", "rev-parse", branch],
490 stderr=subprocess.PIPE, stdout=subprocess.PIPE);
caace111 491 return proc.wait() == 0;
8136a639 492
36bd8446 493_gitConfig = {}
99f790f2 494def gitConfig(key, args = None): # set args to "--bool", for instance
36bd8446 495 if not _gitConfig.has_key(key):
99f790f2
TAL
496 argsFilter = ""
497 if args != None:
498 argsFilter = "%s " % args
499 cmd = "git config %s%s" % (argsFilter, key)
500 _gitConfig[key] = read_pipe(cmd, ignore_error=True).strip()
36bd8446 501 return _gitConfig[key]
01265103 502
7199cf13
VA
503def gitConfigList(key):
504 if not _gitConfig.has_key(key):
505 _gitConfig[key] = read_pipe("git config --get-all %s" % key, ignore_error=True).strip().split(os.linesep)
506 return _gitConfig[key]
507
062410bb
SH
508def p4BranchesInGit(branchesAreInRemotes = True):
509 branches = {}
510
511 cmdline = "git rev-parse --symbolic "
512 if branchesAreInRemotes:
513 cmdline += " --remotes"
514 else:
515 cmdline += " --branches"
516
517 for line in read_pipe_lines(cmdline):
518 line = line.strip()
519
520 ## only import to p4/
521 if not line.startswith('p4/') or line == "p4/HEAD":
522 continue
523 branch = line
524
525 # strip off p4
526 branch = re.sub ("^p4/", "", line)
527
528 branches[branch] = parseRevision(line)
529 return branches
530
9ceab363 531def findUpstreamBranchPoint(head = "HEAD"):
86506fe5
SH
532 branches = p4BranchesInGit()
533 # map from depot-path to branch name
534 branchByDepotPath = {}
535 for branch in branches.keys():
536 tip = branches[branch]
537 log = extractLogMessageFromGitCommit(tip)
538 settings = extractSettingsGitLog(log)
539 if settings.has_key("depot-paths"):
540 paths = ",".join(settings["depot-paths"])
541 branchByDepotPath[paths] = "remotes/p4/" + branch
542
27d2d811 543 settings = None
27d2d811
SH
544 parent = 0
545 while parent < 65535:
9ceab363 546 commit = head + "~%s" % parent
27d2d811
SH
547 log = extractLogMessageFromGitCommit(commit)
548 settings = extractSettingsGitLog(log)
86506fe5
SH
549 if settings.has_key("depot-paths"):
550 paths = ",".join(settings["depot-paths"])
551 if branchByDepotPath.has_key(paths):
552 return [branchByDepotPath[paths], settings]
27d2d811 553
86506fe5 554 parent = parent + 1
27d2d811 555
86506fe5 556 return ["", settings]
27d2d811 557
5ca44617
SH
558def createOrUpdateBranchesFromOrigin(localRefPrefix = "refs/remotes/p4/", silent=True):
559 if not silent:
560 print ("Creating/updating branch(es) in %s based on origin branch(es)"
561 % localRefPrefix)
562
563 originPrefix = "origin/p4/"
564
565 for line in read_pipe_lines("git rev-parse --symbolic --remotes"):
566 line = line.strip()
567 if (not line.startswith(originPrefix)) or line.endswith("HEAD"):
568 continue
569
570 headName = line[len(originPrefix):]
571 remoteHead = localRefPrefix + headName
572 originHead = line
573
574 original = extractSettingsGitLog(extractLogMessageFromGitCommit(originHead))
575 if (not original.has_key('depot-paths')
576 or not original.has_key('change')):
577 continue
578
579 update = False
580 if not gitBranchExists(remoteHead):
581 if verbose:
582 print "creating %s" % remoteHead
583 update = True
584 else:
585 settings = extractSettingsGitLog(extractLogMessageFromGitCommit(remoteHead))
586 if settings.has_key('change') > 0:
587 if settings['depot-paths'] == original['depot-paths']:
588 originP4Change = int(original['change'])
589 p4Change = int(settings['change'])
590 if originP4Change > p4Change:
591 print ("%s (%s) is newer than %s (%s). "
592 "Updating p4 branch from origin."
593 % (originHead, originP4Change,
594 remoteHead, p4Change))
595 update = True
596 else:
597 print ("Ignoring: %s was imported from %s while "
598 "%s was imported from %s"
599 % (originHead, ','.join(original['depot-paths']),
600 remoteHead, ','.join(settings['depot-paths'])))
601
602 if update:
603 system("git update-ref %s %s" % (remoteHead, originHead))
604
605def originP4BranchesExist():
606 return gitBranchExists("origin") or gitBranchExists("origin/p4") or gitBranchExists("origin/p4/master")
607
4f6432d8
SH
608def p4ChangesForPaths(depotPaths, changeRange):
609 assert depotPaths
6de040df
LD
610 cmd = ['changes']
611 for p in depotPaths:
612 cmd += ["%s...%s" % (p, changeRange)]
613 output = p4_read_pipe_lines(cmd)
4f6432d8 614
b4b0ba06 615 changes = {}
4f6432d8 616 for line in output:
c3f6163b
AG
617 changeNum = int(line.split(" ")[1])
618 changes[changeNum] = True
4f6432d8 619
b4b0ba06
PW
620 changelist = changes.keys()
621 changelist.sort()
622 return changelist
4f6432d8 623
d53de8b9
TAL
624def p4PathStartsWith(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"
633 if ignorecase:
634 return path.lower().startswith(prefix.lower())
635 return path.startswith(prefix)
636
543987bd
PW
637def getClientSpec():
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")
642 if len(specList) != 1:
643 die('Output from "client -o" is %d lines, expecting 1' %
644 len(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
656 for view_num in range(len(view_keys)):
657 k = "View%d" % view_num
658 if k not in view_keys:
659 die("Expected view key %s missing" % k)
660 view.append(entry[k])
661
662 return view
663
664def getClientRoot():
665 """Grab the client directory."""
666
667 output = p4CmdList("client -o")
668 if len(output) != 1:
669 die('Output from "client -o" is %d lines, expecting 1' % len(output))
670
671 entry = output[0]
672 if "Root" not in entry:
673 die('Client has no "Root"')
674
675 return entry["Root"]
676
9d7d446a
PW
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#
682def wildcard_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.
687 if not platform.system() == "Windows":
688 path = path.replace("%2A", "*")
689 path = path.replace("%23", "#") \
690 .replace("%40", "@") \
691 .replace("%25", "%")
692 return path
693
694def wildcard_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")
700 return path
701
702def wildcard_present(path):
703 return path.translate(None, "*#@%") != path
704
b984733c
SH
705class Command:
706 def __init__(self):
707 self.usage = "usage: %prog [options]"
8910ac0e 708 self.needsGit = True
6a10b6aa 709 self.verbose = False
b984733c 710
3ea2cfd4
LD
711class P4UserMap:
712 def __init__(self):
713 self.userMapFromPerforceServer = False
affb474f
LD
714 self.myP4UserId = None
715
716 def p4UserId(self):
717 if self.myP4UserId:
718 return self.myP4UserId
719
720 results = p4CmdList("user -o")
721 for r in results:
722 if r.has_key('User'):
723 self.myP4UserId = r['User']
724 return r['User']
725 die("Could not find your p4 user id")
726
727 def p4UserIsMe(self, p4User):
728 # return True if the given p4 user is actually me
729 me = self.p4UserId()
730 if not p4User or p4User != me:
731 return False
732 else:
733 return True
3ea2cfd4
LD
734
735 def getUserCacheFilename(self):
736 home = os.environ.get("HOME", os.environ.get("USERPROFILE"))
737 return home + "/.gitp4-usercache.txt"
738
739 def getUserMapFromPerforceServer(self):
740 if self.userMapFromPerforceServer:
741 return
742 self.users = {}
743 self.emails = {}
744
745 for output in p4CmdList("users"):
746 if not output.has_key("User"):
747 continue
748 self.users[output["User"]] = output["FullName"] + " <" + output["Email"] + ">"
749 self.emails[output["Email"]] = output["User"]
750
751
752 s = ''
753 for (key, val) in self.users.items():
754 s += "%s\t%s\n" % (key.expandtabs(1), val.expandtabs(1))
755
756 open(self.getUserCacheFilename(), "wb").write(s)
757 self.userMapFromPerforceServer = True
758
759 def loadUserMapFromCache(self):
760 self.users = {}
761 self.userMapFromPerforceServer = False
762 try:
763 cache = open(self.getUserCacheFilename(), "rb")
764 lines = cache.readlines()
765 cache.close()
766 for line in lines:
767 entry = line.strip().split("\t")
768 self.users[entry[0]] = entry[1]
769 except IOError:
770 self.getUserMapFromPerforceServer()
771
b984733c 772class P4Debug(Command):
86949eef 773 def __init__(self):
6ae8de88 774 Command.__init__(self)
6a10b6aa 775 self.options = []
c8c39116 776 self.description = "A tool to debug the output of p4 -G."
8910ac0e 777 self.needsGit = False
86949eef
SH
778
779 def run(self, args):
b1ce9447 780 j = 0
6de040df 781 for output in p4CmdList(args):
b1ce9447
HWN
782 print 'Element: %d' % j
783 j += 1
86949eef 784 print output
b984733c 785 return True
86949eef 786
5834684d
SH
787class P4RollBack(Command):
788 def __init__(self):
789 Command.__init__(self)
790 self.options = [
0c66a783 791 optparse.make_option("--local", dest="rollbackLocalBranches", action="store_true")
5834684d
SH
792 ]
793 self.description = "A tool to debug the multi-branch import. Don't use :)"
0c66a783 794 self.rollbackLocalBranches = False
5834684d
SH
795
796 def run(self, args):
797 if len(args) != 1:
798 return False
799 maxChange = int(args[0])
0c66a783 800
ad192f28 801 if "p4ExitCode" in p4Cmd("changes -m 1"):
66a2f523
SH
802 die("Problems executing p4");
803
0c66a783
SH
804 if self.rollbackLocalBranches:
805 refPrefix = "refs/heads/"
b016d397 806 lines = read_pipe_lines("git rev-parse --symbolic --branches")
0c66a783
SH
807 else:
808 refPrefix = "refs/remotes/"
b016d397 809 lines = read_pipe_lines("git rev-parse --symbolic --remotes")
0c66a783
SH
810
811 for line in lines:
812 if self.rollbackLocalBranches or (line.startswith("p4/") and line != "p4/HEAD\n"):
b25b2065
HWN
813 line = line.strip()
814 ref = refPrefix + line
5834684d 815 log = extractLogMessageFromGitCommit(ref)
bb6e09b2
HWN
816 settings = extractSettingsGitLog(log)
817
818 depotPaths = settings['depot-paths']
819 change = settings['change']
820
5834684d 821 changed = False
52102d47 822
6326aa58
HWN
823 if len(p4Cmd("changes -m 1 " + ' '.join (['%s...@%s' % (p, maxChange)
824 for p in depotPaths]))) == 0:
52102d47
SH
825 print "Branch %s did not exist at change %s, deleting." % (ref, maxChange)
826 system("git update-ref -d %s `git rev-parse %s`" % (ref, ref))
827 continue
828
bb6e09b2 829 while change and int(change) > maxChange:
5834684d 830 changed = True
52102d47
SH
831 if self.verbose:
832 print "%s is at %s ; rewinding towards %s" % (ref, change, maxChange)
5834684d
SH
833 system("git update-ref %s \"%s^\"" % (ref, ref))
834 log = extractLogMessageFromGitCommit(ref)
bb6e09b2
HWN
835 settings = extractSettingsGitLog(log)
836
837
838 depotPaths = settings['depot-paths']
839 change = settings['change']
5834684d
SH
840
841 if changed:
52102d47 842 print "%s rewound to %s" % (ref, change)
5834684d
SH
843
844 return True
845
3ea2cfd4 846class P4Submit(Command, P4UserMap):
4f5cf76a 847 def __init__(self):
b984733c 848 Command.__init__(self)
3ea2cfd4 849 P4UserMap.__init__(self)
4f5cf76a 850 self.options = [
4f5cf76a 851 optparse.make_option("--origin", dest="origin"),
ae901090 852 optparse.make_option("-M", dest="detectRenames", action="store_true"),
3ea2cfd4
LD
853 # preserve the user, requires relevant p4 permissions
854 optparse.make_option("--preserve-user", dest="preserveUser", action="store_true"),
06804c76 855 optparse.make_option("--export-labels", dest="exportLabels", action="store_true"),
4f5cf76a
SH
856 ]
857 self.description = "Submit changes from git to the perforce depot."
c9b50e63 858 self.usage += " [name of git branch to submit into perforce depot]"
9512497b 859 self.origin = ""
ae901090 860 self.detectRenames = False
3ea2cfd4 861 self.preserveUser = gitConfig("git-p4.preserveUser").lower() == "true"
f7baba8b 862 self.isWindows = (platform.system() == "Windows")
06804c76 863 self.exportLabels = False
8e9497c2 864 self.p4HasMoveCommand = p4_has_command("move")
4f5cf76a 865
4f5cf76a
SH
866 def check(self):
867 if len(p4CmdList("opened ...")) > 0:
868 die("You have files opened with perforce! Close them before starting the sync.")
869
f19cb0a0
PW
870 def separate_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)
887 if m is None:
888 return (message, None)
889
890 jobtext = message[m.start():]
891 stripped_message = message[:m.start()].rstrip()
892 return (stripped_message, jobtext)
893
894 def prepareLogMessage(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."""
4f5cf76a
SH
898 result = ""
899
edae1e2f
SH
900 inDescriptionSection = False
901
4f5cf76a
SH
902 for line in template.split("\n"):
903 if line.startswith("#"):
904 result += line + "\n"
905 continue
906
edae1e2f 907 if inDescriptionSection:
c9dbab04 908 if line.startswith("Files:") or line.startswith("Jobs:"):
edae1e2f 909 inDescriptionSection = False
f19cb0a0
PW
910 # insert Jobs section
911 if jobs:
912 result += jobs + "\n"
edae1e2f
SH
913 else:
914 continue
915 else:
916 if line.startswith("Description:"):
917 inDescriptionSection = True
918 line += "\n"
919 for messageLine in message.split("\n"):
920 line += "\t" + messageLine + "\n"
921
922 result += line + "\n"
4f5cf76a
SH
923
924 return result
925
60df071c
LD
926 def patchRCSKeywords(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='.')
929 try:
930 outFile = os.fdopen(handle, "w+")
931 inFile = open(file, "r")
932 regexp = re.compile(pattern, re.VERBOSE)
933 for 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)
941 except:
942 # cleanup our temporary file
943 os.unlink(outFileName)
944 print "Failed to strip RCS keywords in %s" % file
945 raise
946
947 print "Patched up RCS keywords in %s" % file
948
3ea2cfd4
LD
949 def p4UserForCommit(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()
954 if not self.emails.has_key(gitEmail):
955 return (None,gitEmail)
956 else:
957 return (self.emails[gitEmail],gitEmail)
958
959 def checkValidP4Users(self,commits):
960 # check if any git authors cannot be mapped to p4 users
961 for id in commits:
962 (user,email) = self.p4UserForCommit(id)
963 if not user:
964 msg = "Cannot find p4 user for email %s in commit %s." % (email, id)
965 if gitConfig('git-p4.allowMissingP4Users').lower() == "true":
966 print "%s" % msg
967 else:
968 die("Error: %s\nSet git-p4.allowMissingP4Users to true to allow this." % msg)
969
970 def lastP4Changelist(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
977 for r in results:
978 if r.has_key('Client'):
979 client = r['Client']
980 break
981 if not client:
982 die("could not get client spec")
6de040df 983 results = p4CmdList(["changes", "-c", client, "-m", "1"])
3ea2cfd4
LD
984 for r in results:
985 if r.has_key('change'):
986 return r['change']
987 die("Could not get changelist number for last submit - cannot patch up user details")
988
989 def modifyChangelistUser(self, changelist, newUser):
990 # fixup the user field of a changelist after it has been submitted.
991 changes = p4CmdList("change -o %s" % changelist)
ecdba36d
LD
992 if len(changes) != 1:
993 die("Bad output from p4 change modifying %s to user %s" %
994 (changelist, newUser))
995
996 c = changes[0]
997 if c['User'] == newUser: return # nothing to do
998 c['User'] = newUser
999 input = marshal.dumps(c)
1000
3ea2cfd4
LD
1001 result = p4CmdList("change -f -i", stdin=input)
1002 for r in result:
1003 if r.has_key('code'):
1004 if r['code'] == 'error':
1005 die("Could not modify user field of changelist %s to %s:%s" % (changelist, newUser, r['data']))
1006 if r.has_key('data'):
1007 print("Updated user field for changelist %s to %s" % (changelist, newUser))
1008 return
1009 die("Could not modify user field of changelist %s to %s" % (changelist, newUser))
1010
1011 def canChangeChangelists(self):
1012 # check to see if we have p4 admin or super-user permissions, either of
1013 # which are required to modify changelists.
52a4880b 1014 results = p4CmdList(["protects", self.depotPath])
3ea2cfd4
LD
1015 for r in results:
1016 if r.has_key('perm'):
1017 if r['perm'] == 'admin':
1018 return 1
1019 if r['perm'] == 'super':
1020 return 1
1021 return 0
1022
ea99c3ae 1023 def prepareSubmitTemplate(self):
f19cb0a0
PW
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 submission
1026 template in original order, since a human might edit it.
1027
1028 Remove lines in the Files section that show changes to files
1029 outside the depot path we're committing into."""
1030
ea99c3ae
SH
1031 template = ""
1032 inFilesSection = False
6de040df 1033 for line in p4_read_pipe_lines(['change', '-o']):
f3e5ae4f
MSO
1034 if line.endswith("\r\n"):
1035 line = line[:-2] + "\n"
ea99c3ae
SH
1036 if inFilesSection:
1037 if line.startswith("\t"):
1038 # path starts and ends with a tab
1039 path = line[1:]
1040 lastTab = path.rfind("\t")
1041 if lastTab != -1:
1042 path = path[:lastTab]
d53de8b9 1043 if not p4PathStartsWith(path, self.depotPath):
ea99c3ae
SH
1044 continue
1045 else:
1046 inFilesSection = False
1047 else:
1048 if line.startswith("Files:"):
1049 inFilesSection = True
1050
1051 template += line
1052
1053 return template
1054
7c766e57
PW
1055 def edit_template(self, template_file):
1056 """Invoke the editor to let the user change the submission
1057 message. Return true if okay to continue with the submit."""
1058
1059 # if configured to skip the editing part, just submit
1060 if gitConfig("git-p4.skipSubmitEdit") == "true":
1061 return True
1062
1063 # look at the modification time, to check later if the user saved
1064 # the file
1065 mtime = os.stat(template_file).st_mtime
1066
1067 # invoke the editor
f95ceaf0 1068 if os.environ.has_key("P4EDITOR") and (os.environ.get("P4EDITOR") != ""):
7c766e57
PW
1069 editor = os.environ.get("P4EDITOR")
1070 else:
1071 editor = read_pipe("git var GIT_EDITOR").strip()
1072 system(editor + " " + template_file)
1073
1074 # If the file was not saved, prompt to see if this patch should
1075 # be skipped. But skip this verification step if configured so.
1076 if gitConfig("git-p4.skipSubmitEditCheck") == "true":
1077 return True
1078
d1652049
PW
1079 # modification time updated means user saved the file
1080 if os.stat(template_file).st_mtime > mtime:
1081 return True
1082
1083 while True:
1084 response = raw_input("Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) ")
1085 if response == 'y':
1086 return True
1087 if response == 'n':
1088 return False
7c766e57 1089
7cb5cbef 1090 def applyCommit(self, id):
0e36f2d7 1091 print "Applying %s" % (read_pipe("git log --max-count=1 --pretty=oneline %s" % id))
ae901090 1092
848de9c3 1093 (p4User, gitEmail) = self.p4UserForCommit(id)
3ea2cfd4 1094
84cb0003 1095 diff = read_pipe_lines("git diff-tree -r %s \"%s^\" \"%s\"" % (self.diffOpts, id, id))
4f5cf76a
SH
1096 filesToAdd = set()
1097 filesToDelete = set()
d336c158 1098 editedFiles = set()
b6ad6dcc 1099 pureRenameCopy = set()
c65b670e 1100 filesToChangeExecBit = {}
60df071c 1101
4f5cf76a 1102 for line in diff:
b43b0a3c
CP
1103 diff = parseDiffTreeEntry(line)
1104 modifier = diff['status']
1105 path = diff['src']
4f5cf76a 1106 if modifier == "M":
6de040df 1107 p4_edit(path)
c65b670e
CP
1108 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
1109 filesToChangeExecBit[path] = diff['dst_mode']
d336c158 1110 editedFiles.add(path)
4f5cf76a
SH
1111 elif modifier == "A":
1112 filesToAdd.add(path)
c65b670e 1113 filesToChangeExecBit[path] = diff['dst_mode']
4f5cf76a
SH
1114 if path in filesToDelete:
1115 filesToDelete.remove(path)
1116 elif modifier == "D":
1117 filesToDelete.add(path)
1118 if path in filesToAdd:
1119 filesToAdd.remove(path)
4fddb41b
VA
1120 elif modifier == "C":
1121 src, dest = diff['src'], diff['dst']
6de040df 1122 p4_integrate(src, dest)
b6ad6dcc 1123 pureRenameCopy.add(dest)
4fddb41b 1124 if diff['src_sha1'] != diff['dst_sha1']:
6de040df 1125 p4_edit(dest)
b6ad6dcc 1126 pureRenameCopy.discard(dest)
4fddb41b 1127 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
6de040df 1128 p4_edit(dest)
b6ad6dcc 1129 pureRenameCopy.discard(dest)
4fddb41b
VA
1130 filesToChangeExecBit[dest] = diff['dst_mode']
1131 os.unlink(dest)
1132 editedFiles.add(dest)
d9a5f25b 1133 elif modifier == "R":
b43b0a3c 1134 src, dest = diff['src'], diff['dst']
8e9497c2
GG
1135 if self.p4HasMoveCommand:
1136 p4_edit(src) # src must be open before move
1137 p4_move(src, dest) # opens for (move/delete, move/add)
b6ad6dcc 1138 else:
8e9497c2
GG
1139 p4_integrate(src, dest)
1140 if diff['src_sha1'] != diff['dst_sha1']:
1141 p4_edit(dest)
1142 else:
1143 pureRenameCopy.add(dest)
c65b670e 1144 if isModeExecChanged(diff['src_mode'], diff['dst_mode']):
8e9497c2
GG
1145 if not self.p4HasMoveCommand:
1146 p4_edit(dest) # with move: already open, writable
c65b670e 1147 filesToChangeExecBit[dest] = diff['dst_mode']
8e9497c2
GG
1148 if not self.p4HasMoveCommand:
1149 os.unlink(dest)
1150 filesToDelete.add(src)
d9a5f25b 1151 editedFiles.add(dest)
4f5cf76a
SH
1152 else:
1153 die("unknown modifier %s for %s" % (modifier, path))
1154
0e36f2d7 1155 diffcmd = "git format-patch -k --stdout \"%s^\"..\"%s\"" % (id, id)
47a130b7 1156 patchcmd = diffcmd + " | git apply "
c1b296b9
SH
1157 tryPatchCmd = patchcmd + "--check -"
1158 applyPatchCmd = patchcmd + "--check --apply -"
60df071c 1159 patch_succeeded = True
51a2640a 1160
47a130b7 1161 if os.system(tryPatchCmd) != 0:
60df071c
LD
1162 fixed_rcs_keywords = False
1163 patch_succeeded = False
51a2640a 1164 print "Unfortunately applying the change failed!"
60df071c
LD
1165
1166 # Patch failed, maybe it's just RCS keyword woes. Look through
1167 # the patch to see if that's possible.
1168 if gitConfig("git-p4.attemptRCSCleanup","--bool") == "true":
1169 file = None
1170 pattern = None
1171 kwfiles = {}
1172 for file in editedFiles | filesToDelete:
1173 # did this file's delta contain RCS keywords?
1174 pattern = p4_keywords_regexp_for_file(file)
1175
1176 if pattern:
1177 # this file is a possibility...look for RCS keywords.
1178 regexp = re.compile(pattern, re.VERBOSE)
1179 for line in read_pipe_lines(["git", "diff", "%s^..%s" % (id, id), file]):
1180 if regexp.search(line):
1181 if verbose:
1182 print "got keyword match on %s in %s in %s" % (pattern, line, file)
1183 kwfiles[file] = pattern
1184 break
1185
1186 for file in kwfiles:
1187 if verbose:
1188 print "zapping %s with %s" % (line,pattern)
1189 self.patchRCSKeywords(file, kwfiles[file])
1190 fixed_rcs_keywords = True
1191
1192 if fixed_rcs_keywords:
1193 print "Retrying the patch with RCS keywords cleaned up"
1194 if os.system(tryPatchCmd) == 0:
1195 patch_succeeded = True
1196
1197 if not patch_succeeded:
51a2640a
SH
1198 print "What do you want to do?"
1199 response = "x"
1200 while response != "s" and response != "a" and response != "w":
cebdf5af
HWN
1201 response = raw_input("[s]kip this patch / [a]pply the patch forcibly "
1202 "and with .rej files / [w]rite the patch to a file (patch.txt) ")
51a2640a
SH
1203 if response == "s":
1204 print "Skipping! Good luck with the next patches..."
20947149 1205 for f in editedFiles:
6de040df 1206 p4_revert(f)
20947149 1207 for f in filesToAdd:
6de040df 1208 os.remove(f)
51a2640a
SH
1209 return
1210 elif response == "a":
47a130b7 1211 os.system(applyPatchCmd)
51a2640a
SH
1212 if len(filesToAdd) > 0:
1213 print "You may also want to call p4 add on the following files:"
1214 print " ".join(filesToAdd)
1215 if len(filesToDelete):
1216 print "The following files should be scheduled for deletion with p4 delete:"
1217 print " ".join(filesToDelete)
cebdf5af 1218 die("Please resolve and submit the conflict manually and "
9dcb9f24 1219 + "continue afterwards with git p4 submit --continue")
51a2640a
SH
1220 elif response == "w":
1221 system(diffcmd + " > patch.txt")
1222 print "Patch saved to patch.txt in %s !" % self.clientPath
cebdf5af 1223 die("Please resolve and submit the conflict manually and "
9dcb9f24 1224 "continue afterwards with git p4 submit --continue")
51a2640a 1225
47a130b7 1226 system(applyPatchCmd)
4f5cf76a
SH
1227
1228 for f in filesToAdd:
6de040df 1229 p4_add(f)
4f5cf76a 1230 for f in filesToDelete:
6de040df
LD
1231 p4_revert(f)
1232 p4_delete(f)
4f5cf76a 1233
c65b670e
CP
1234 # Set/clear executable bits
1235 for f in filesToChangeExecBit.keys():
1236 mode = filesToChangeExecBit[f]
1237 setP4ExecBit(f, mode)
1238
0e36f2d7 1239 logMessage = extractLogMessageFromGitCommit(id)
0e36f2d7 1240 logMessage = logMessage.strip()
f19cb0a0 1241 (logMessage, jobs) = self.separate_jobs_from_description(logMessage)
4f5cf76a 1242
ea99c3ae 1243 template = self.prepareSubmitTemplate()
f19cb0a0 1244 submitTemplate = self.prepareLogMessage(template, logMessage, jobs)
ecdba36d 1245
c47178d4
PW
1246 if self.preserveUser:
1247 submitTemplate = submitTemplate + ("\n######## Actual user %s, modified after commit\n" % p4User)
1248
1249 if os.environ.has_key("P4DIFF"):
1250 del(os.environ["P4DIFF"])
1251 diff = ""
1252 for editedFile in editedFiles:
1253 diff += p4_read_pipe(['diff', '-du',
1254 wildcard_encode(editedFile)])
1255
1256 newdiff = ""
1257 for newFile in filesToAdd:
1258 newdiff += "==== new file ====\n"
1259 newdiff += "--- /dev/null\n"
1260 newdiff += "+++ %s\n" % newFile
1261 f = open(newFile, "r")
1262 for line in f.readlines():
1263 newdiff += "+" + line
1264 f.close()
1265
1266 if self.checkAuthorship and not self.p4UserIsMe(p4User):
1267 submitTemplate += "######## git author %s does not match your p4 account.\n" % gitEmail
1268 submitTemplate += "######## Use option --preserve-user to modify authorship.\n"
1269 submitTemplate += "######## Variable git-p4.skipUserNameCheck hides this message.\n"
1270
1271 separatorLine = "######## everything below this line is just the diff #######\n"
1272
1273 (handle, fileName) = tempfile.mkstemp()
1274 tmpFile = os.fdopen(handle, "w+")
1275 if self.isWindows:
1276 submitTemplate = submitTemplate.replace("\n", "\r\n")
1277 separatorLine = separatorLine.replace("\n", "\r\n")
1278 newdiff = newdiff.replace("\n", "\r\n")
1279 tmpFile.write(submitTemplate + separatorLine + diff + newdiff)
1280 tmpFile.close()
1281
1282 if self.edit_template(fileName):
1283 # read the edited message and submit
1284 tmpFile = open(fileName, "rb")
1285 message = tmpFile.read()
e96e400f 1286 tmpFile.close()
c47178d4
PW
1287 submitTemplate = message[:message.index(separatorLine)]
1288 if self.isWindows:
1289 submitTemplate = submitTemplate.replace("\r\n", "\n")
1290 p4_write_pipe(['submit', '-i'], submitTemplate)
e96e400f 1291
c47178d4
PW
1292 if self.preserveUser:
1293 if p4User:
1294 # Get last changelist number. Cannot easily get it from
1295 # the submit command output as the output is
1296 # unmarshalled.
1297 changelist = self.lastP4Changelist()
1298 self.modifyChangelistUser(changelist, p4User)
1299
1300 # The rename/copy happened by applying a patch that created a
1301 # new file. This leaves it writable, which confuses p4.
1302 for f in pureRenameCopy:
1303 p4_sync(f, "-f")
cdc7e388 1304
4f5cf76a 1305 else:
c47178d4
PW
1306 # skip this patch
1307 print "Submission cancelled, undoing p4 changes."
1308 for f in editedFiles:
1309 p4_revert(f)
1310 for f in filesToAdd:
1311 p4_revert(f)
1312 os.remove(f)
1313
1314 os.remove(fileName)
4f5cf76a 1315
06804c76
LD
1316 # Export git tags as p4 labels. Create a p4 label and then tag
1317 # with that.
1318 def exportGitTags(self, gitTags):
c8942a22
LD
1319 validLabelRegexp = gitConfig("git-p4.labelExportRegexp")
1320 if len(validLabelRegexp) == 0:
1321 validLabelRegexp = defaultLabelRegexp
1322 m = re.compile(validLabelRegexp)
06804c76
LD
1323
1324 for name in gitTags:
1325
1326 if not m.match(name):
1327 if verbose:
05a3cec5 1328 print "tag %s does not match regexp %s" % (name, validLabelRegexp)
06804c76
LD
1329 continue
1330
1331 # Get the p4 commit this corresponds to
c8942a22
LD
1332 logMessage = extractLogMessageFromGitCommit(name)
1333 values = extractSettingsGitLog(logMessage)
06804c76 1334
c8942a22 1335 if not values.has_key('change'):
06804c76
LD
1336 # a tag pointing to something not sent to p4; ignore
1337 if verbose:
1338 print "git tag %s does not give a p4 commit" % name
1339 continue
c8942a22
LD
1340 else:
1341 changelist = values['change']
06804c76
LD
1342
1343 # Get the tag details.
1344 inHeader = True
1345 isAnnotated = False
1346 body = []
1347 for l in read_pipe_lines(["git", "cat-file", "-p", name]):
1348 l = l.strip()
1349 if inHeader:
1350 if re.match(r'tag\s+', l):
1351 isAnnotated = True
1352 elif re.match(r'\s*$', l):
1353 inHeader = False
1354 continue
1355 else:
1356 body.append(l)
1357
1358 if not isAnnotated:
1359 body = ["lightweight tag imported by git p4\n"]
1360
1361 # Create the label - use the same view as the client spec we are using
1362 clientSpec = getClientSpec()
1363
1364 labelTemplate = "Label: %s\n" % name
1365 labelTemplate += "Description:\n"
1366 for b in body:
1367 labelTemplate += "\t" + b + "\n"
1368 labelTemplate += "View:\n"
1369 for mapping in clientSpec.mappings:
1370 labelTemplate += "\t%s\n" % mapping.depot_side.path
1371
1372 p4_write_pipe(["label", "-i"], labelTemplate)
1373
1374 # Use the label
1375 p4_system(["tag", "-l", name] +
1376 ["%s@%s" % (mapping.depot_side.path, changelist) for mapping in clientSpec.mappings])
1377
1378 if verbose:
1379 print "created p4 label for tag %s" % name
1380
4f5cf76a 1381 def run(self, args):
c9b50e63
SH
1382 if len(args) == 0:
1383 self.master = currentGitBranch()
4280e533 1384 if len(self.master) == 0 or not gitBranchExists("refs/heads/%s" % self.master):
c9b50e63
SH
1385 die("Detecting current git branch failed!")
1386 elif len(args) == 1:
1387 self.master = args[0]
28755dba
PW
1388 if not branchExists(self.master):
1389 die("Branch %s does not exist" % self.master)
c9b50e63
SH
1390 else:
1391 return False
1392
4c2d5d72
JX
1393 allowSubmit = gitConfig("git-p4.allowSubmit")
1394 if len(allowSubmit) > 0 and not self.master in allowSubmit.split(","):
1395 die("%s is not in git-p4.allowSubmit" % self.master)
1396
27d2d811 1397 [upstream, settings] = findUpstreamBranchPoint()
ea99c3ae 1398 self.depotPath = settings['depot-paths'][0]
27d2d811
SH
1399 if len(self.origin) == 0:
1400 self.origin = upstream
a3fdd579 1401
3ea2cfd4
LD
1402 if self.preserveUser:
1403 if not self.canChangeChangelists():
1404 die("Cannot preserve user names without p4 super-user or admin permissions")
1405
a3fdd579
SH
1406 if self.verbose:
1407 print "Origin branch is " + self.origin
9512497b 1408
ea99c3ae 1409 if len(self.depotPath) == 0:
9512497b
SH
1410 print "Internal error: cannot locate perforce depot path from existing branches"
1411 sys.exit(128)
1412
543987bd
PW
1413 self.useClientSpec = False
1414 if gitConfig("git-p4.useclientspec", "--bool") == "true":
1415 self.useClientSpec = True
1416 if self.useClientSpec:
1417 self.clientSpecDirs = getClientSpec()
9512497b 1418
543987bd
PW
1419 if self.useClientSpec:
1420 # all files are relative to the client spec
1421 self.clientPath = getClientRoot()
1422 else:
1423 self.clientPath = p4Where(self.depotPath)
9512497b 1424
543987bd
PW
1425 if self.clientPath == "":
1426 die("Error: Cannot locate perforce checkout of %s in client view" % self.depotPath)
9512497b 1427
ea99c3ae 1428 print "Perforce checkout for depot path %s located at %s" % (self.depotPath, self.clientPath)
7944f142 1429 self.oldWorkingDirectory = os.getcwd()
c1b296b9 1430
0591cfa8 1431 # ensure the clientPath exists
8d7ec362 1432 new_client_dir = False
0591cfa8 1433 if not os.path.exists(self.clientPath):
8d7ec362 1434 new_client_dir = True
0591cfa8
GG
1435 os.makedirs(self.clientPath)
1436
053fd0c1 1437 chdir(self.clientPath)
6a01298a 1438 print "Synchronizing p4 checkout..."
8d7ec362
PW
1439 if new_client_dir:
1440 # old one was destroyed, and maybe nobody told p4
1441 p4_sync("...", "-f")
1442 else:
1443 p4_sync("...")
4f5cf76a 1444 self.check()
4f5cf76a 1445
4c750c0d
SH
1446 commits = []
1447 for line in read_pipe_lines("git rev-list --no-merges %s..%s" % (self.origin, self.master)):
1448 commits.append(line.strip())
1449 commits.reverse()
4f5cf76a 1450
848de9c3
LD
1451 if self.preserveUser or (gitConfig("git-p4.skipUserNameCheck") == "true"):
1452 self.checkAuthorship = False
1453 else:
1454 self.checkAuthorship = True
1455
3ea2cfd4
LD
1456 if self.preserveUser:
1457 self.checkValidP4Users(commits)
1458
84cb0003
GG
1459 #
1460 # Build up a set of options to be passed to diff when
1461 # submitting each commit to p4.
1462 #
1463 if self.detectRenames:
1464 # command-line -M arg
1465 self.diffOpts = "-M"
1466 else:
1467 # If not explicitly set check the config variable
1468 detectRenames = gitConfig("git-p4.detectRenames")
1469
1470 if detectRenames.lower() == "false" or detectRenames == "":
1471 self.diffOpts = ""
1472 elif detectRenames.lower() == "true":
1473 self.diffOpts = "-M"
1474 else:
1475 self.diffOpts = "-M%s" % detectRenames
1476
1477 # no command-line arg for -C or --find-copies-harder, just
1478 # config variables
1479 detectCopies = gitConfig("git-p4.detectCopies")
1480 if detectCopies.lower() == "false" or detectCopies == "":
1481 pass
1482 elif detectCopies.lower() == "true":
1483 self.diffOpts += " -C"
1484 else:
1485 self.diffOpts += " -C%s" % detectCopies
1486
1487 if gitConfig("git-p4.detectCopiesHarder", "--bool") == "true":
1488 self.diffOpts += " --find-copies-harder"
1489
4f5cf76a 1490 while len(commits) > 0:
4f5cf76a
SH
1491 commit = commits[0]
1492 commits = commits[1:]
7cb5cbef 1493 self.applyCommit(commit)
4f5cf76a 1494
4f5cf76a 1495 if len(commits) == 0:
4c750c0d 1496 print "All changes applied!"
053fd0c1 1497 chdir(self.oldWorkingDirectory)
14594f4b 1498
4c750c0d
SH
1499 sync = P4Sync()
1500 sync.run([])
14594f4b 1501
4c750c0d
SH
1502 rebase = P4Rebase()
1503 rebase.rebase()
4f5cf76a 1504
06804c76 1505 if gitConfig("git-p4.exportLabels", "--bool") == "true":
06dcd152 1506 self.exportLabels = True
06804c76
LD
1507
1508 if self.exportLabels:
1509 p4Labels = getP4Labels(self.depotPath)
1510 gitTags = getGitTags()
1511
1512 missingGitTags = gitTags - p4Labels
1513 self.exportGitTags(missingGitTags)
1514
b984733c
SH
1515 return True
1516
ecb7cf98
PW
1517class View(object):
1518 """Represent a p4 view ("p4 help views"), and map files in a
1519 repo according to the view."""
1520
1521 class Path(object):
1522 """A depot or client path, possibly containing wildcards.
1523 The only one supported is ... at the end, currently.
1524 Initialize with the full path, with //depot or //client."""
1525
1526 def __init__(self, path, is_depot):
1527 self.path = path
1528 self.is_depot = is_depot
1529 self.find_wildcards()
1530 # remember the prefix bit, useful for relative mappings
1531 m = re.match("(//[^/]+/)", self.path)
1532 if not m:
1533 die("Path %s does not start with //prefix/" % self.path)
1534 prefix = m.group(1)
1535 if not self.is_depot:
1536 # strip //client/ on client paths
1537 self.path = self.path[len(prefix):]
1538
1539 def find_wildcards(self):
1540 """Make sure wildcards are valid, and set up internal
1541 variables."""
1542
1543 self.ends_triple_dot = False
1544 # There are three wildcards allowed in p4 views
1545 # (see "p4 help views"). This code knows how to
1546 # handle "..." (only at the end), but cannot deal with
1547 # "%%n" or "*". Only check the depot_side, as p4 should
1548 # validate that the client_side matches too.
1549 if re.search(r'%%[1-9]', self.path):
1550 die("Can't handle %%n wildcards in view: %s" % self.path)
1551 if self.path.find("*") >= 0:
1552 die("Can't handle * wildcards in view: %s" % self.path)
1553 triple_dot_index = self.path.find("...")
1554 if triple_dot_index >= 0:
43b82bd9
PW
1555 if triple_dot_index != len(self.path) - 3:
1556 die("Can handle only single ... wildcard, at end: %s" %
ecb7cf98
PW
1557 self.path)
1558 self.ends_triple_dot = True
1559
1560 def ensure_compatible(self, other_path):
1561 """Make sure the wildcards agree."""
1562 if self.ends_triple_dot != other_path.ends_triple_dot:
1563 die("Both paths must end with ... if either does;\n" +
1564 "paths: %s %s" % (self.path, other_path.path))
1565
1566 def match_wildcards(self, test_path):
1567 """See if this test_path matches us, and fill in the value
1568 of the wildcards if so. Returns a tuple of
1569 (True|False, wildcards[]). For now, only the ... at end
1570 is supported, so at most one wildcard."""
1571 if self.ends_triple_dot:
1572 dotless = self.path[:-3]
1573 if test_path.startswith(dotless):
1574 wildcard = test_path[len(dotless):]
1575 return (True, [ wildcard ])
1576 else:
1577 if test_path == self.path:
1578 return (True, [])
1579 return (False, [])
1580
1581 def match(self, test_path):
1582 """Just return if it matches; don't bother with the wildcards."""
1583 b, _ = self.match_wildcards(test_path)
1584 return b
1585
1586 def fill_in_wildcards(self, wildcards):
1587 """Return the relative path, with the wildcards filled in
1588 if there are any."""
1589 if self.ends_triple_dot:
1590 return self.path[:-3] + wildcards[0]
1591 else:
1592 return self.path
1593
1594 class Mapping(object):
1595 def __init__(self, depot_side, client_side, overlay, exclude):
1596 # depot_side is without the trailing /... if it had one
1597 self.depot_side = View.Path(depot_side, is_depot=True)
1598 self.client_side = View.Path(client_side, is_depot=False)
1599 self.overlay = overlay # started with "+"
1600 self.exclude = exclude # started with "-"
1601 assert not (self.overlay and self.exclude)
1602 self.depot_side.ensure_compatible(self.client_side)
1603
1604 def __str__(self):
1605 c = " "
1606 if self.overlay:
1607 c = "+"
1608 if self.exclude:
1609 c = "-"
1610 return "View.Mapping: %s%s -> %s" % \
329afb8e 1611 (c, self.depot_side.path, self.client_side.path)
ecb7cf98
PW
1612
1613 def map_depot_to_client(self, depot_path):
1614 """Calculate the client path if using this mapping on the
1615 given depot path; does not consider the effect of other
1616 mappings in a view. Even excluded mappings are returned."""
1617 matches, wildcards = self.depot_side.match_wildcards(depot_path)
1618 if not matches:
1619 return ""
1620 client_path = self.client_side.fill_in_wildcards(wildcards)
1621 return client_path
1622
1623 #
1624 # View methods
1625 #
1626 def __init__(self):
1627 self.mappings = []
1628
1629 def append(self, view_line):
1630 """Parse a view line, splitting it into depot and client
1631 sides. Append to self.mappings, preserving order."""
1632
1633 # Split the view line into exactly two words. P4 enforces
1634 # structure on these lines that simplifies this quite a bit.
1635 #
1636 # Either or both words may be double-quoted.
1637 # Single quotes do not matter.
1638 # Double-quote marks cannot occur inside the words.
1639 # A + or - prefix is also inside the quotes.
1640 # There are no quotes unless they contain a space.
1641 # The line is already white-space stripped.
1642 # The two words are separated by a single space.
1643 #
1644 if view_line[0] == '"':
1645 # First word is double quoted. Find its end.
1646 close_quote_index = view_line.find('"', 1)
1647 if close_quote_index <= 0:
1648 die("No first-word closing quote found: %s" % view_line)
1649 depot_side = view_line[1:close_quote_index]
1650 # skip closing quote and space
1651 rhs_index = close_quote_index + 1 + 1
1652 else:
1653 space_index = view_line.find(" ")
1654 if space_index <= 0:
1655 die("No word-splitting space found: %s" % view_line)
1656 depot_side = view_line[0:space_index]
1657 rhs_index = space_index + 1
1658
1659 if view_line[rhs_index] == '"':
1660 # Second word is double quoted. Make sure there is a
1661 # double quote at the end too.
1662 if not view_line.endswith('"'):
1663 die("View line with rhs quote should end with one: %s" %
1664 view_line)
1665 # skip the quotes
1666 client_side = view_line[rhs_index+1:-1]
1667 else:
1668 client_side = view_line[rhs_index:]
1669
1670 # prefix + means overlay on previous mapping
1671 overlay = False
1672 if depot_side.startswith("+"):
1673 overlay = True
1674 depot_side = depot_side[1:]
1675
1676 # prefix - means exclude this path
1677 exclude = False
1678 if depot_side.startswith("-"):
1679 exclude = True
1680 depot_side = depot_side[1:]
1681
1682 m = View.Mapping(depot_side, client_side, overlay, exclude)
1683 self.mappings.append(m)
1684
1685 def map_in_client(self, depot_path):
1686 """Return the relative location in the client where this
1687 depot file should live. Returns "" if the file should
1688 not be mapped in the client."""
1689
1690 paths_filled = []
1691 client_path = ""
1692
1693 # look at later entries first
1694 for m in self.mappings[::-1]:
1695
1696 # see where will this path end up in the client
1697 p = m.map_depot_to_client(depot_path)
1698
1699 if p == "":
1700 # Depot path does not belong in client. Must remember
1701 # this, as previous items should not cause files to
1702 # exist in this path either. Remember that the list is
1703 # being walked from the end, which has higher precedence.
1704 # Overlap mappings do not exclude previous mappings.
1705 if not m.overlay:
1706 paths_filled.append(m.client_side)
1707
1708 else:
1709 # This mapping matched; no need to search any further.
1710 # But, the mapping could be rejected if the client path
6ee9a999
PW
1711 # has already been claimed by an earlier mapping (i.e.
1712 # one later in the list, which we are walking backwards).
ecb7cf98
PW
1713 already_mapped_in_client = False
1714 for f in paths_filled:
1715 # this is View.Path.match
1716 if f.match(p):
1717 already_mapped_in_client = True
1718 break
1719 if not already_mapped_in_client:
1720 # Include this file, unless it is from a line that
1721 # explicitly said to exclude it.
1722 if not m.exclude:
1723 client_path = p
1724
1725 # a match, even if rejected, always stops the search
1726 break
1727
1728 return client_path
1729
3ea2cfd4 1730class P4Sync(Command, P4UserMap):
56c09345
PW
1731 delete_actions = ( "delete", "move/delete", "purge" )
1732
b984733c
SH
1733 def __init__(self):
1734 Command.__init__(self)
3ea2cfd4 1735 P4UserMap.__init__(self)
b984733c
SH
1736 self.options = [
1737 optparse.make_option("--branch", dest="branch"),
1738 optparse.make_option("--detect-branches", dest="detectBranches", action="store_true"),
1739 optparse.make_option("--changesfile", dest="changesFile"),
1740 optparse.make_option("--silent", dest="silent", action="store_true"),
ef48f909 1741 optparse.make_option("--detect-labels", dest="detectLabels", action="store_true"),
06804c76 1742 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),
d2c6dd30
HWN
1743 optparse.make_option("--import-local", dest="importIntoRemotes", action="store_false",
1744 help="Import into refs/heads/ , not refs/remotes"),
8b41a97f 1745 optparse.make_option("--max-changes", dest="maxChanges"),
86dff6b6 1746 optparse.make_option("--keep-path", dest="keepRepoPath", action='store_true',
3a70cdfa
TAL
1747 help="Keep entire BRANCH/DIR/SUBDIR prefix during import"),
1748 optparse.make_option("--use-client-spec", dest="useClientSpec", action='store_true',
1749 help="Only sync files that are included in the Perforce Client Spec")
b984733c
SH
1750 ]
1751 self.description = """Imports from Perforce into a git repository.\n
1752 example:
1753 //depot/my/project/ -- to import the current head
1754 //depot/my/project/@all -- to import everything
1755 //depot/my/project/@1,6 -- to import only from revision 1 to 6
1756
1757 (a ... is not needed in the path p4 specification, it's added implicitly)"""
1758
1759 self.usage += " //depot/path[@revRange]"
b984733c 1760 self.silent = False
1d7367dc
RG
1761 self.createdBranches = set()
1762 self.committedChanges = set()
569d1bd4 1763 self.branch = ""
b984733c 1764 self.detectBranches = False
cb53e1f8 1765 self.detectLabels = False
06804c76 1766 self.importLabels = False
b984733c 1767 self.changesFile = ""
01265103 1768 self.syncWithOrigin = True
a028a98e 1769 self.importIntoRemotes = True
01a9c9c5 1770 self.maxChanges = ""
c1f9197f 1771 self.isWindows = (platform.system() == "Windows")
8b41a97f 1772 self.keepRepoPath = False
6326aa58 1773 self.depotPaths = None
3c699645 1774 self.p4BranchesInGit = []
354081d5 1775 self.cloneExclude = []
3a70cdfa 1776 self.useClientSpec = False
a93d33ee 1777 self.useClientSpec_from_options = False
ecb7cf98 1778 self.clientSpecDirs = None
fed23693
VA
1779 self.tempBranches = []
1780 self.tempBranchLocation = "git-p4-tmp"
b984733c 1781
01265103
SH
1782 if gitConfig("git-p4.syncFromOrigin") == "false":
1783 self.syncWithOrigin = False
1784
fed23693
VA
1785 # Force a checkpoint in fast-import and wait for it to finish
1786 def checkpoint(self):
1787 self.gitStream.write("checkpoint\n\n")
1788 self.gitStream.write("progress checkpoint\n\n")
1789 out = self.gitOutput.readline()
1790 if self.verbose:
1791 print "checkpoint finished: " + out
1792
b984733c 1793 def extractFilesFromCommit(self, commit):
354081d5
TT
1794 self.cloneExclude = [re.sub(r"\.\.\.$", "", path)
1795 for path in self.cloneExclude]
b984733c
SH
1796 files = []
1797 fnum = 0
1798 while commit.has_key("depotFile%s" % fnum):
1799 path = commit["depotFile%s" % fnum]
6326aa58 1800
354081d5 1801 if [p for p in self.cloneExclude
d53de8b9 1802 if p4PathStartsWith(path, p)]:
354081d5
TT
1803 found = False
1804 else:
1805 found = [p for p in self.depotPaths
d53de8b9 1806 if p4PathStartsWith(path, p)]
6326aa58 1807 if not found:
b984733c
SH
1808 fnum = fnum + 1
1809 continue
1810
1811 file = {}
1812 file["path"] = path
1813 file["rev"] = commit["rev%s" % fnum]
1814 file["action"] = commit["action%s" % fnum]
1815 file["type"] = commit["type%s" % fnum]
1816 files.append(file)
1817 fnum = fnum + 1
1818 return files
1819
6326aa58 1820 def stripRepoPath(self, path, prefixes):
3952710b 1821 if self.useClientSpec:
0d1696ef 1822 path = self.clientSpecDirs.map_in_client(path)
3952710b 1823
0d1696ef
PW
1824 else:
1825 if self.keepRepoPath:
1826 prefixes = [re.sub("^(//[^/]+/).*", r'\1', prefixes[0])]
6326aa58 1827
0d1696ef
PW
1828 for p in prefixes:
1829 if p4PathStartsWith(path, p):
1830 path = path[len(p):]
8b41a97f 1831
0d1696ef 1832 path = wildcard_decode(path)
6326aa58 1833 return path
6754a299 1834
71b112d4 1835 def splitFilesIntoBranches(self, commit):
d5904674 1836 branches = {}
71b112d4
SH
1837 fnum = 0
1838 while commit.has_key("depotFile%s" % fnum):
1839 path = commit["depotFile%s" % fnum]
6326aa58 1840 found = [p for p in self.depotPaths
d53de8b9 1841 if p4PathStartsWith(path, p)]
6326aa58 1842 if not found:
71b112d4
SH
1843 fnum = fnum + 1
1844 continue
1845
1846 file = {}
1847 file["path"] = path
1848 file["rev"] = commit["rev%s" % fnum]
1849 file["action"] = commit["action%s" % fnum]
1850 file["type"] = commit["type%s" % fnum]
1851 fnum = fnum + 1
1852
6326aa58 1853 relPath = self.stripRepoPath(path, self.depotPaths)
b984733c 1854
4b97ffb1 1855 for branch in self.knownBranches.keys():
6754a299
HWN
1856
1857 # add a trailing slash so that a commit into qt/4.2foo doesn't end up in qt/4.2
1858 if relPath.startswith(branch + "/"):
d5904674
SH
1859 if branch not in branches:
1860 branches[branch] = []
71b112d4 1861 branches[branch].append(file)
6555b2cc 1862 break
b984733c
SH
1863
1864 return branches
1865
b932705b
LD
1866 # output one file from the P4 stream
1867 # - helper for streamP4Files
1868
1869 def streamOneP4File(self, file, contents):
b932705b
LD
1870 relPath = self.stripRepoPath(file['depotFile'], self.branchPrefixes)
1871 if verbose:
1872 sys.stderr.write("%s\n" % relPath)
1873
9cffb8c8
PW
1874 (type_base, type_mods) = split_p4_type(file["type"])
1875
1876 git_mode = "100644"
1877 if "x" in type_mods:
1878 git_mode = "100755"
1879 if type_base == "symlink":
1880 git_mode = "120000"
1881 # p4 print on a symlink contains "target\n"; remove the newline
b39c3612
EP
1882 data = ''.join(contents)
1883 contents = [data[:-1]]
b932705b 1884
9cffb8c8 1885 if type_base == "utf16":
55aa5714
PW
1886 # p4 delivers different text in the python output to -G
1887 # than it does when using "print -o", or normal p4 client
1888 # operations. utf16 is converted to ascii or utf8, perhaps.
1889 # But ascii text saved as -t utf16 is completely mangled.
1890 # Invoke print -o to get the real contents.
6de040df 1891 text = p4_read_pipe(['print', '-q', '-o', '-', file['depotFile']])
55aa5714
PW
1892 contents = [ text ]
1893
9f7ef0ea
PW
1894 if type_base == "apple":
1895 # Apple filetype files will be streamed as a concatenation of
1896 # its appledouble header and the contents. This is useless
1897 # on both macs and non-macs. If using "print -q -o xx", it
1898 # will create "xx" with the data, and "%xx" with the header.
1899 # This is also not very useful.
1900 #
1901 # Ideally, someday, this script can learn how to generate
1902 # appledouble files directly and import those to git, but
1903 # non-mac machines can never find a use for apple filetype.
1904 print "\nIgnoring apple filetype file %s" % file['depotFile']
1905 return
1906
9cffb8c8
PW
1907 # Perhaps windows wants unicode, utf16 newlines translated too;
1908 # but this is not doing it.
1909 if self.isWindows and type_base == "text":
b932705b
LD
1910 mangled = []
1911 for data in contents:
1912 data = data.replace("\r\n", "\n")
1913 mangled.append(data)
1914 contents = mangled
1915
55aa5714
PW
1916 # Note that we do not try to de-mangle keywords on utf16 files,
1917 # even though in theory somebody may want that.
60df071c
LD
1918 pattern = p4_keywords_regexp_for_type(type_base, type_mods)
1919 if pattern:
1920 regexp = re.compile(pattern, re.VERBOSE)
1921 text = ''.join(contents)
1922 text = regexp.sub(r'$\1$', text)
1923 contents = [ text ]
b932705b 1924
9cffb8c8 1925 self.gitStream.write("M %s inline %s\n" % (git_mode, relPath))
b932705b
LD
1926
1927 # total length...
1928 length = 0
1929 for d in contents:
1930 length = length + len(d)
1931
1932 self.gitStream.write("data %d\n" % length)
1933 for d in contents:
1934 self.gitStream.write(d)
1935 self.gitStream.write("\n")
1936
1937 def streamOneP4Deletion(self, file):
1938 relPath = self.stripRepoPath(file['path'], self.branchPrefixes)
1939 if verbose:
1940 sys.stderr.write("delete %s\n" % relPath)
1941 self.gitStream.write("D %s\n" % relPath)
1942
1943 # handle another chunk of streaming data
1944 def streamP4FilesCb(self, marshalled):
1945
c3f6163b
AG
1946 if marshalled.has_key('depotFile') and self.stream_have_file_info:
1947 # start of a new file - output the old one first
1948 self.streamOneP4File(self.stream_file, self.stream_contents)
1949 self.stream_file = {}
1950 self.stream_contents = []
1951 self.stream_have_file_info = False
b932705b 1952
c3f6163b
AG
1953 # pick up the new file information... for the
1954 # 'data' field we need to append to our array
1955 for k in marshalled.keys():
1956 if k == 'data':
1957 self.stream_contents.append(marshalled['data'])
1958 else:
1959 self.stream_file[k] = marshalled[k]
b932705b 1960
c3f6163b 1961 self.stream_have_file_info = True
b932705b
LD
1962
1963 # Stream directly from "p4 files" into "git fast-import"
1964 def streamP4Files(self, files):
30b5940b
SH
1965 filesForCommit = []
1966 filesToRead = []
b932705b 1967 filesToDelete = []
30b5940b 1968
3a70cdfa 1969 for f in files:
ecb7cf98
PW
1970 # if using a client spec, only add the files that have
1971 # a path in the client
1972 if self.clientSpecDirs:
1973 if self.clientSpecDirs.map_in_client(f['path']) == "":
1974 continue
3a70cdfa 1975
ecb7cf98
PW
1976 filesForCommit.append(f)
1977 if f['action'] in self.delete_actions:
1978 filesToDelete.append(f)
1979 else:
1980 filesToRead.append(f)
6a49f8e2 1981
b932705b
LD
1982 # deleted files...
1983 for f in filesToDelete:
1984 self.streamOneP4Deletion(f)
1b9a4684 1985
b932705b
LD
1986 if len(filesToRead) > 0:
1987 self.stream_file = {}
1988 self.stream_contents = []
1989 self.stream_have_file_info = False
8ff45f2a 1990
c3f6163b
AG
1991 # curry self argument
1992 def streamP4FilesCbSelf(entry):
1993 self.streamP4FilesCb(entry)
6a49f8e2 1994
6de040df
LD
1995 fileArgs = ['%s#%s' % (f['path'], f['rev']) for f in filesToRead]
1996
1997 p4CmdList(["-x", "-", "print"],
1998 stdin=fileArgs,
1999 cb=streamP4FilesCbSelf)
30b5940b 2000
b932705b
LD
2001 # do the last chunk
2002 if self.stream_file.has_key('depotFile'):
2003 self.streamOneP4File(self.stream_file, self.stream_contents)
6a49f8e2 2004
affb474f
LD
2005 def make_email(self, userid):
2006 if userid in self.users:
2007 return self.users[userid]
2008 else:
2009 return "%s <a@b>" % userid
2010
06804c76
LD
2011 # Stream a p4 tag
2012 def streamTag(self, gitStream, labelName, labelDetails, commit, epoch):
2013 if verbose:
2014 print "writing tag %s for commit %s" % (labelName, commit)
2015 gitStream.write("tag %s\n" % labelName)
2016 gitStream.write("from %s\n" % commit)
2017
2018 if labelDetails.has_key('Owner'):
2019 owner = labelDetails["Owner"]
2020 else:
2021 owner = None
2022
2023 # Try to use the owner of the p4 label, or failing that,
2024 # the current p4 user id.
2025 if owner:
2026 email = self.make_email(owner)
2027 else:
2028 email = self.make_email(self.p4UserId())
2029 tagger = "%s %s %s" % (email, epoch, self.tz)
2030
2031 gitStream.write("tagger %s\n" % tagger)
2032
2033 print "labelDetails=",labelDetails
2034 if labelDetails.has_key('Description'):
2035 description = labelDetails['Description']
2036 else:
2037 description = 'Label from git p4'
2038
2039 gitStream.write("data %d\n" % len(description))
2040 gitStream.write(description)
2041 gitStream.write("\n")
2042
e63231e5 2043 def commit(self, details, files, branch, parent = ""):
b984733c
SH
2044 epoch = details["time"]
2045 author = details["user"]
2046
4b97ffb1
SH
2047 if self.verbose:
2048 print "commit into %s" % branch
2049
96e07dd2
HWN
2050 # start with reading files; if that fails, we should not
2051 # create a commit.
2052 new_files = []
2053 for f in files:
e63231e5 2054 if [p for p in self.branchPrefixes if p4PathStartsWith(f['path'], p)]:
96e07dd2
HWN
2055 new_files.append (f)
2056 else:
afa1dd9a 2057 sys.stderr.write("Ignoring file outside of prefix: %s\n" % f['path'])
96e07dd2 2058
b984733c 2059 self.gitStream.write("commit %s\n" % branch)
6a49f8e2 2060# gitStream.write("mark :%s\n" % details["change"])
b984733c
SH
2061 self.committedChanges.add(int(details["change"]))
2062 committer = ""
b607e71e
SH
2063 if author not in self.users:
2064 self.getUserMapFromPerforceServer()
affb474f 2065 committer = "%s %s %s" % (self.make_email(author), epoch, self.tz)
b984733c
SH
2066
2067 self.gitStream.write("committer %s\n" % committer)
2068
2069 self.gitStream.write("data <<EOT\n")
2070 self.gitStream.write(details["desc"])
e63231e5
PW
2071 self.gitStream.write("\n[git-p4: depot-paths = \"%s\": change = %s" %
2072 (','.join(self.branchPrefixes), details["change"]))
6581de09
SH
2073 if len(details['options']) > 0:
2074 self.gitStream.write(": options = %s" % details['options'])
2075 self.gitStream.write("]\nEOT\n\n")
b984733c
SH
2076
2077 if len(parent) > 0:
4b97ffb1
SH
2078 if self.verbose:
2079 print "parent %s" % parent
b984733c
SH
2080 self.gitStream.write("from %s\n" % parent)
2081
b932705b 2082 self.streamP4Files(new_files)
b984733c
SH
2083 self.gitStream.write("\n")
2084
1f4ba1cb
SH
2085 change = int(details["change"])
2086
9bda3a85 2087 if self.labels.has_key(change):
1f4ba1cb
SH
2088 label = self.labels[change]
2089 labelDetails = label[0]
2090 labelRevisions = label[1]
71b112d4
SH
2091 if self.verbose:
2092 print "Change %s is labelled %s" % (change, labelDetails)
1f4ba1cb 2093
6de040df 2094 files = p4CmdList(["files"] + ["%s...@%s" % (p, change)
e63231e5 2095 for p in self.branchPrefixes])
1f4ba1cb
SH
2096
2097 if len(files) == len(labelRevisions):
2098
2099 cleanedFiles = {}
2100 for info in files:
56c09345 2101 if info["action"] in self.delete_actions:
1f4ba1cb
SH
2102 continue
2103 cleanedFiles[info["depotFile"]] = info["rev"]
2104
2105 if cleanedFiles == labelRevisions:
06804c76 2106 self.streamTag(self.gitStream, 'tag_%s' % labelDetails['label'], labelDetails, branch, epoch)
1f4ba1cb
SH
2107
2108 else:
a46668fa 2109 if not self.silent:
cebdf5af
HWN
2110 print ("Tag %s does not match with change %s: files do not match."
2111 % (labelDetails["label"], change))
1f4ba1cb
SH
2112
2113 else:
a46668fa 2114 if not self.silent:
cebdf5af
HWN
2115 print ("Tag %s does not match with change %s: file count is different."
2116 % (labelDetails["label"], change))
b984733c 2117
06804c76 2118 # Build a dictionary of changelists and labels, for "detect-labels" option.
1f4ba1cb
SH
2119 def getLabels(self):
2120 self.labels = {}
2121
52a4880b 2122 l = p4CmdList(["labels"] + ["%s..." % p for p in self.depotPaths])
10c3211b 2123 if len(l) > 0 and not self.silent:
183f8436 2124 print "Finding files belonging to labels in %s" % `self.depotPaths`
01ce1fe9
SH
2125
2126 for output in l:
1f4ba1cb
SH
2127 label = output["label"]
2128 revisions = {}
2129 newestChange = 0
71b112d4
SH
2130 if self.verbose:
2131 print "Querying files for label %s" % label
6de040df
LD
2132 for file in p4CmdList(["files"] +
2133 ["%s...@%s" % (p, label)
2134 for p in self.depotPaths]):
1f4ba1cb
SH
2135 revisions[file["depotFile"]] = file["rev"]
2136 change = int(file["change"])
2137 if change > newestChange:
2138 newestChange = change
2139
9bda3a85
SH
2140 self.labels[newestChange] = [output, revisions]
2141
2142 if self.verbose:
2143 print "Label changes: %s" % self.labels.keys()
1f4ba1cb 2144
06804c76
LD
2145 # Import p4 labels as git tags. A direct mapping does not
2146 # exist, so assume that if all the files are at the same revision
2147 # then we can use that, or it's something more complicated we should
2148 # just ignore.
2149 def importP4Labels(self, stream, p4Labels):
2150 if verbose:
2151 print "import p4 labels: " + ' '.join(p4Labels)
2152
2153 ignoredP4Labels = gitConfigList("git-p4.ignoredP4Labels")
c8942a22 2154 validLabelRegexp = gitConfig("git-p4.labelImportRegexp")
06804c76
LD
2155 if len(validLabelRegexp) == 0:
2156 validLabelRegexp = defaultLabelRegexp
2157 m = re.compile(validLabelRegexp)
2158
2159 for name in p4Labels:
2160 commitFound = False
2161
2162 if not m.match(name):
2163 if verbose:
2164 print "label %s does not match regexp %s" % (name,validLabelRegexp)
2165 continue
2166
2167 if name in ignoredP4Labels:
2168 continue
2169
2170 labelDetails = p4CmdList(['label', "-o", name])[0]
2171
2172 # get the most recent changelist for each file in this label
2173 change = p4Cmd(["changes", "-m", "1"] + ["%s...@%s" % (p, name)
2174 for p in self.depotPaths])
2175
2176 if change.has_key('change'):
2177 # find the corresponding git commit; take the oldest commit
2178 changelist = int(change['change'])
2179 gitCommit = read_pipe(["git", "rev-list", "--max-count=1",
2180 "--reverse", ":/\[git-p4:.*change = %d\]" % changelist])
2181 if len(gitCommit) == 0:
2182 print "could not find git commit for changelist %d" % changelist
2183 else:
2184 gitCommit = gitCommit.strip()
2185 commitFound = True
2186 # Convert from p4 time format
2187 try:
2188 tmwhen = time.strptime(labelDetails['Update'], "%Y/%m/%d %H:%M:%S")
2189 except ValueError:
2190 print "Could not convert label time %s" % labelDetail['Update']
2191 tmwhen = 1
2192
2193 when = int(time.mktime(tmwhen))
2194 self.streamTag(stream, name, labelDetails, gitCommit, when)
2195 if verbose:
2196 print "p4 label %s mapped to git commit %s" % (name, gitCommit)
2197 else:
2198 if verbose:
2199 print "Label %s has no changelists - possibly deleted?" % name
2200
2201 if not commitFound:
2202 # We can't import this label; don't try again as it will get very
2203 # expensive repeatedly fetching all the files for labels that will
2204 # never be imported. If the label is moved in the future, the
2205 # ignore will need to be removed manually.
2206 system(["git", "config", "--add", "git-p4.ignoredP4Labels", name])
2207
86dff6b6
HWN
2208 def guessProjectName(self):
2209 for p in self.depotPaths:
6e5295c4
SH
2210 if p.endswith("/"):
2211 p = p[:-1]
2212 p = p[p.strip().rfind("/") + 1:]
2213 if not p.endswith("/"):
2214 p += "/"
2215 return p
86dff6b6 2216
4b97ffb1 2217 def getBranchMapping(self):
6555b2cc
SH
2218 lostAndFoundBranches = set()
2219
8ace74c0
VA
2220 user = gitConfig("git-p4.branchUser")
2221 if len(user) > 0:
2222 command = "branches -u %s" % user
2223 else:
2224 command = "branches"
2225
2226 for info in p4CmdList(command):
52a4880b 2227 details = p4Cmd(["branch", "-o", info["branch"]])
4b97ffb1
SH
2228 viewIdx = 0
2229 while details.has_key("View%s" % viewIdx):
2230 paths = details["View%s" % viewIdx].split(" ")
2231 viewIdx = viewIdx + 1
2232 # require standard //depot/foo/... //depot/bar/... mapping
2233 if len(paths) != 2 or not paths[0].endswith("/...") or not paths[1].endswith("/..."):
2234 continue
2235 source = paths[0]
2236 destination = paths[1]
6509e19c 2237 ## HACK
d53de8b9 2238 if p4PathStartsWith(source, self.depotPaths[0]) and p4PathStartsWith(destination, self.depotPaths[0]):
6509e19c
SH
2239 source = source[len(self.depotPaths[0]):-4]
2240 destination = destination[len(self.depotPaths[0]):-4]
6555b2cc 2241
1a2edf4e
SH
2242 if destination in self.knownBranches:
2243 if not self.silent:
2244 print "p4 branch %s defines a mapping from %s to %s" % (info["branch"], source, destination)
2245 print "but there exists another mapping from %s to %s already!" % (self.knownBranches[destination], destination)
2246 continue
2247
6555b2cc
SH
2248 self.knownBranches[destination] = source
2249
2250 lostAndFoundBranches.discard(destination)
2251
29bdbac1 2252 if source not in self.knownBranches:
6555b2cc
SH
2253 lostAndFoundBranches.add(source)
2254
7199cf13
VA
2255 # Perforce does not strictly require branches to be defined, so we also
2256 # check git config for a branch list.
2257 #
2258 # Example of branch definition in git config file:
2259 # [git-p4]
2260 # branchList=main:branchA
2261 # branchList=main:branchB
2262 # branchList=branchA:branchC
2263 configBranches = gitConfigList("git-p4.branchList")
2264 for branch in configBranches:
2265 if branch:
2266 (source, destination) = branch.split(":")
2267 self.knownBranches[destination] = source
2268
2269 lostAndFoundBranches.discard(destination)
2270
2271 if source not in self.knownBranches:
2272 lostAndFoundBranches.add(source)
2273
6555b2cc
SH
2274
2275 for branch in lostAndFoundBranches:
2276 self.knownBranches[branch] = branch
29bdbac1 2277
38f9f5ec
SH
2278 def getBranchMappingFromGitBranches(self):
2279 branches = p4BranchesInGit(self.importIntoRemotes)
2280 for branch in branches.keys():
2281 if branch == "master":
2282 branch = "main"
2283 else:
2284 branch = branch[len(self.projectName):]
2285 self.knownBranches[branch] = branch
2286
29bdbac1 2287 def listExistingP4GitBranches(self):
144ff46b
SH
2288 # branches holds mapping from name to commit
2289 branches = p4BranchesInGit(self.importIntoRemotes)
2290 self.p4BranchesInGit = branches.keys()
2291 for branch in branches.keys():
2292 self.initialParents[self.refPrefix + branch] = branches[branch]
4b97ffb1 2293
bb6e09b2
HWN
2294 def updateOptionDict(self, d):
2295 option_keys = {}
2296 if self.keepRepoPath:
2297 option_keys['keepRepoPath'] = 1
2298
2299 d["options"] = ' '.join(sorted(option_keys.keys()))
2300
2301 def readOptions(self, d):
2302 self.keepRepoPath = (d.has_key('options')
2303 and ('keepRepoPath' in d['options']))
6326aa58 2304
8134f69c
SH
2305 def gitRefForBranch(self, branch):
2306 if branch == "main":
2307 return self.refPrefix + "master"
2308
2309 if len(branch) <= 0:
2310 return branch
2311
2312 return self.refPrefix + self.projectName + branch
2313
1ca3d710
SH
2314 def gitCommitByP4Change(self, ref, change):
2315 if self.verbose:
2316 print "looking in ref " + ref + " for change %s using bisect..." % change
2317
2318 earliestCommit = ""
2319 latestCommit = parseRevision(ref)
2320
2321 while True:
2322 if self.verbose:
2323 print "trying: earliest %s latest %s" % (earliestCommit, latestCommit)
2324 next = read_pipe("git rev-list --bisect %s %s" % (latestCommit, earliestCommit)).strip()
2325 if len(next) == 0:
2326 if self.verbose:
2327 print "argh"
2328 return ""
2329 log = extractLogMessageFromGitCommit(next)
2330 settings = extractSettingsGitLog(log)
2331 currentChange = int(settings['change'])
2332 if self.verbose:
2333 print "current change %s" % currentChange
2334
2335 if currentChange == change:
2336 if self.verbose:
2337 print "found %s" % next
2338 return next
2339
2340 if currentChange < change:
2341 earliestCommit = "^%s" % next
2342 else:
2343 latestCommit = "%s" % next
2344
2345 return ""
2346
2347 def importNewBranch(self, branch, maxChange):
2348 # make fast-import flush all changes to disk and update the refs using the checkpoint
2349 # command so that we can try to find the branch parent in the git history
2350 self.gitStream.write("checkpoint\n\n");
2351 self.gitStream.flush();
2352 branchPrefix = self.depotPaths[0] + branch + "/"
2353 range = "@1,%s" % maxChange
2354 #print "prefix" + branchPrefix
2355 changes = p4ChangesForPaths([branchPrefix], range)
2356 if len(changes) <= 0:
2357 return False
2358 firstChange = changes[0]
2359 #print "first change in branch: %s" % firstChange
2360 sourceBranch = self.knownBranches[branch]
2361 sourceDepotPath = self.depotPaths[0] + sourceBranch
2362 sourceRef = self.gitRefForBranch(sourceBranch)
2363 #print "source " + sourceBranch
2364
52a4880b 2365 branchParentChange = int(p4Cmd(["changes", "-m", "1", "%s...@1,%s" % (sourceDepotPath, firstChange)])["change"])
1ca3d710
SH
2366 #print "branch parent: %s" % branchParentChange
2367 gitParent = self.gitCommitByP4Change(sourceRef, branchParentChange)
2368 if len(gitParent) > 0:
2369 self.initialParents[self.gitRefForBranch(branch)] = gitParent
2370 #print "parent git commit: %s" % gitParent
2371
2372 self.importChanges(changes)
2373 return True
2374
fed23693
VA
2375 def searchParent(self, parent, branch, target):
2376 parentFound = False
2377 for blob in read_pipe_lines(["git", "rev-list", "--reverse", "--no-merges", parent]):
2378 blob = blob.strip()
2379 if len(read_pipe(["git", "diff-tree", blob, target])) == 0:
2380 parentFound = True
2381 if self.verbose:
2382 print "Found parent of %s in commit %s" % (branch, blob)
2383 break
2384 if parentFound:
2385 return blob
2386 else:
2387 return None
2388
e87f37ae
SH
2389 def importChanges(self, changes):
2390 cnt = 1
2391 for change in changes:
3558f32f 2392 description = p4Cmd(["describe", str(change)])
e87f37ae
SH
2393 self.updateOptionDict(description)
2394
2395 if not self.silent:
2396 sys.stdout.write("\rImporting revision %s (%s%%)" % (change, cnt * 100 / len(changes)))
2397 sys.stdout.flush()
2398 cnt = cnt + 1
2399
2400 try:
2401 if self.detectBranches:
2402 branches = self.splitFilesIntoBranches(description)
2403 for branch in branches.keys():
2404 ## HACK --hwn
2405 branchPrefix = self.depotPaths[0] + branch + "/"
e63231e5 2406 self.branchPrefixes = [ branchPrefix ]
e87f37ae
SH
2407
2408 parent = ""
2409
2410 filesForCommit = branches[branch]
2411
2412 if self.verbose:
2413 print "branch is %s" % branch
2414
2415 self.updatedBranches.add(branch)
2416
2417 if branch not in self.createdBranches:
2418 self.createdBranches.add(branch)
2419 parent = self.knownBranches[branch]
2420 if parent == branch:
2421 parent = ""
1ca3d710
SH
2422 else:
2423 fullBranch = self.projectName + branch
2424 if fullBranch not in self.p4BranchesInGit:
2425 if not self.silent:
2426 print("\n Importing new branch %s" % fullBranch);
2427 if self.importNewBranch(branch, change - 1):
2428 parent = ""
2429 self.p4BranchesInGit.append(fullBranch)
2430 if not self.silent:
2431 print("\n Resuming with change %s" % change);
2432
2433 if self.verbose:
2434 print "parent determined through known branches: %s" % parent
e87f37ae 2435
8134f69c
SH
2436 branch = self.gitRefForBranch(branch)
2437 parent = self.gitRefForBranch(parent)
e87f37ae
SH
2438
2439 if self.verbose:
2440 print "looking for initial parent for %s; current parent is %s" % (branch, parent)
2441
2442 if len(parent) == 0 and branch in self.initialParents:
2443 parent = self.initialParents[branch]
2444 del self.initialParents[branch]
2445
fed23693
VA
2446 blob = None
2447 if len(parent) > 0:
2448 tempBranch = os.path.join(self.tempBranchLocation, "%d" % (change))
2449 if self.verbose:
2450 print "Creating temporary branch: " + tempBranch
e63231e5 2451 self.commit(description, filesForCommit, tempBranch)
fed23693
VA
2452 self.tempBranches.append(tempBranch)
2453 self.checkpoint()
2454 blob = self.searchParent(parent, branch, tempBranch)
2455 if blob:
e63231e5 2456 self.commit(description, filesForCommit, branch, blob)
fed23693
VA
2457 else:
2458 if self.verbose:
2459 print "Parent of %s not found. Committing into head of %s" % (branch, parent)
e63231e5 2460 self.commit(description, filesForCommit, branch, parent)
e87f37ae
SH
2461 else:
2462 files = self.extractFilesFromCommit(description)
e63231e5 2463 self.commit(description, files, self.branch,
e87f37ae
SH
2464 self.initialParent)
2465 self.initialParent = ""
2466 except IOError:
2467 print self.gitError.read()
2468 sys.exit(1)
2469
c208a243
SH
2470 def importHeadRevision(self, revision):
2471 print "Doing initial import of %s from revision %s into %s" % (' '.join(self.depotPaths), revision, self.branch)
2472
4e2e6ce4
PW
2473 details = {}
2474 details["user"] = "git perforce import user"
1494fcbb 2475 details["desc"] = ("Initial import of %s from the state at revision %s\n"
c208a243
SH
2476 % (' '.join(self.depotPaths), revision))
2477 details["change"] = revision
2478 newestRevision = 0
2479
2480 fileCnt = 0
6de040df
LD
2481 fileArgs = ["%s...%s" % (p,revision) for p in self.depotPaths]
2482
2483 for info in p4CmdList(["files"] + fileArgs):
c208a243 2484
68b28593 2485 if 'code' in info and info['code'] == 'error':
c208a243
SH
2486 sys.stderr.write("p4 returned an error: %s\n"
2487 % info['data'])
d88e707f
PW
2488 if info['data'].find("must refer to client") >= 0:
2489 sys.stderr.write("This particular p4 error is misleading.\n")
2490 sys.stderr.write("Perhaps the depot path was misspelled.\n");
2491 sys.stderr.write("Depot path: %s\n" % " ".join(self.depotPaths))
c208a243 2492 sys.exit(1)
68b28593
PW
2493 if 'p4ExitCode' in info:
2494 sys.stderr.write("p4 exitcode: %s\n" % info['p4ExitCode'])
c208a243
SH
2495 sys.exit(1)
2496
2497
2498 change = int(info["change"])
2499 if change > newestRevision:
2500 newestRevision = change
2501
56c09345 2502 if info["action"] in self.delete_actions:
c208a243
SH
2503 # don't increase the file cnt, otherwise details["depotFile123"] will have gaps!
2504 #fileCnt = fileCnt + 1
2505 continue
2506
2507 for prop in ["depotFile", "rev", "action", "type" ]:
2508 details["%s%s" % (prop, fileCnt)] = info[prop]
2509
2510 fileCnt = fileCnt + 1
2511
2512 details["change"] = newestRevision
4e2e6ce4 2513
9dcb9f24 2514 # Use time from top-most change so that all git p4 clones of
4e2e6ce4
PW
2515 # the same p4 repo have the same commit SHA1s.
2516 res = p4CmdList("describe -s %d" % newestRevision)
2517 newestTime = None
2518 for r in res:
2519 if r.has_key('time'):
2520 newestTime = int(r['time'])
2521 if newestTime is None:
2522 die("\"describe -s\" on newest change %d did not give a time")
2523 details["time"] = newestTime
2524
c208a243
SH
2525 self.updateOptionDict(details)
2526 try:
e63231e5 2527 self.commit(details, self.extractFilesFromCommit(details), self.branch)
c208a243
SH
2528 except IOError:
2529 print "IO error with git fast-import. Is your git version recent enough?"
2530 print self.gitError.read()
2531
2532
b984733c 2533 def run(self, args):
6326aa58 2534 self.depotPaths = []
179caebf
SH
2535 self.changeRange = ""
2536 self.initialParent = ""
6326aa58 2537 self.previousDepotPaths = []
ce6f33c8 2538
29bdbac1
SH
2539 # map from branch depot path to parent branch
2540 self.knownBranches = {}
2541 self.initialParents = {}
5ca44617 2542 self.hasOrigin = originP4BranchesExist()
a43ff00c
SH
2543 if not self.syncWithOrigin:
2544 self.hasOrigin = False
29bdbac1 2545
a028a98e
SH
2546 if self.importIntoRemotes:
2547 self.refPrefix = "refs/remotes/p4/"
2548 else:
db775559 2549 self.refPrefix = "refs/heads/p4/"
a028a98e 2550
cebdf5af
HWN
2551 if self.syncWithOrigin and self.hasOrigin:
2552 if not self.silent:
2553 print "Syncing with origin first by calling git fetch origin"
2554 system("git fetch origin")
10f880f8 2555
569d1bd4 2556 if len(self.branch) == 0:
db775559 2557 self.branch = self.refPrefix + "master"
a028a98e 2558 if gitBranchExists("refs/heads/p4") and self.importIntoRemotes:
48df6fd8 2559 system("git update-ref %s refs/heads/p4" % self.branch)
48df6fd8 2560 system("git branch -D p4");
faf1bd20 2561 # create it /after/ importing, when master exists
0058a33a 2562 if not gitBranchExists(self.refPrefix + "HEAD") and self.importIntoRemotes and gitBranchExists(self.branch):
a3c55c09 2563 system("git symbolic-ref %sHEAD %s" % (self.refPrefix, self.branch))
967f72e2 2564
a93d33ee
PW
2565 # accept either the command-line option, or the configuration variable
2566 if self.useClientSpec:
2567 # will use this after clone to set the variable
2568 self.useClientSpec_from_options = True
2569 else:
09fca77b
PW
2570 if gitConfig("git-p4.useclientspec", "--bool") == "true":
2571 self.useClientSpec = True
2572 if self.useClientSpec:
543987bd 2573 self.clientSpecDirs = getClientSpec()
3a70cdfa 2574
6a49f8e2
HWN
2575 # TODO: should always look at previous commits,
2576 # merge with previous imports, if possible.
2577 if args == []:
d414c74a 2578 if self.hasOrigin:
5ca44617 2579 createOrUpdateBranchesFromOrigin(self.refPrefix, self.silent)
abcd790f
SH
2580 self.listExistingP4GitBranches()
2581
2582 if len(self.p4BranchesInGit) > 1:
2583 if not self.silent:
2584 print "Importing from/into multiple branches"
2585 self.detectBranches = True
967f72e2 2586
29bdbac1
SH
2587 if self.verbose:
2588 print "branches: %s" % self.p4BranchesInGit
2589
2590 p4Change = 0
2591 for branch in self.p4BranchesInGit:
cebdf5af 2592 logMsg = extractLogMessageFromGitCommit(self.refPrefix + branch)
bb6e09b2
HWN
2593
2594 settings = extractSettingsGitLog(logMsg)
29bdbac1 2595
bb6e09b2
HWN
2596 self.readOptions(settings)
2597 if (settings.has_key('depot-paths')
2598 and settings.has_key ('change')):
2599 change = int(settings['change']) + 1
29bdbac1
SH
2600 p4Change = max(p4Change, change)
2601
bb6e09b2
HWN
2602 depotPaths = sorted(settings['depot-paths'])
2603 if self.previousDepotPaths == []:
6326aa58 2604 self.previousDepotPaths = depotPaths
29bdbac1 2605 else:
6326aa58
HWN
2606 paths = []
2607 for (prev, cur) in zip(self.previousDepotPaths, depotPaths):
04d277b3
VA
2608 prev_list = prev.split("/")
2609 cur_list = cur.split("/")
2610 for i in range(0, min(len(cur_list), len(prev_list))):
2611 if cur_list[i] <> prev_list[i]:
583e1707 2612 i = i - 1
6326aa58
HWN
2613 break
2614
04d277b3 2615 paths.append ("/".join(cur_list[:i + 1]))
6326aa58
HWN
2616
2617 self.previousDepotPaths = paths
29bdbac1
SH
2618
2619 if p4Change > 0:
bb6e09b2 2620 self.depotPaths = sorted(self.previousDepotPaths)
d5904674 2621 self.changeRange = "@%s,#head" % p4Change
330f53b8
SH
2622 if not self.detectBranches:
2623 self.initialParent = parseRevision(self.branch)
341dc1c1 2624 if not self.silent and not self.detectBranches:
967f72e2 2625 print "Performing incremental import into %s git branch" % self.branch
569d1bd4 2626
f9162f6a
SH
2627 if not self.branch.startswith("refs/"):
2628 self.branch = "refs/heads/" + self.branch
179caebf 2629
6326aa58 2630 if len(args) == 0 and self.depotPaths:
b984733c 2631 if not self.silent:
6326aa58 2632 print "Depot paths: %s" % ' '.join(self.depotPaths)
b984733c 2633 else:
6326aa58 2634 if self.depotPaths and self.depotPaths != args:
cebdf5af 2635 print ("previous import used depot path %s and now %s was specified. "
6326aa58
HWN
2636 "This doesn't work!" % (' '.join (self.depotPaths),
2637 ' '.join (args)))
b984733c 2638 sys.exit(1)
6326aa58 2639
bb6e09b2 2640 self.depotPaths = sorted(args)
b984733c 2641
1c49fc19 2642 revision = ""
b984733c 2643 self.users = {}
b984733c 2644
58c8bc7c
PW
2645 # Make sure no revision specifiers are used when --changesfile
2646 # is specified.
2647 bad_changesfile = False
2648 if len(self.changesFile) > 0:
2649 for p in self.depotPaths:
2650 if p.find("@") >= 0 or p.find("#") >= 0:
2651 bad_changesfile = True
2652 break
2653 if bad_changesfile:
2654 die("Option --changesfile is incompatible with revision specifiers")
2655
6326aa58
HWN
2656 newPaths = []
2657 for p in self.depotPaths:
2658 if p.find("@") != -1:
2659 atIdx = p.index("@")
2660 self.changeRange = p[atIdx:]
2661 if self.changeRange == "@all":
2662 self.changeRange = ""
6a49f8e2 2663 elif ',' not in self.changeRange:
1c49fc19 2664 revision = self.changeRange
6326aa58 2665 self.changeRange = ""
7fcff9de 2666 p = p[:atIdx]
6326aa58
HWN
2667 elif p.find("#") != -1:
2668 hashIdx = p.index("#")
1c49fc19 2669 revision = p[hashIdx:]
7fcff9de 2670 p = p[:hashIdx]
6326aa58 2671 elif self.previousDepotPaths == []:
58c8bc7c
PW
2672 # pay attention to changesfile, if given, else import
2673 # the entire p4 tree at the head revision
2674 if len(self.changesFile) == 0:
2675 revision = "#head"
6326aa58
HWN
2676
2677 p = re.sub ("\.\.\.$", "", p)
2678 if not p.endswith("/"):
2679 p += "/"
2680
2681 newPaths.append(p)
2682
2683 self.depotPaths = newPaths
2684
e63231e5
PW
2685 # --detect-branches may change this for each branch
2686 self.branchPrefixes = self.depotPaths
2687
b607e71e 2688 self.loadUserMapFromCache()
cb53e1f8
SH
2689 self.labels = {}
2690 if self.detectLabels:
2691 self.getLabels();
b984733c 2692
4b97ffb1 2693 if self.detectBranches:
df450923
SH
2694 ## FIXME - what's a P4 projectName ?
2695 self.projectName = self.guessProjectName()
2696
38f9f5ec
SH
2697 if self.hasOrigin:
2698 self.getBranchMappingFromGitBranches()
2699 else:
2700 self.getBranchMapping()
29bdbac1
SH
2701 if self.verbose:
2702 print "p4-git branches: %s" % self.p4BranchesInGit
2703 print "initial parents: %s" % self.initialParents
2704 for b in self.p4BranchesInGit:
2705 if b != "master":
6326aa58
HWN
2706
2707 ## FIXME
29bdbac1
SH
2708 b = b[len(self.projectName):]
2709 self.createdBranches.add(b)
4b97ffb1 2710
f291b4e3 2711 self.tz = "%+03d%02d" % (- time.timezone / 3600, ((- time.timezone % 3600) / 60))
b984733c 2712
cebdf5af 2713 importProcess = subprocess.Popen(["git", "fast-import"],
6326aa58
HWN
2714 stdin=subprocess.PIPE, stdout=subprocess.PIPE,
2715 stderr=subprocess.PIPE);
08483580
SH
2716 self.gitOutput = importProcess.stdout
2717 self.gitStream = importProcess.stdin
2718 self.gitError = importProcess.stderr
b984733c 2719
1c49fc19 2720 if revision:
c208a243 2721 self.importHeadRevision(revision)
b984733c
SH
2722 else:
2723 changes = []
2724
0828ab14 2725 if len(self.changesFile) > 0:
b984733c 2726 output = open(self.changesFile).readlines()
1d7367dc 2727 changeSet = set()
b984733c
SH
2728 for line in output:
2729 changeSet.add(int(line))
2730
2731 for change in changeSet:
2732 changes.append(change)
2733
2734 changes.sort()
2735 else:
9dcb9f24
PW
2736 # catch "git p4 sync" with no new branches, in a repo that
2737 # does not have any existing p4 branches
accad8e0 2738 if len(args) == 0 and not self.p4BranchesInGit:
e32e00dc 2739 die("No remote p4 branches. Perhaps you never did \"git p4 clone\" in here.");
29bdbac1 2740 if self.verbose:
86dff6b6 2741 print "Getting p4 changes for %s...%s" % (', '.join(self.depotPaths),
6326aa58 2742 self.changeRange)
4f6432d8 2743 changes = p4ChangesForPaths(self.depotPaths, self.changeRange)
b984733c 2744
01a9c9c5 2745 if len(self.maxChanges) > 0:
7fcff9de 2746 changes = changes[:min(int(self.maxChanges), len(changes))]
01a9c9c5 2747
b984733c 2748 if len(changes) == 0:
0828ab14 2749 if not self.silent:
341dc1c1 2750 print "No changes to import!"
06804c76
LD
2751 else:
2752 if not self.silent and not self.detectBranches:
2753 print "Import destination: %s" % self.branch
2754
2755 self.updatedBranches = set()
b984733c 2756
06804c76 2757 self.importChanges(changes)
a9d1a27a 2758
06804c76
LD
2759 if not self.silent:
2760 print ""
2761 if len(self.updatedBranches) > 0:
2762 sys.stdout.write("Updated branches: ")
2763 for b in self.updatedBranches:
2764 sys.stdout.write("%s " % b)
2765 sys.stdout.write("\n")
341dc1c1 2766
06804c76 2767 if gitConfig("git-p4.importLabels", "--bool") == "true":
06dcd152 2768 self.importLabels = True
b984733c 2769
06804c76
LD
2770 if self.importLabels:
2771 p4Labels = getP4Labels(self.depotPaths)
2772 gitTags = getGitTags()
2773
2774 missingP4Labels = p4Labels - gitTags
2775 self.importP4Labels(self.gitStream, missingP4Labels)
b984733c 2776
b984733c 2777 self.gitStream.close()
29bdbac1
SH
2778 if importProcess.wait() != 0:
2779 die("fast-import failed: %s" % self.gitError.read())
b984733c
SH
2780 self.gitOutput.close()
2781 self.gitError.close()
2782
fed23693
VA
2783 # Cleanup temporary branches created during import
2784 if self.tempBranches != []:
2785 for branch in self.tempBranches:
2786 read_pipe("git update-ref -d %s" % branch)
2787 os.rmdir(os.path.join(os.environ.get("GIT_DIR", ".git"), self.tempBranchLocation))
2788
b984733c
SH
2789 return True
2790
01ce1fe9
SH
2791class P4Rebase(Command):
2792 def __init__(self):
2793 Command.__init__(self)
06804c76
LD
2794 self.options = [
2795 optparse.make_option("--import-labels", dest="importLabels", action="store_true"),
06804c76 2796 ]
06804c76 2797 self.importLabels = False
cebdf5af
HWN
2798 self.description = ("Fetches the latest revision from perforce and "
2799 + "rebases the current work (branch) against it")
01ce1fe9
SH
2800
2801 def run(self, args):
2802 sync = P4Sync()
06804c76 2803 sync.importLabels = self.importLabels
01ce1fe9 2804 sync.run([])
d7e3868c 2805
14594f4b
SH
2806 return self.rebase()
2807
2808 def rebase(self):
36ee4ee4
SH
2809 if os.system("git update-index --refresh") != 0:
2810 die("Some files in your working directory are modified and different than what is in your index. You can use git update-index <filename> to bring the index up-to-date or stash away all your changes with git stash.");
2811 if len(read_pipe("git diff-index HEAD --")) > 0:
2812 die("You have uncommited changes. Please commit them before rebasing or stash them away with git stash.");
2813
d7e3868c
SH
2814 [upstream, settings] = findUpstreamBranchPoint()
2815 if len(upstream) == 0:
2816 die("Cannot find upstream branchpoint for rebase")
2817
2818 # the branchpoint may be p4/foo~3, so strip off the parent
2819 upstream = re.sub("~[0-9]+$", "", upstream)
2820
2821 print "Rebasing the current branch onto %s" % upstream
b25b2065 2822 oldHead = read_pipe("git rev-parse HEAD").strip()
d7e3868c 2823 system("git rebase %s" % upstream)
1f52af6c 2824 system("git diff-tree --stat --summary -M %s HEAD" % oldHead)
01ce1fe9
SH
2825 return True
2826
f9a3a4f7
SH
2827class P4Clone(P4Sync):
2828 def __init__(self):
2829 P4Sync.__init__(self)
2830 self.description = "Creates a new git repository and imports from Perforce into it"
bb6e09b2 2831 self.usage = "usage: %prog [options] //depot/path[@revRange]"
354081d5 2832 self.options += [
bb6e09b2
HWN
2833 optparse.make_option("--destination", dest="cloneDestination",
2834 action='store', default=None,
354081d5
TT
2835 help="where to leave result of the clone"),
2836 optparse.make_option("-/", dest="cloneExclude",
2837 action="append", type="string",
38200076
PW
2838 help="exclude depot path"),
2839 optparse.make_option("--bare", dest="cloneBare",
2840 action="store_true", default=False),
354081d5 2841 ]
bb6e09b2 2842 self.cloneDestination = None
f9a3a4f7 2843 self.needsGit = False
38200076 2844 self.cloneBare = False
f9a3a4f7 2845
354081d5
TT
2846 # This is required for the "append" cloneExclude action
2847 def ensure_value(self, attr, value):
2848 if not hasattr(self, attr) or getattr(self, attr) is None:
2849 setattr(self, attr, value)
2850 return getattr(self, attr)
2851
6a49f8e2
HWN
2852 def defaultDestination(self, args):
2853 ## TODO: use common prefix of args?
2854 depotPath = args[0]
2855 depotDir = re.sub("(@[^@]*)$", "", depotPath)
2856 depotDir = re.sub("(#[^#]*)$", "", depotDir)
053d9e43 2857 depotDir = re.sub(r"\.\.\.$", "", depotDir)
6a49f8e2
HWN
2858 depotDir = re.sub(r"/$", "", depotDir)
2859 return os.path.split(depotDir)[1]
2860
f9a3a4f7
SH
2861 def run(self, args):
2862 if len(args) < 1:
2863 return False
bb6e09b2
HWN
2864
2865 if self.keepRepoPath and not self.cloneDestination:
2866 sys.stderr.write("Must specify destination for --keep-path\n")
2867 sys.exit(1)
f9a3a4f7 2868
6326aa58 2869 depotPaths = args
5e100b5c
SH
2870
2871 if not self.cloneDestination and len(depotPaths) > 1:
2872 self.cloneDestination = depotPaths[-1]
2873 depotPaths = depotPaths[:-1]
2874
354081d5 2875 self.cloneExclude = ["/"+p for p in self.cloneExclude]
6326aa58
HWN
2876 for p in depotPaths:
2877 if not p.startswith("//"):
2878 return False
f9a3a4f7 2879
bb6e09b2 2880 if not self.cloneDestination:
98ad4faf 2881 self.cloneDestination = self.defaultDestination(args)
f9a3a4f7 2882
86dff6b6 2883 print "Importing from %s into %s" % (', '.join(depotPaths), self.cloneDestination)
38200076 2884
c3bf3f13
KG
2885 if not os.path.exists(self.cloneDestination):
2886 os.makedirs(self.cloneDestination)
053fd0c1 2887 chdir(self.cloneDestination)
38200076
PW
2888
2889 init_cmd = [ "git", "init" ]
2890 if self.cloneBare:
2891 init_cmd.append("--bare")
2892 subprocess.check_call(init_cmd)
2893
6326aa58 2894 if not P4Sync.run(self, depotPaths):
f9a3a4f7 2895 return False
f9a3a4f7 2896 if self.branch != "master":
e9905013
TAL
2897 if self.importIntoRemotes:
2898 masterbranch = "refs/remotes/p4/master"
2899 else:
2900 masterbranch = "refs/heads/p4/master"
2901 if gitBranchExists(masterbranch):
2902 system("git branch master %s" % masterbranch)
38200076
PW
2903 if not self.cloneBare:
2904 system("git checkout -f")
8f9b2e08
SH
2905 else:
2906 print "Could not detect main branch. No checkout/master branch created."
86dff6b6 2907
a93d33ee
PW
2908 # auto-set this variable if invoked with --use-client-spec
2909 if self.useClientSpec_from_options:
2910 system("git config --bool git-p4.useclientspec true")
2911
f9a3a4f7
SH
2912 return True
2913
09d89de2
SH
2914class P4Branches(Command):
2915 def __init__(self):
2916 Command.__init__(self)
2917 self.options = [ ]
2918 self.description = ("Shows the git branches that hold imports and their "
2919 + "corresponding perforce depot paths")
2920 self.verbose = False
2921
2922 def run(self, args):
5ca44617
SH
2923 if originP4BranchesExist():
2924 createOrUpdateBranchesFromOrigin()
2925
09d89de2
SH
2926 cmdline = "git rev-parse --symbolic "
2927 cmdline += " --remotes"
2928
2929 for line in read_pipe_lines(cmdline):
2930 line = line.strip()
2931
2932 if not line.startswith('p4/') or line == "p4/HEAD":
2933 continue
2934 branch = line
2935
2936 log = extractLogMessageFromGitCommit("refs/remotes/%s" % branch)
2937 settings = extractSettingsGitLog(log)
2938
2939 print "%s <= %s (%s)" % (branch, ",".join(settings["depot-paths"]), settings["change"])
2940 return True
2941
b984733c
SH
2942class HelpFormatter(optparse.IndentedHelpFormatter):
2943 def __init__(self):
2944 optparse.IndentedHelpFormatter.__init__(self)
2945
2946 def format_description(self, description):
2947 if description:
2948 return description + "\n"
2949 else:
2950 return ""
4f5cf76a 2951
86949eef
SH
2952def printUsage(commands):
2953 print "usage: %s <command> [options]" % sys.argv[0]
2954 print ""
2955 print "valid commands: %s" % ", ".join(commands)
2956 print ""
2957 print "Try %s <command> --help for command specific help." % sys.argv[0]
2958 print ""
2959
2960commands = {
b86f7378
HWN
2961 "debug" : P4Debug,
2962 "submit" : P4Submit,
a9834f58 2963 "commit" : P4Submit,
b86f7378
HWN
2964 "sync" : P4Sync,
2965 "rebase" : P4Rebase,
2966 "clone" : P4Clone,
09d89de2
SH
2967 "rollback" : P4RollBack,
2968 "branches" : P4Branches
86949eef
SH
2969}
2970
86949eef 2971
bb6e09b2
HWN
2972def main():
2973 if len(sys.argv[1:]) == 0:
2974 printUsage(commands.keys())
2975 sys.exit(2)
4f5cf76a 2976
bb6e09b2
HWN
2977 cmd = ""
2978 cmdName = sys.argv[1]
2979 try:
b86f7378
HWN
2980 klass = commands[cmdName]
2981 cmd = klass()
bb6e09b2
HWN
2982 except KeyError:
2983 print "unknown command %s" % cmdName
2984 print ""
2985 printUsage(commands.keys())
2986 sys.exit(2)
2987
2988 options = cmd.options
b86f7378 2989 cmd.gitdir = os.environ.get("GIT_DIR", None)
bb6e09b2
HWN
2990
2991 args = sys.argv[2:]
2992
6a10b6aa
LD
2993 options.append(optparse.make_option("--verbose", dest="verbose", action="store_true"))
2994 if cmd.needsGit:
2995 options.append(optparse.make_option("--git-dir", dest="gitdir"))
bb6e09b2 2996
6a10b6aa
LD
2997 parser = optparse.OptionParser(cmd.usage.replace("%prog", "%prog " + cmdName),
2998 options,
2999 description = cmd.description,
3000 formatter = HelpFormatter())
bb6e09b2 3001
6a10b6aa 3002 (cmd, args) = parser.parse_args(sys.argv[2:], cmd);
bb6e09b2
HWN
3003 global verbose
3004 verbose = cmd.verbose
3005 if cmd.needsGit:
b86f7378
HWN
3006 if cmd.gitdir == None:
3007 cmd.gitdir = os.path.abspath(".git")
3008 if not isValidGitDir(cmd.gitdir):
3009 cmd.gitdir = read_pipe("git rev-parse --git-dir").strip()
3010 if os.path.exists(cmd.gitdir):
bb6e09b2
HWN
3011 cdup = read_pipe("git rev-parse --show-cdup").strip()
3012 if len(cdup) > 0:
053fd0c1 3013 chdir(cdup);
e20a9e53 3014
b86f7378
HWN
3015 if not isValidGitDir(cmd.gitdir):
3016 if isValidGitDir(cmd.gitdir + "/.git"):
3017 cmd.gitdir += "/.git"
bb6e09b2 3018 else:
b86f7378 3019 die("fatal: cannot locate git repository at %s" % cmd.gitdir)
e20a9e53 3020
b86f7378 3021 os.environ["GIT_DIR"] = cmd.gitdir
86949eef 3022
bb6e09b2
HWN
3023 if not cmd.run(args):
3024 parser.print_help()
09fca77b 3025 sys.exit(2)
4f5cf76a 3026
4f5cf76a 3027
bb6e09b2
HWN
3028if __name__ == '__main__':
3029 main()