2007-03-20 03:59:12 +08:00
#!/usr/bin/env python
#
# git-p4.py -- A tool for bidirectional operation between a Perforce depot and git.
#
2007-05-28 20:43:25 +08:00
# Author: Simon Hausmann <simon@lst.de>
# Copyright: 2007 Simon Hausmann <simon@lst.de>
2007-03-20 05:26:36 +08:00
# 2007 Trolltech ASA
2007-03-20 03:59:12 +08:00
# License: MIT <http://www.opensource.org/licenses/mit-license.php>
#
2022-04-01 22:24:49 +08:00
# pylint: disable=bad-whitespace
# pylint: disable=broad-except
# pylint: disable=consider-iterating-dictionary
# pylint: disable=disable
# pylint: disable=fixme
# pylint: disable=invalid-name
# pylint: disable=line-too-long
# pylint: disable=missing-docstring
# pylint: disable=no-self-use
# pylint: disable=superfluous-parens
# pylint: disable=too-few-public-methods
# pylint: disable=too-many-arguments
# pylint: disable=too-many-branches
# pylint: disable=too-many-instance-attributes
# pylint: disable=too-many-lines
# pylint: disable=too-many-locals
# pylint: disable=too-many-nested-blocks
# pylint: disable=too-many-statements
# pylint: disable=ungrouped-imports
# pylint: disable=unused-import
# pylint: disable=wrong-import-order
# pylint: disable=wrong-import-position
2020-01-29 19:12:43 +08:00
#
2022-04-01 22:25:04 +08:00
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
import struct
2012-12-29 00:40:59 +08:00
import sys
2019-12-14 07:52:35 +08:00
if sys . version_info . major < 3 and sys . version_info . minor < 7 :
sys . stderr . write ( " git-p4: requires Python 2.7 or later. \n " )
2012-12-29 00:40:59 +08:00
sys . exit ( 1 )
2022-04-01 22:25:04 +08:00
import ctypes
import errno
2019-12-14 07:52:44 +08:00
import functools
2022-04-01 22:25:04 +08:00
import glob
2013-01-27 11:11:05 +08:00
import marshal
2022-04-01 22:25:04 +08:00
import optparse
import os
2013-01-27 11:11:05 +08:00
import platform
import re
import shutil
2013-01-27 11:11:19 +08:00
import stat
2022-04-01 22:25:04 +08:00
import subprocess
import tempfile
import time
2015-09-26 15:55:03 +08:00
import zipfile
import zlib
2007-05-24 05:20:53 +08:00
2019-12-14 07:52:47 +08:00
# On python2.7 where raw_input() and input() are both availble,
# we want raw_input's semantics, but aliased to input for python3
# compatibility
2018-06-19 16:04:09 +08:00
# support basestring in python3
try :
2019-12-14 07:52:47 +08:00
if raw_input and input :
input = raw_input
except :
pass
2013-01-27 03:14:33 +08:00
2007-05-24 05:49:35 +08:00
verbose = False
2007-03-20 03:59:12 +08:00
2012-04-11 23:21:24 +08:00
# Only labels/tags matching this will be imported/exported
2012-04-11 23:21:24 +08:00
defaultLabelRegexp = r ' [a-zA-Z0-9_ \ -.]+$ '
2008-08-11 02:26:28 +08:00
git-p4: auto-size the block
git-p4 originally would fetch changes in one query. On large repos this
could fail because of the limits that Perforce imposes on the number of
items returned and the number of queries in the database.
To fix this, git-p4 learned to query changes in blocks of 512 changes,
However, this can be very slow - if you have a few million changes,
with each chunk taking about a second, it can be an hour or so.
Although it's possible to tune this value manually with the
"--changes-block-size" option, it's far from obvious to ordinary users
that this is what needs doing.
This change alters the block size dynamically by looking for the
specific error messages returned from the Perforce server, and reducing
the block size if the error is seen, either to the limit reported by the
server, or to half the current block size.
That means we can start out with a very large block size, and then let
it automatically drop down to a value that works without error, while
still failing correctly if some other error occurs.
Signed-off-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-09 04:32:48 +08:00
# The block size is reduced automatically if required
2022-04-01 22:24:58 +08:00
defaultBlockSize = 1 << 20
2015-06-10 15:30:59 +08:00
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
defaultMetadataDecodingStrategy = ' passthrough ' if sys . version_info . major == 2 else ' fallback '
defaultFallbackMetadataEncoding = ' cp1252 '
2018-06-09 04:32:45 +08:00
p4_access_checked = False
2015-06-10 15:30:59 +08:00
git-p4: resolve RCS keywords in bytes not utf-8
RCS keywords are strings that are replaced with information from
Perforce. Examples include $Date$, $Author$, $File$, $Change$ etc.
Perforce resolves these by expanding them with their expanded values
when files are synced, but Git's data model requires these expanded
values to be converted back into their unexpanded form.
Previously, git-p4.py would implement this behaviour through the use of
regular expressions. However, the regular expression substitution was
applied using decoded strings i.e. the content of incoming commit diffs
was first decoded from bytes into UTF-8, processed with regular
expressions, then converted back to bytes.
Not only is this behaviour inefficient, but it is also a cause of a
common issue caused by text files containing invalid UTF-8 data. For
files created in Windows, CP1252 Smart Quote Characters (0x93 and 0x94)
are seen fairly frequently. These codes are invalid in UTF-8, so if the
script encountered any file containing them, on Python 2 the symbols
will be corrupted, and on Python 3 the script will fail with an
exception.
This patch replaces this decoding/encoding with bytes object regular
expressions, so that the substitution is performed directly upon the
source data with no conversions.
A test for smart quote handling has been added to the
t9810-git-p4-rcs.sh test suite.
Signed-off-by: Joel Holdsworth <jholdsworth@nvidia.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-16 21:46:19 +08:00
re_ko_keywords = re . compile ( br ' \ $(Id|Header)(:[^$ \ n]+)? \ $ ' )
re_k_keywords = re . compile ( br ' \ $(Id|Header|Author|Date|DateTime|Change|File|Revision)(:[^$ \ n]+)? \ $ ' )
2021-12-16 21:46:16 +08:00
2022-04-01 22:24:43 +08:00
git-p4: print size values in appropriate units
The git-p4 script reports file sizes in various log messages.
Previously, in each case the script would print them as the number of
bytes divided by 1048576 i.e. the size in mebibytes, rounded down to an
integer. This resulted in small files being described as having a size
of "0 MB".
This patch replaces the existing behaviour with a new helper function:
format_size_human_readable, which takes a number of bytes (or any other
quantity), and computes the appropriate prefix to use: none, Ki, Mi, Gi,
Ti, Pi, Ei, Zi, Yi.
For example, a size of 123456 will now be printed as "120.6 KiB" greatly
improving the readability of the log output.
Large valued prefixes such as pebi, exbi, zebi and yobi are included for
completeness, though they not expected to appear in any real-world
Perforce repository!
Signed-off-by: Joel Holdsworth <jholdsworth@nvidia.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-19 23:40:27 +08:00
def format_size_human_readable ( num ) :
2022-04-01 22:24:46 +08:00
""" Returns a number of units (typically bytes) formatted as a
human - readable string .
"""
git-p4: print size values in appropriate units
The git-p4 script reports file sizes in various log messages.
Previously, in each case the script would print them as the number of
bytes divided by 1048576 i.e. the size in mebibytes, rounded down to an
integer. This resulted in small files being described as having a size
of "0 MB".
This patch replaces the existing behaviour with a new helper function:
format_size_human_readable, which takes a number of bytes (or any other
quantity), and computes the appropriate prefix to use: none, Ki, Mi, Gi,
Ti, Pi, Ei, Zi, Yi.
For example, a size of 123456 will now be printed as "120.6 KiB" greatly
improving the readability of the log output.
Large valued prefixes such as pebi, exbi, zebi and yobi are included for
completeness, though they not expected to appear in any real-world
Perforce repository!
Signed-off-by: Joel Holdsworth <jholdsworth@nvidia.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-19 23:40:27 +08:00
if num < 1024 :
return ' {:d} B ' . format ( num )
for unit in [ " Ki " , " Mi " , " Gi " , " Ti " , " Pi " , " Ei " , " Zi " ] :
num / = 1024.0
if num < 1024.0 :
return " {:3.1f} {} B " . format ( num , unit )
return " {:.1f} YiB " . format ( num )
2022-04-01 22:24:43 +08:00
2008-08-11 02:26:28 +08:00
def p4_build_cmd ( cmd ) :
""" Build a suitable p4 command line.
2022-04-01 22:24:46 +08:00
This consolidates building and returning a p4 command line into one
location . It means that hooking into the environment , or other
configuration can be done more easily .
"""
2011-10-16 22:47:52 +08:00
real_cmd = [ " p4 " ]
2008-08-11 02:26:31 +08:00
user = gitConfig ( " git-p4.user " )
if len ( user ) > 0 :
2022-04-01 22:24:53 +08:00
real_cmd + = [ " -u " , user ]
2008-08-11 02:26:31 +08:00
password = gitConfig ( " git-p4.password " )
if len ( password ) > 0 :
2011-10-16 22:47:52 +08:00
real_cmd + = [ " -P " , password ]
2008-08-11 02:26:31 +08:00
port = gitConfig ( " git-p4.port " )
if len ( port ) > 0 :
2011-10-16 22:47:52 +08:00
real_cmd + = [ " -p " , port ]
2008-08-11 02:26:31 +08:00
host = gitConfig ( " git-p4.host " )
if len ( host ) > 0 :
2012-02-23 03:16:05 +08:00
real_cmd + = [ " -H " , host ]
2008-08-11 02:26:31 +08:00
client = gitConfig ( " git-p4.client " )
if len ( client ) > 0 :
2011-10-16 22:47:52 +08:00
real_cmd + = [ " -c " , client ]
2008-08-11 02:26:31 +08:00
2016-12-04 22:03:11 +08:00
retries = gitConfigInt ( " git-p4.retries " )
if retries is None :
# Perform 3 retries by default
retries = 3
2016-12-29 18:22:23 +08:00
if retries > 0 :
# Provide a way to not pass this option by setting git-p4.retries to 0
real_cmd + = [ " -r " , str ( retries ) ]
2011-10-16 22:47:52 +08:00
2022-01-07 05:40:34 +08:00
real_cmd + = cmd
2018-06-09 04:32:45 +08:00
# now check that we can actually talk to the server
global p4_access_checked
if not p4_access_checked :
p4_access_checked = True # suppress access checks in p4_check_access itself
p4_check_access ( )
2008-08-11 02:26:28 +08:00
return real_cmd
2022-04-01 22:24:43 +08:00
2016-12-14 05:51:28 +08:00
def git_dir ( path ) :
2022-04-01 22:24:46 +08:00
""" Return TRUE if the given path is a git directory (/path/to/dir/.git).
This won ' t automatically add " .git " to a directory.
"""
2016-12-14 05:51:28 +08:00
d = read_pipe ( [ " git " , " --git-dir " , path , " rev-parse " , " --git-dir " ] , True ) . strip ( )
if not d or len ( d ) == 0 :
return None
else :
return d
2022-04-01 22:24:43 +08:00
2013-03-12 05:45:29 +08:00
def chdir ( path , is_client_path = False ) :
2022-04-01 22:24:46 +08:00
""" Do chdir to the given path, and set the PWD environment variable for use
by P4 . It does not look at getcwd ( ) output . Since we ' re not using the
shell , it is necessary to set the PWD environment variable explicitly .
Normally , expand the path to force it to be absolute . This addresses
the use of relative path names inside P4 settings , e . g .
P4CONFIG = . p4config . P4 does not simply open the filename as given ; it
looks for . p4config using PWD .
If is_client_path , the path was handed to us directly by p4 , and may be
a symbolic link . Do not call os . getcwd ( ) in this case , because it will
cause p4 to think that PWD is not inside the client path .
2013-03-12 05:45:29 +08:00
"""
os . chdir ( path )
if not is_client_path :
path = os . getcwd ( )
os . environ [ ' PWD ' ] = path
2008-08-02 03:50:03 +08:00
2022-04-01 22:24:43 +08:00
2015-09-26 15:55:02 +08:00
def calcDiskFree ( ) :
""" Return free space in bytes on the disk of the given dirname. """
if platform . system ( ) == ' Windows ' :
free_bytes = ctypes . c_ulonglong ( 0 )
ctypes . windll . kernel32 . GetDiskFreeSpaceExW ( ctypes . c_wchar_p ( os . getcwd ( ) ) , None , None , ctypes . pointer ( free_bytes ) )
return free_bytes . value
else :
st = os . statvfs ( os . getcwd ( ) )
return st . f_bavail * st . f_frsize
2022-04-01 22:24:43 +08:00
2007-05-24 05:49:35 +08:00
def die ( msg ) :
2022-04-01 22:24:46 +08:00
""" Terminate execution. Make sure that any running child processes have
been wait ( ) ed for before calling this .
"""
2007-05-24 05:49:35 +08:00
if verbose :
raise Exception ( msg )
else :
sys . stderr . write ( msg + " \n " )
sys . exit ( 1 )
2022-04-01 22:24:43 +08:00
2019-12-16 22:02:19 +08:00
def prompt ( prompt_text ) :
2022-04-01 22:24:46 +08:00
""" Prompt the user to choose one of the choices.
2019-12-16 22:02:19 +08:00
2022-04-01 22:24:46 +08:00
Choices are identified in the prompt_text by square brackets around a
single letter option .
"""
2019-12-16 22:02:19 +08:00
choices = set ( m . group ( 1 ) for m in re . finditer ( r " \ [(.) \ ] " , prompt_text ) )
while True :
2020-02-12 02:57:58 +08:00
sys . stderr . flush ( )
sys . stdout . write ( prompt_text )
sys . stdout . flush ( )
2022-04-01 22:24:58 +08:00
response = sys . stdin . readline ( ) . strip ( ) . lower ( )
2019-12-16 22:02:19 +08:00
if not response :
continue
response = response [ 0 ]
if response in choices :
return response
2022-04-01 22:24:43 +08:00
2019-12-14 07:52:38 +08:00
# We need different encoding/decoding strategies for text data being passed
# around in pipes depending on python version
if bytes is not str :
# For python3, always encode and decode as appropriate
def decode_text_stream ( s ) :
return s . decode ( ) if isinstance ( s , bytes ) else s
2022-04-01 22:24:43 +08:00
2019-12-14 07:52:38 +08:00
def encode_text_stream ( s ) :
return s . encode ( ) if isinstance ( s , str ) else s
else :
# For python2.7, pass read strings as-is, but also allow writing unicode
def decode_text_stream ( s ) :
return s
2022-04-01 22:24:43 +08:00
2019-12-14 07:52:38 +08:00
def encode_text_stream ( s ) :
return s . encode ( ' utf_8 ' ) if isinstance ( s , unicode ) else s
2022-04-01 22:24:43 +08:00
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
class MetadataDecodingException ( Exception ) :
def __init__ ( self , input_string ) :
self . input_string = input_string
def __str__ ( self ) :
return """ Decoding perforce metadata failed!
The failing string was :
- - -
{ }
- - -
Consider setting the git - p4 . metadataDecodingStrategy config option to
' fallback ' , to allow metadata to be decoded using a fallback encoding ,
defaulting to cp1252 . """ .format(self.input_string)
encoding_fallback_warning_issued = False
encoding_escape_warning_issued = False
def metadata_stream_to_writable_bytes ( s ) :
encodingStrategy = gitConfig ( ' git-p4.metadataDecodingStrategy ' ) or defaultMetadataDecodingStrategy
fallbackEncoding = gitConfig ( ' git-p4.metadataFallbackEncoding ' ) or defaultFallbackMetadataEncoding
if not isinstance ( s , bytes ) :
return s . encode ( ' utf_8 ' )
if encodingStrategy == ' passthrough ' :
return s
try :
s . decode ( ' utf_8 ' )
return s
except UnicodeDecodeError :
if encodingStrategy == ' fallback ' and fallbackEncoding :
global encoding_fallback_warning_issued
global encoding_escape_warning_issued
try :
if not encoding_fallback_warning_issued :
print ( " \n Could not decode value as utf-8; using configured fallback encoding %s : %s " % ( fallbackEncoding , s ) )
print ( " \n (this warning is only displayed once during an import) " )
encoding_fallback_warning_issued = True
return s . decode ( fallbackEncoding ) . encode ( ' utf_8 ' )
except Exception as exc :
if not encoding_escape_warning_issued :
print ( " \n Could not decode value with configured fallback encoding %s ; escaping bytes over 127: %s " % ( fallbackEncoding , s ) )
print ( " \n (this warning is only displayed once during an import) " )
encoding_escape_warning_issued = True
escaped_bytes = b ' '
# bytes and strings work very differently in python2 vs python3...
if str is bytes :
for byte in s :
byte_number = struct . unpack ( ' >B ' , byte ) [ 0 ]
if byte_number > 127 :
escaped_bytes + = b ' % '
escaped_bytes + = hex ( byte_number ) [ 2 : ] . upper ( )
else :
escaped_bytes + = byte
else :
for byte_number in s :
if byte_number > 127 :
escaped_bytes + = b ' % '
escaped_bytes + = hex ( byte_number ) . upper ( ) . encode ( ) [ 2 : ]
else :
escaped_bytes + = bytes ( [ byte_number ] )
return escaped_bytes
raise MetadataDecodingException ( s )
2022-05-21 06:27:00 +08:00
2019-12-14 07:52:40 +08:00
def decode_path ( path ) :
2022-04-01 22:24:46 +08:00
""" Decode a given string (bytes or otherwise) using configured path
encoding options .
"""
2019-12-14 07:52:40 +08:00
encoding = gitConfig ( ' git-p4.pathEncoding ' ) or ' utf_8 '
if bytes is not str :
return path . decode ( encoding , errors = ' replace ' ) if isinstance ( path , bytes ) else path
else :
try :
path . decode ( ' ascii ' )
except :
path = path . decode ( encoding , errors = ' replace ' )
if verbose :
print ( ' Path with non-ASCII characters detected. Used {} to decode: {} ' . format ( encoding , path ) )
return path
2022-04-01 22:24:43 +08:00
git-p4: create new function run_git_hook
This commit is in preparation of introducing new p4 submit hooks.
The current code in the python script git-p4.py makes the assumption
that the git hooks can be executed by subprocess.call() function.
However, when git is run on Windows, this may not work as expected.
The subprocess.call() does not cover all the use cases for properly
executing the various types of executable files on Windows.
Prepare for remediation by adding a new function, run_git_hook, that
takes 2 parameters:
* the short filename of an optionally registered git hook
* an optional list of parameters
The run_git_hook function will honor the existing behavior seen in the
current code for executing the p4-pre-submit hook:
* Hooks are looked for in core.hooksPath directory.
* If core.hooksPath is not set, then the current .git/hooks directory
is checked.
* If the hook does not exist, the function returns True.
* If the hook file is not accessible, the function returns True.
* If the hook returns a zero exit code when executed, the function
return True.
* If the hook returns a non-zero exit code, the function returns False.
Add the following additional functionality if git-p4.py is run on
Windows.
* If hook file is not located without an extension, search for
any file in the associated hook directory (from the list above) that
has the same name but with an extension.
* If the file is still not found, return True (the hook is missing)
Add a new function run_hook_command() that wraps the OS dependent
functionality for actually running the subprocess.call() with OS
dependent behavior:
If a hook file exists on Windows:
* If there is no extension, set the launch executable to be SH.EXE
- Look for SH.EXE under the environmental variable EXEPATH in the
bin/ directory.
- If %EXEPATH%/bin/sh.exe exists, use this as the actual executable.
- If %EXEPATH%/bin/sh.exe does not exist, use sh.exe
- Execute subprocess.call() without the shell (shell=False)
* If there is an extension, execute subprocess.call() with teh shell
(shell=True) and consider the file to be the executable.
The return value from run_hook_command() is the subprocess.call()
return value.
These functions are added in this commit, but are only staged and not
yet used.
Signed-off-by: Ben Keene <seraphire@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-12 02:57:59 +08:00
def run_git_hook ( cmd , param = [ ] ) :
""" Execute a hook if the hook exists. """
2021-12-22 11:59:39 +08:00
args = [ ' git ' , ' hook ' , ' run ' , ' --ignore-missing ' , cmd ]
if param :
args . append ( " -- " )
for p in param :
args . append ( p )
return subprocess . call ( args ) == 0
git-p4: create new function run_git_hook
This commit is in preparation of introducing new p4 submit hooks.
The current code in the python script git-p4.py makes the assumption
that the git hooks can be executed by subprocess.call() function.
However, when git is run on Windows, this may not work as expected.
The subprocess.call() does not cover all the use cases for properly
executing the various types of executable files on Windows.
Prepare for remediation by adding a new function, run_git_hook, that
takes 2 parameters:
* the short filename of an optionally registered git hook
* an optional list of parameters
The run_git_hook function will honor the existing behavior seen in the
current code for executing the p4-pre-submit hook:
* Hooks are looked for in core.hooksPath directory.
* If core.hooksPath is not set, then the current .git/hooks directory
is checked.
* If the hook does not exist, the function returns True.
* If the hook file is not accessible, the function returns True.
* If the hook returns a zero exit code when executed, the function
return True.
* If the hook returns a non-zero exit code, the function returns False.
Add the following additional functionality if git-p4.py is run on
Windows.
* If hook file is not located without an extension, search for
any file in the associated hook directory (from the list above) that
has the same name but with an extension.
* If the file is still not found, return True (the hook is missing)
Add a new function run_hook_command() that wraps the OS dependent
functionality for actually running the subprocess.call() with OS
dependent behavior:
If a hook file exists on Windows:
* If there is no extension, set the launch executable to be SH.EXE
- Look for SH.EXE under the environmental variable EXEPATH in the
bin/ directory.
- If %EXEPATH%/bin/sh.exe exists, use this as the actual executable.
- If %EXEPATH%/bin/sh.exe does not exist, use sh.exe
- Execute subprocess.call() without the shell (shell=False)
* If there is an extension, execute subprocess.call() with teh shell
(shell=True) and consider the file to be the executable.
The return value from run_hook_command() is the subprocess.call()
return value.
These functions are added in this commit, but are only staged and not
yet used.
Signed-off-by: Ben Keene <seraphire@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-02-12 02:57:59 +08:00
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def write_pipe ( c , stdin , * k , * * kw ) :
2007-05-24 05:49:35 +08:00
if verbose :
2022-01-07 05:40:35 +08:00
sys . stderr . write ( ' Writing pipe: {} \n ' . format ( ' ' . join ( c ) ) )
2007-05-24 04:10:46 +08:00
2022-01-07 05:40:33 +08:00
p = subprocess . Popen ( c , stdin = subprocess . PIPE , * k , * * kw )
2011-10-16 22:47:52 +08:00
pipe = p . stdin
val = pipe . write ( stdin )
pipe . close ( )
if p . wait ( ) :
2022-01-07 05:40:35 +08:00
die ( ' Command failed: {} ' . format ( ' ' . join ( c ) ) )
2007-05-24 04:10:46 +08:00
return val
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def p4_write_pipe ( c , stdin , * k , * * kw ) :
2008-08-15 06:40:38 +08:00
real_cmd = p4_build_cmd ( c )
2019-12-14 07:52:38 +08:00
if bytes is not str and isinstance ( stdin , str ) :
stdin = encode_text_stream ( stdin )
2022-01-07 05:40:33 +08:00
return write_pipe ( real_cmd , stdin , * k , * * kw )
2008-08-15 06:40:38 +08:00
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def read_pipe_full ( c , * k , * * kw ) :
2022-04-01 22:24:46 +08:00
""" Read output from command. Returns a tuple of the return status, stdout
text and stderr text .
"""
2007-05-24 05:49:35 +08:00
if verbose :
2022-01-07 05:40:35 +08:00
sys . stderr . write ( ' Reading pipe: {} \n ' . format ( ' ' . join ( c ) ) )
2007-05-24 05:20:53 +08:00
2022-01-07 05:40:33 +08:00
p = subprocess . Popen (
c , stdout = subprocess . PIPE , stderr = subprocess . PIPE , * k , * * kw )
2022-04-01 22:24:52 +08:00
out , err = p . communicate ( )
2019-12-14 07:52:38 +08:00
return ( p . returncode , out , decode_text_stream ( err ) )
2017-04-15 18:36:08 +08:00
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def read_pipe ( c , ignore_error = False , raw = False , * k , * * kw ) :
2022-04-01 22:24:46 +08:00
""" Read output from command. Returns the output text on success. On
failure , terminates execution , unless ignore_error is True , when it
returns an empty string .
2019-12-14 07:52:39 +08:00
2022-04-01 22:24:46 +08:00
If raw is True , do not attempt to decode output text .
"""
2022-04-01 22:24:52 +08:00
retcode , out , err = read_pipe_full ( c , * k , * * kw )
2017-04-15 18:36:08 +08:00
if retcode != 0 :
if ignore_error :
out = " "
else :
2022-01-07 05:40:35 +08:00
die ( ' Command failed: {} \n Error: {} ' . format ( ' ' . join ( c ) , err ) )
2019-12-14 07:52:39 +08:00
if not raw :
out = decode_text_stream ( out )
2015-09-21 18:01:41 +08:00
return out
2007-05-24 04:10:46 +08:00
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def read_pipe_text ( c , * k , * * kw ) :
2022-04-01 22:24:46 +08:00
""" Read output from a command with trailing whitespace stripped. On error,
returns None .
"""
2022-04-01 22:24:52 +08:00
retcode , out , err = read_pipe_full ( c , * k , * * kw )
2017-04-15 18:36:08 +08:00
if retcode != 0 :
return None
else :
2019-12-14 07:52:38 +08:00
return decode_text_stream ( out ) . rstrip ( )
2017-04-15 18:36:08 +08:00
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def p4_read_pipe ( c , ignore_error = False , raw = False , * k , * * kw ) :
2008-08-15 06:40:38 +08:00
real_cmd = p4_build_cmd ( c )
2022-01-07 05:40:33 +08:00
return read_pipe ( real_cmd , ignore_error , raw = raw , * k , * * kw )
2007-05-24 04:10:46 +08:00
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def read_pipe_lines ( c , raw = False , * k , * * kw ) :
2007-05-24 05:49:35 +08:00
if verbose :
2022-01-07 05:40:35 +08:00
sys . stderr . write ( ' Reading pipe: {} \n ' . format ( ' ' . join ( c ) ) )
2011-10-16 22:47:52 +08:00
2022-01-07 05:40:33 +08:00
p = subprocess . Popen ( c , stdout = subprocess . PIPE , * k , * * kw )
2011-10-16 22:47:52 +08:00
pipe = p . stdout
2021-12-16 21:46:17 +08:00
lines = pipe . readlines ( )
if not raw :
lines = [ decode_text_stream ( line ) for line in lines ]
2011-10-16 22:47:52 +08:00
if pipe . close ( ) or p . wait ( ) :
2022-01-07 05:40:35 +08:00
die ( ' Command failed: {} ' . format ( ' ' . join ( c ) ) )
2021-12-16 21:46:17 +08:00
return lines
2007-05-15 20:57:57 +08:00
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def p4_read_pipe_lines ( c , * k , * * kw ) :
2022-04-01 22:24:46 +08:00
""" Specifically invoke p4 on the command supplied. """
2008-08-11 02:26:30 +08:00
real_cmd = p4_build_cmd ( c )
2022-01-07 05:40:33 +08:00
return read_pipe_lines ( real_cmd , * k , * * kw )
2008-08-11 02:26:24 +08:00
2022-04-01 22:24:43 +08:00
2012-07-13 07:29:00 +08:00
def p4_has_command ( cmd ) :
2022-04-01 22:24:46 +08:00
""" Ask p4 for help on this command. If it returns an error, the command
does not exist in this version of p4 .
"""
2012-07-13 07:29:00 +08:00
real_cmd = p4_build_cmd ( [ " help " , cmd ] )
p = subprocess . Popen ( real_cmd , stdout = subprocess . PIPE ,
stderr = subprocess . PIPE )
p . communicate ( )
return p . returncode == 0
2022-04-01 22:24:43 +08:00
2012-11-24 06:35:35 +08:00
def p4_has_move_command ( ) :
2022-04-01 22:24:46 +08:00
""" See if the move command exists, that it supports -k, and that it has not
been administratively disabled . The arguments must be correct , but the
filenames do not have to exist . Use ones with wildcards so even if they
exist , it will fail .
"""
2012-11-24 06:35:35 +08:00
if not p4_has_command ( " move " ) :
return False
cmd = p4_build_cmd ( [ " move " , " -k " , " @from " , " @to " ] )
p = subprocess . Popen ( cmd , stdout = subprocess . PIPE , stderr = subprocess . PIPE )
2022-04-01 22:24:52 +08:00
out , err = p . communicate ( )
2019-12-14 07:52:38 +08:00
err = decode_text_stream ( err )
2012-11-24 06:35:35 +08:00
# return code will be 1 in either case
if err . find ( " Invalid option " ) > = 0 :
return False
if err . find ( " disabled " ) > = 0 :
return False
# assume it failed because @... was invalid changelist
return True
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def system ( cmd , ignore_error = False , * k , * * kw ) :
2007-05-24 05:49:35 +08:00
if verbose :
2022-01-07 05:40:35 +08:00
sys . stderr . write ( " executing {} \n " . format (
' ' . join ( cmd ) if isinstance ( cmd , list ) else cmd ) )
2022-01-07 05:40:33 +08:00
retcode = subprocess . call ( cmd , * k , * * kw )
2015-11-21 17:54:40 +08:00
if retcode and not ignore_error :
2022-01-07 05:41:56 +08:00
raise subprocess . CalledProcessError ( retcode , cmd )
2007-05-24 04:41:50 +08:00
2015-11-21 17:54:40 +08:00
return retcode
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def p4_system ( cmd , * k , * * kw ) :
2022-04-01 22:24:46 +08:00
""" Specifically invoke p4 as the system command. """
2008-08-11 02:26:30 +08:00
real_cmd = p4_build_cmd ( cmd )
2022-01-07 05:40:33 +08:00
retcode = subprocess . call ( real_cmd , * k , * * kw )
2013-01-27 03:14:33 +08:00
if retcode :
2022-01-07 05:41:56 +08:00
raise subprocess . CalledProcessError ( retcode , real_cmd )
2011-10-16 22:47:52 +08:00
2022-04-01 22:24:43 +08:00
2018-06-09 04:32:45 +08:00
def die_bad_access ( s ) :
die ( " failure accessing depot: {0} " . format ( s . rstrip ( ) ) )
2022-04-01 22:24:43 +08:00
2018-06-09 04:32:45 +08:00
def p4_check_access ( min_expiration = 1 ) :
2022-04-01 22:24:46 +08:00
""" Check if we can access Perforce - account still logged in. """
2018-06-09 04:32:45 +08:00
results = p4CmdList ( [ " login " , " -s " ] )
if len ( results ) == 0 :
# should never get here: always get either some results, or a p4ExitCode
assert ( " could not parse response from perforce " )
result = results [ 0 ]
if ' p4ExitCode ' in result :
# p4 returned non-zero status, e.g. P4PORT invalid, or p4 not in path
die_bad_access ( " could not run p4 " )
code = result . get ( " code " )
if not code :
# we get here if we couldn't connect and there was nothing to unmarshal
die_bad_access ( " could not connect " )
elif code == " stat " :
expiry = result . get ( " TicketExpiration " )
if expiry :
expiry = int ( expiry )
if expiry > min_expiration :
# ok to carry on
return
else :
die_bad_access ( " perforce ticket expires in {0} seconds " . format ( expiry ) )
else :
# account without a timeout - all ok
return
elif code == " error " :
data = result . get ( " data " )
if data :
die_bad_access ( " p4 error: {0} " . format ( data ) )
else :
die_bad_access ( " unknown error " )
2019-01-08 04:51:38 +08:00
elif code == " info " :
return
2018-06-09 04:32:45 +08:00
else :
die_bad_access ( " unknown error code {0} " . format ( code ) )
2022-04-01 22:24:43 +08:00
git p4: scrub crlf for utf16 files on windows
Files of type utf16 are handled with "p4 print" instead of the
normal "p4 -G print" interface due to how the latter does not
produce correct output. See 55aa571 (git-p4: handle utf16
filetype properly, 2011-09-17) for details.
On windows, though, "p4 print" can not be told which line
endings to use, as there is no underlying client, and always
chooses crlf, even for utf16 files. Convert the \r\n into \n
when importing utf16 files.
The fix for this is complex, in that the problem is a property
of the NT version of p4. There are old versions of p4 that
were compiled directly for cygwin that should not be subjected
to text replacement. The right check here, then, is to look
at the p4 version, not the OS version. Note also that on cygwin,
platform.system() is "CYGWIN_NT-5.1" or similar, not "Windows".
Add a function to memoize the p4 version string and use it to
check for "/NT", indicating the Windows build of p4.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-27 11:11:13 +08:00
_p4_version_string = None
2022-04-01 22:24:43 +08:00
git p4: scrub crlf for utf16 files on windows
Files of type utf16 are handled with "p4 print" instead of the
normal "p4 -G print" interface due to how the latter does not
produce correct output. See 55aa571 (git-p4: handle utf16
filetype properly, 2011-09-17) for details.
On windows, though, "p4 print" can not be told which line
endings to use, as there is no underlying client, and always
chooses crlf, even for utf16 files. Convert the \r\n into \n
when importing utf16 files.
The fix for this is complex, in that the problem is a property
of the NT version of p4. There are old versions of p4 that
were compiled directly for cygwin that should not be subjected
to text replacement. The right check here, then, is to look
at the p4 version, not the OS version. Note also that on cygwin,
platform.system() is "CYGWIN_NT-5.1" or similar, not "Windows".
Add a function to memoize the p4 version string and use it to
check for "/NT", indicating the Windows build of p4.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-27 11:11:13 +08:00
def p4_version_string ( ) :
2022-04-01 22:24:46 +08:00
""" Read the version string, showing just the last line, which hopefully is
the interesting version bit .
git p4: scrub crlf for utf16 files on windows
Files of type utf16 are handled with "p4 print" instead of the
normal "p4 -G print" interface due to how the latter does not
produce correct output. See 55aa571 (git-p4: handle utf16
filetype properly, 2011-09-17) for details.
On windows, though, "p4 print" can not be told which line
endings to use, as there is no underlying client, and always
chooses crlf, even for utf16 files. Convert the \r\n into \n
when importing utf16 files.
The fix for this is complex, in that the problem is a property
of the NT version of p4. There are old versions of p4 that
were compiled directly for cygwin that should not be subjected
to text replacement. The right check here, then, is to look
at the p4 version, not the OS version. Note also that on cygwin,
platform.system() is "CYGWIN_NT-5.1" or similar, not "Windows".
Add a function to memoize the p4 version string and use it to
check for "/NT", indicating the Windows build of p4.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-27 11:11:13 +08:00
$ p4 - V
Perforce - The Fast Software Configuration Management System .
Copyright 1995 - 2011 Perforce Software . All rights reserved .
Rev . P4 / NTX86 / 2011.1 / 393975 ( 2011 / 12 / 16 ) .
2022-04-01 22:24:46 +08:00
"""
git p4: scrub crlf for utf16 files on windows
Files of type utf16 are handled with "p4 print" instead of the
normal "p4 -G print" interface due to how the latter does not
produce correct output. See 55aa571 (git-p4: handle utf16
filetype properly, 2011-09-17) for details.
On windows, though, "p4 print" can not be told which line
endings to use, as there is no underlying client, and always
chooses crlf, even for utf16 files. Convert the \r\n into \n
when importing utf16 files.
The fix for this is complex, in that the problem is a property
of the NT version of p4. There are old versions of p4 that
were compiled directly for cygwin that should not be subjected
to text replacement. The right check here, then, is to look
at the p4 version, not the OS version. Note also that on cygwin,
platform.system() is "CYGWIN_NT-5.1" or similar, not "Windows".
Add a function to memoize the p4 version string and use it to
check for "/NT", indicating the Windows build of p4.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-27 11:11:13 +08:00
global _p4_version_string
if not _p4_version_string :
a = p4_read_pipe_lines ( [ " -V " ] )
_p4_version_string = a [ - 1 ] . rstrip ( )
return _p4_version_string
2022-04-01 22:24:43 +08:00
2011-10-16 22:47:52 +08:00
def p4_integrate ( src , dest ) :
2012-04-30 08:57:17 +08:00
p4_system ( [ " integrate " , " -Dt " , wildcard_encode ( src ) , wildcard_encode ( dest ) ] )
2011-10-16 22:47:52 +08:00
2022-04-01 22:24:43 +08:00
2012-04-30 08:57:14 +08:00
def p4_sync ( f , * options ) :
2012-04-30 08:57:17 +08:00
p4_system ( [ " sync " ] + list ( options ) + [ wildcard_encode ( f ) ] )
2011-10-16 22:47:52 +08:00
2022-04-01 22:24:43 +08:00
2011-10-16 22:47:52 +08:00
def p4_add ( f ) :
2022-04-01 22:24:47 +08:00
""" Forcibly add file names with wildcards. """
2012-04-30 08:57:17 +08:00
if wildcard_present ( f ) :
p4_system ( [ " add " , " -f " , f ] )
else :
p4_system ( [ " add " , f ] )
2011-10-16 22:47:52 +08:00
2022-04-01 22:24:43 +08:00
2011-10-16 22:47:52 +08:00
def p4_delete ( f ) :
2012-04-30 08:57:17 +08:00
p4_system ( [ " delete " , wildcard_encode ( f ) ] )
2011-10-16 22:47:52 +08:00
2022-04-01 22:24:43 +08:00
2016-01-12 20:43:47 +08:00
def p4_edit ( f , * options ) :
p4_system ( [ " edit " ] + list ( options ) + [ wildcard_encode ( f ) ] )
2011-10-16 22:47:52 +08:00
2022-04-01 22:24:43 +08:00
2011-10-16 22:47:52 +08:00
def p4_revert ( f ) :
2012-04-30 08:57:17 +08:00
p4_system ( [ " revert " , wildcard_encode ( f ) ] )
2011-10-16 22:47:52 +08:00
2022-04-01 22:24:43 +08:00
2012-04-30 08:57:17 +08:00
def p4_reopen ( type , f ) :
p4_system ( [ " reopen " , " -t " , type , wildcard_encode ( f ) ] )
2008-08-11 02:26:26 +08:00
2022-04-01 22:24:43 +08:00
2016-12-03 06:43:19 +08:00
def p4_reopen_in_change ( changelist , files ) :
cmd = [ " reopen " , " -c " , str ( changelist ) ] + files
p4_system ( cmd )
2022-04-01 22:24:43 +08:00
2012-07-13 07:29:00 +08:00
def p4_move ( src , dest ) :
p4_system ( [ " move " , " -k " , wildcard_encode ( src ) , wildcard_encode ( dest ) ] )
2022-04-01 22:24:43 +08:00
2015-06-10 15:30:59 +08:00
def p4_last_change ( ) :
2017-07-13 15:00:35 +08:00
results = p4CmdList ( [ " changes " , " -m " , " 1 " ] , skip_info = True )
2015-06-10 15:30:59 +08:00
return int ( results [ 0 ] [ ' change ' ] )
2022-04-01 22:24:43 +08:00
2018-05-24 06:20:26 +08:00
def p4_describe ( change , shelved = False ) :
2022-04-01 22:24:46 +08:00
""" Make sure it returns a valid result by checking for the presence of
field " time " .
Return a dict of the results .
"""
2012-11-24 06:35:34 +08:00
2018-05-24 06:20:26 +08:00
cmd = [ " describe " , " -s " ]
if shelved :
cmd + = [ " -S " ]
cmd + = [ str ( change ) ]
ds = p4CmdList ( cmd , skip_info = True )
2012-11-24 06:35:34 +08:00
if len ( ds ) != 1 :
die ( " p4 describe -s %d did not return 1 result: %s " % ( change , str ( ds ) ) )
d = ds [ 0 ]
if " p4ExitCode " in d :
die ( " p4 describe -s %d exited with %d : %s " % ( change , d [ " p4ExitCode " ] ,
str ( d ) ) )
if " code " in d :
if d [ " code " ] == " error " :
die ( " p4 describe -s %d returned error code: %s " % ( change , str ( d ) ) )
if " time " not in d :
die ( " p4 describe -s %d returned no \" time \" : %s " % ( change , str ( d ) ) )
return d
2022-04-01 22:24:43 +08:00
2011-10-16 22:45:01 +08:00
def split_p4_type ( p4type ) :
2022-04-01 22:24:47 +08:00
""" Canonicalize the p4 type and return a tuple of the base type, plus any
modifiers . See " p4 help filetypes " for a list and explanation .
"""
2011-10-16 22:45:01 +08:00
p4_filetypes_historical = {
" ctempobj " : " binary+Sw " ,
" ctext " : " text+C " ,
" cxtext " : " text+Cx " ,
" ktext " : " text+k " ,
" kxtext " : " text+kx " ,
" ltext " : " text+F " ,
" tempobj " : " binary+FSw " ,
" ubinary " : " binary+F " ,
" uresource " : " resource+F " ,
" uxbinary " : " binary+Fx " ,
" xbinary " : " binary+x " ,
" xltext " : " text+Fx " ,
" xtempobj " : " binary+Swx " ,
" xtext " : " text+x " ,
" xunicode " : " unicode+x " ,
" xutf16 " : " utf16+x " ,
}
if p4type in p4_filetypes_historical :
p4type = p4_filetypes_historical [ p4type ]
mods = " "
s = p4type . split ( " + " )
base = s [ 0 ]
mods = " "
if len ( s ) > 1 :
mods = s [ 1 ]
return ( base , mods )
2007-09-20 04:12:48 +08:00
2022-04-01 22:24:43 +08:00
2014-01-22 07:16:45 +08:00
def p4_type ( f ) :
2022-04-01 22:24:47 +08:00
""" Return the raw p4 type of a file (text, text+ko, etc). """
2014-01-22 07:16:45 +08:00
results = p4CmdList ( [ " fstat " , " -T " , " headType " , wildcard_encode ( f ) ] )
2012-02-23 15:51:30 +08:00
return results [ 0 ] [ ' headType ' ]
2022-04-01 22:24:43 +08:00
2012-02-23 15:51:30 +08:00
def p4_keywords_regexp_for_type ( base , type_mods ) :
2022-04-01 22:24:47 +08:00
""" Given a type base and modifier, return a regexp matching the keywords
that can be expanded in the file .
"""
2012-02-23 15:51:30 +08:00
if base in ( " text " , " unicode " , " binary " ) :
if " ko " in type_mods :
2021-12-16 21:46:16 +08:00
return re_ko_keywords
2012-02-23 15:51:30 +08:00
elif " k " in type_mods :
2021-12-16 21:46:16 +08:00
return re_k_keywords
2012-02-23 15:51:30 +08:00
else :
return None
else :
return None
2022-04-01 22:24:43 +08:00
2012-02-23 15:51:30 +08:00
def p4_keywords_regexp_for_file ( file ) :
2022-04-01 22:24:47 +08:00
""" Given a file, return a regexp matching the possible RCS keywords that
will be expanded , or None for files with kw expansion turned off .
"""
2012-02-23 15:51:30 +08:00
if not os . path . exists ( file ) :
return None
else :
2022-04-01 22:24:52 +08:00
type_base , type_mods = split_p4_type ( p4_type ( file ) )
2012-02-23 15:51:30 +08:00
return p4_keywords_regexp_for_type ( type_base , type_mods )
2007-09-20 04:12:48 +08:00
2022-04-01 22:24:43 +08:00
2007-11-02 11:43:14 +08:00
def setP4ExecBit ( file , mode ) :
2022-04-01 22:24:47 +08:00
""" Reopens an already open file and changes the execute bit to match the
execute bit setting in the passed in mode .
"""
2007-11-02 11:43:14 +08:00
p4Type = " +x "
if not isModeExec ( mode ) :
p4Type = getP4OpenedType ( file )
p4Type = re . sub ( ' ^([cku]?)x(.*) ' , ' \\ 1 \\ 2 ' , p4Type )
p4Type = re . sub ( ' (.*? \ +.*?)x(.*?) ' , ' \\ 1 \\ 2 ' , p4Type )
if p4Type [ - 1 ] == " + " :
p4Type = p4Type [ 0 : - 1 ]
2011-10-16 22:47:52 +08:00
p4_reopen ( p4Type , file )
2007-11-02 11:43:14 +08:00
2022-04-01 22:24:43 +08:00
2007-11-02 11:43:14 +08:00
def getP4OpenedType ( file ) :
2022-04-01 22:24:47 +08:00
""" Returns the perforce file type for the given file. """
2007-11-02 11:43:14 +08:00
2012-04-30 08:57:17 +08:00
result = p4_read_pipe ( [ " opened " , wildcard_encode ( file ) ] )
2015-04-04 16:46:03 +08:00
match = re . match ( " .* \ ((.+) \ )( \ *exclusive \ *)? \r ?$ " , result )
2007-11-02 11:43:14 +08:00
if match :
return match . group ( 1 )
else :
2008-03-28 22:40:40 +08:00
die ( " Could not determine file type for %s (result: ' %s ' ) " % ( file , result ) )
2007-11-02 11:43:14 +08:00
2022-04-01 22:24:43 +08:00
2012-04-11 23:21:24 +08:00
def getP4Labels ( depotPaths ) :
2022-04-01 22:24:47 +08:00
""" Return the set of all p4 labels. """
2012-04-11 23:21:24 +08:00
labels = set ( )
git-p4: change the expansion test from basestring to list
Python 3 handles strings differently than Python 2.7. Since Python 2
is reaching it's end of life, a series of changes are being submitted to
enable python 3.5 and following support. The current code fails basic
tests under python 3.5.
Some codepaths can represent a command line the program
internally prepares to execute either as a single string
(i.e. each token properly quoted, concatenated with $IFS) or
as a list of argv[] elements, and there are 9 places where
we say "if X is isinstance(_, basestring), then do this
thing to handle X as a command line in a single string; if
not, X is a command line in a list form".
This does not work well with Python 3, as there is no
basestring (everything is Unicode now), and even with Python
2, it was not an ideal way to tell the two cases apart,
because an internally formed command line could have been in
a single Unicode string.
Flip the check to say "if X is not a list, then handle X as
a command line in a single string; otherwise treat it as a
command line in a list form".
This will get rid of references to 'basestring', to migrate
the code ready for Python 3.
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Ben Keene <seraphire@gmail.com>
Signed-off-by: Yang Zhao <yang.zhao@skyboxlabs.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-12-14 07:52:36 +08:00
if not isinstance ( depotPaths , list ) :
2012-04-11 23:21:24 +08:00
depotPaths = [ depotPaths ]
for l in p4CmdList ( [ " labels " ] + [ " %s ... " % p for p in depotPaths ] ) :
label = l [ ' label ' ]
labels . add ( label )
return labels
2022-04-01 22:24:43 +08:00
2012-04-11 23:21:24 +08:00
def getGitTags ( ) :
2022-04-01 22:24:47 +08:00
""" Return the set of all git tags. """
2012-04-11 23:21:24 +08:00
gitTags = set ( )
for line in read_pipe_lines ( [ " git " , " tag " ] ) :
tag = line . strip ( )
gitTags . add ( tag )
return gitTags
2022-04-01 22:24:43 +08:00
2019-12-14 07:52:46 +08:00
_diff_tree_pattern = None
2007-11-02 11:43:13 +08:00
2022-04-01 22:24:43 +08:00
2007-11-02 11:43:13 +08:00
def parseDiffTreeEntry ( entry ) :
""" Parses a single diff tree entry into its component elements.
2022-04-01 22:24:46 +08:00
See git - diff - tree ( 1 ) manpage for details about the format of the diff
output . This method returns a dictionary with the following elements :
src_mode - The mode of the source file
dst_mode - The mode of the destination file
src_sha1 - The sha1 for the source file
dst_sha1 - The sha1 fr the destination file
status - The one letter status of the diff ( i . e . ' A ' , ' M ' , ' D ' , etc )
status_score - The score for the status ( applicable for ' C ' and ' R '
statuses ) . This is None if there is no score .
src - The path for the source file .
dst - The path for the destination file . This is only present for
copy or renames . If it is not present , this is None .
If the pattern is not matched , None is returned .
"""
2007-11-02 11:43:13 +08:00
2019-12-14 07:52:46 +08:00
global _diff_tree_pattern
if not _diff_tree_pattern :
_diff_tree_pattern = re . compile ( ' :( \ d+) ( \ d+) ( \ w+) ( \ w+) ([A-Z])( \ d+)? \t (.*?)(( \t (.*))|$) ' )
match = _diff_tree_pattern . match ( entry )
2007-11-02 11:43:13 +08:00
if match :
return {
' src_mode ' : match . group ( 1 ) ,
' dst_mode ' : match . group ( 2 ) ,
' src_sha1 ' : match . group ( 3 ) ,
' dst_sha1 ' : match . group ( 4 ) ,
' status ' : match . group ( 5 ) ,
' status_score ' : match . group ( 6 ) ,
' src ' : match . group ( 7 ) ,
' dst ' : match . group ( 10 )
}
return None
2022-04-01 22:24:43 +08:00
2007-11-02 11:43:14 +08:00
def isModeExec ( mode ) :
2022-04-01 22:24:47 +08:00
""" Returns True if the given git mode represents an executable file,
otherwise False .
"""
2007-11-02 11:43:14 +08:00
return mode [ - 3 : ] == " 755 "
2022-04-01 22:24:43 +08:00
2018-06-09 04:32:46 +08:00
class P4Exception ( Exception ) :
2022-04-01 22:24:46 +08:00
""" Base class for exceptions from the p4 client. """
2022-04-01 22:24:43 +08:00
2018-06-09 04:32:46 +08:00
def __init__ ( self , exit_code ) :
self . p4ExitCode = exit_code
2022-04-01 22:24:43 +08:00
2018-06-09 04:32:46 +08:00
class P4ServerException ( P4Exception ) :
2022-04-01 22:24:46 +08:00
""" Base class for exceptions where we get some kind of marshalled up result
from the server .
"""
2022-04-01 22:24:43 +08:00
2018-06-09 04:32:46 +08:00
def __init__ ( self , exit_code , p4_result ) :
super ( P4ServerException , self ) . __init__ ( exit_code )
self . p4_result = p4_result
self . code = p4_result [ 0 ] [ ' code ' ]
self . data = p4_result [ 0 ] [ ' data ' ]
2022-04-01 22:24:43 +08:00
2018-06-09 04:32:46 +08:00
class P4RequestSizeException ( P4ServerException ) :
2022-04-01 22:24:46 +08:00
""" One of the maxresults or maxscanrows errors. """
2022-04-01 22:24:43 +08:00
2018-06-09 04:32:46 +08:00
def __init__ ( self , exit_code , p4_result , limit ) :
super ( P4RequestSizeException , self ) . __init__ ( exit_code , p4_result )
self . limit = limit
2022-04-01 22:24:43 +08:00
2020-01-29 19:12:42 +08:00
class P4CommandException ( P4Exception ) :
2022-04-01 22:24:46 +08:00
""" Something went wrong calling p4 which means we have to give up. """
2022-04-01 22:24:43 +08:00
2020-01-29 19:12:42 +08:00
def __init__ ( self , msg ) :
self . msg = msg
def __str__ ( self ) :
return self . msg
2022-04-01 22:24:43 +08:00
2007-11-02 11:43:14 +08:00
def isModeExecChanged ( src_mode , dst_mode ) :
return isModeExec ( src_mode ) != isModeExec ( dst_mode )
2022-04-01 22:24:43 +08:00
2022-07-21 17:07:20 +08:00
def p4KeysContainingNonUtf8Chars ( ) :
""" Returns all keys which may contain non UTF-8 encoded strings
for which a fallback strategy has to be applied .
"""
return [ ' desc ' , ' client ' , ' FullName ' ]
def p4KeysContainingBinaryData ( ) :
""" Returns all keys which may contain arbitrary binary data
"""
return [ ' data ' ]
def p4KeyContainsFilePaths ( key ) :
""" Returns True if the key contains file paths. These are handled by decode_path().
Otherwise False .
"""
return key . startswith ( ' depotFile ' ) or key in [ ' path ' , ' clientFile ' ]
def p4KeyWhichCanBeDirectlyDecoded ( key ) :
""" Returns True if the key can be directly decoded as UTF-8 string
Otherwise False .
Keys which can not be encoded directly :
- ` data ` which may contain arbitrary binary data
- ` desc ` or ` client ` or ` FullName ` which may contain non - UTF8 encoded text
- ` depotFile [ 0 - 9 ] * ` , ` path ` , or ` clientFile ` which may contain non - UTF8 encoded text , handled by decode_path ( )
"""
if key in p4KeysContainingNonUtf8Chars ( ) or \
key in p4KeysContainingBinaryData ( ) or \
p4KeyContainsFilePaths ( key ) :
return False
return True
2018-06-09 04:32:46 +08:00
def p4CmdList ( cmd , stdin = None , stdin_mode = ' w+b ' , cb = None , skip_info = False ,
2022-01-07 05:40:33 +08:00
errors_as_exceptions = False , * k , * * kw ) :
2011-10-16 22:47:52 +08:00
2022-01-07 05:40:34 +08:00
cmd = p4_build_cmd ( [ " -G " ] + cmd )
2007-05-24 05:49:35 +08:00
if verbose :
2022-01-07 05:40:35 +08:00
sys . stderr . write ( " Opening pipe: {} \n " . format ( ' ' . join ( cmd ) ) )
2007-07-16 11:58:10 +08:00
# Use a temporary file to avoid deadlocks without
# subprocess.communicate(), which would put another copy
# of stdout into memory.
stdin_file = None
if stdin is not None :
stdin_file = tempfile . TemporaryFile ( prefix = ' p4-stdin ' , mode = stdin_mode )
git-p4: change the expansion test from basestring to list
Python 3 handles strings differently than Python 2.7. Since Python 2
is reaching it's end of life, a series of changes are being submitted to
enable python 3.5 and following support. The current code fails basic
tests under python 3.5.
Some codepaths can represent a command line the program
internally prepares to execute either as a single string
(i.e. each token properly quoted, concatenated with $IFS) or
as a list of argv[] elements, and there are 9 places where
we say "if X is isinstance(_, basestring), then do this
thing to handle X as a command line in a single string; if
not, X is a command line in a list form".
This does not work well with Python 3, as there is no
basestring (everything is Unicode now), and even with Python
2, it was not an ideal way to tell the two cases apart,
because an internally formed command line could have been in
a single Unicode string.
Flip the check to say "if X is not a list, then handle X as
a command line in a single string; otherwise treat it as a
command line in a list form".
This will get rid of references to 'basestring', to migrate
the code ready for Python 3.
Thanks-to: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Ben Keene <seraphire@gmail.com>
Signed-off-by: Yang Zhao <yang.zhao@skyboxlabs.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-12-14 07:52:36 +08:00
if not isinstance ( stdin , list ) :
2011-10-16 22:47:52 +08:00
stdin_file . write ( stdin )
else :
for i in stdin :
2019-12-14 07:52:39 +08:00
stdin_file . write ( encode_text_stream ( i ) )
stdin_file . write ( b ' \n ' )
2007-07-16 11:58:10 +08:00
stdin_file . flush ( )
stdin_file . seek ( 0 )
2022-01-07 05:40:33 +08:00
p4 = subprocess . Popen (
cmd , stdin = stdin_file , stdout = subprocess . PIPE , * k , * * kw )
2007-03-20 03:59:12 +08:00
result = [ ]
try :
while True :
2007-07-16 11:58:10 +08:00
entry = marshal . load ( p4 . stdout )
2022-07-21 17:07:20 +08:00
2019-12-14 07:52:38 +08:00
if bytes is not str :
2022-07-21 17:07:20 +08:00
# Decode unmarshalled dict to use str keys and values. Special cases are handled below.
2019-12-14 07:52:38 +08:00
decoded_entry = { }
for key , value in entry . items ( ) :
key = key . decode ( )
2022-07-21 17:07:20 +08:00
if isinstance ( value , bytes ) and p4KeyWhichCanBeDirectlyDecoded ( key ) :
2019-12-14 07:52:38 +08:00
value = value . decode ( )
decoded_entry [ key ] = value
# Parse out data if it's an error response
if decoded_entry . get ( ' code ' ) == ' error ' and ' data ' in decoded_entry :
decoded_entry [ ' data ' ] = decoded_entry [ ' data ' ] . decode ( )
entry = decoded_entry
2017-07-13 15:00:35 +08:00
if skip_info :
if ' code ' in entry and entry [ ' code ' ] == ' info ' :
continue
2022-07-21 17:07:20 +08:00
for key in p4KeysContainingNonUtf8Chars ( ) :
if key in entry :
entry [ key ] = metadata_stream_to_writable_bytes ( entry [ key ] )
2011-04-07 14:01:21 +08:00
if cb is not None :
cb ( entry )
else :
result . append ( entry )
2007-03-20 03:59:12 +08:00
except EOFError :
pass
2007-07-16 11:58:10 +08:00
exitCode = p4 . wait ( )
if exitCode != 0 :
2018-06-09 04:32:46 +08:00
if errors_as_exceptions :
if len ( result ) > 0 :
data = result [ 0 ] . get ( ' data ' )
if data :
m = re . search ( ' Too many rows scanned \ (over ( \ d+) \ ) ' , data )
if not m :
m = re . search ( ' Request too large \ (over ( \ d+) \ ) ' , data )
if m :
limit = int ( m . group ( 1 ) )
raise P4RequestSizeException ( exitCode , result , limit )
raise P4ServerException ( exitCode , result )
else :
raise P4Exception ( exitCode )
else :
entry = { }
entry [ " p4ExitCode " ] = exitCode
result . append ( entry )
2007-03-20 03:59:12 +08:00
return result
2022-04-01 22:24:43 +08:00
2022-01-07 05:40:33 +08:00
def p4Cmd ( cmd , * k , * * kw ) :
list = p4CmdList ( cmd , * k , * * kw )
2007-03-20 03:59:12 +08:00
result = { }
for entry in list :
result . update ( entry )
2022-04-01 22:24:44 +08:00
return result
2007-03-20 03:59:12 +08:00
2022-04-01 22:24:43 +08:00
2007-03-24 16:15:11 +08:00
def p4Where ( depotPath ) :
if not depotPath . endswith ( " / " ) :
depotPath + = " / "
2015-04-22 06:49:30 +08:00
depotPathLong = depotPath + " ... "
outputList = p4CmdList ( [ " where " , depotPathLong ] )
2008-12-04 21:37:33 +08:00
output = None
for entry in outputList :
2008-12-09 23:41:50 +08:00
if " depotFile " in entry :
2015-04-22 06:49:30 +08:00
# Search for the base client side depot path, as long as it starts with the branch's P4 path.
# The base path always ends with "/...".
2019-12-14 07:52:40 +08:00
entry_path = decode_path ( entry [ ' depotFile ' ] )
if entry_path . find ( depotPath ) == 0 and entry_path [ - 4 : ] == " /... " :
2008-12-09 23:41:50 +08:00
output = entry
break
elif " data " in entry :
data = entry . get ( " data " )
space = data . find ( " " )
if data [ : space ] == depotPath :
output = entry
break
2022-04-01 22:25:00 +08:00
if output is None :
2008-12-04 21:37:33 +08:00
return " "
2007-05-21 15:34:56 +08:00
if output [ " code " ] == " error " :
return " "
2007-03-24 16:15:11 +08:00
clientPath = " "
if " path " in output :
2019-12-14 07:52:40 +08:00
clientPath = decode_path ( output [ ' path ' ] )
2007-03-24 16:15:11 +08:00
elif " data " in output :
data = output . get ( " data " )
2019-12-14 07:52:40 +08:00
lastSpace = data . rfind ( b " " )
clientPath = decode_path ( data [ lastSpace + 1 : ] )
2007-03-24 16:15:11 +08:00
if clientPath . endswith ( " ... " ) :
clientPath = clientPath [ : - 3 ]
return clientPath
2022-04-01 22:24:43 +08:00
2007-03-20 03:59:12 +08:00
def currentGitBranch ( ) :
2017-04-15 18:36:09 +08:00
return read_pipe_text ( [ " git " , " symbolic-ref " , " --short " , " -q " , " HEAD " ] )
2007-03-20 03:59:12 +08:00
2022-04-01 22:24:43 +08:00
2007-03-20 05:25:17 +08:00
def isValidGitDir ( path ) :
2022-04-01 22:25:00 +08:00
return git_dir ( path ) is not None
2007-03-20 05:25:17 +08:00
2022-04-01 22:24:43 +08:00
2007-05-17 15:13:54 +08:00
def parseRevision ( ref ) :
2022-01-07 05:40:34 +08:00
return read_pipe ( [ " git " , " rev-parse " , ref ] ) . strip ( )
2007-05-17 15:13:54 +08:00
2022-04-01 22:24:43 +08:00
2011-12-25 10:07:40 +08:00
def branchExists ( ref ) :
rev = read_pipe ( [ " git " , " rev-parse " , " -q " , " --verify " , ref ] ,
ignore_error = True )
return len ( rev ) > 0
2022-04-01 22:24:43 +08:00
2007-03-23 04:10:25 +08:00
def extractLogMessageFromGitCommit ( commit ) :
logMessage = " "
2007-05-24 04:10:46 +08:00
2022-04-01 22:24:57 +08:00
# fixme: title is first line of commit, not 1st paragraph.
2007-03-23 04:10:25 +08:00
foundTitle = False
2019-05-29 02:15:46 +08:00
for log in read_pipe_lines ( [ " git " , " cat-file " , " commit " , commit ] ) :
2022-04-01 22:24:45 +08:00
if not foundTitle :
if len ( log ) == 1 :
foundTitle = True
continue
2007-03-23 04:10:25 +08:00
2022-04-01 22:24:45 +08:00
logMessage + = log
2007-03-23 04:10:25 +08:00
return logMessage
2022-04-01 22:24:43 +08:00
2007-05-24 05:49:35 +08:00
def extractSettingsGitLog ( log ) :
2007-03-23 04:10:25 +08:00
values = { }
for line in log . split ( " \n " ) :
line = line . strip ( )
2022-04-01 22:24:54 +08:00
m = re . search ( r " ^ * \ [git-p4: (.*) \ ]$ " , line )
2007-05-24 05:49:35 +08:00
if not m :
continue
2022-04-01 22:24:54 +08:00
assignments = m . group ( 1 ) . split ( ' : ' )
2007-05-24 05:49:35 +08:00
for a in assignments :
2022-04-01 22:24:54 +08:00
vals = a . split ( ' = ' )
2007-05-24 05:49:35 +08:00
key = vals [ 0 ] . strip ( )
2022-04-01 22:24:54 +08:00
val = ( ' = ' . join ( vals [ 1 : ] ) ) . strip ( )
if val . endswith ( ' \" ' ) and val . startswith ( ' " ' ) :
2007-05-24 05:49:35 +08:00
val = val [ 1 : - 1 ]
values [ key ] = val
2007-06-07 15:19:34 +08:00
paths = values . get ( " depot-paths " )
if not paths :
paths = values . get ( " depot-path " )
2007-06-08 04:54:32 +08:00
if paths :
values [ ' depot-paths ' ] = paths . split ( ' , ' )
2007-05-24 05:49:35 +08:00
return values
2007-03-23 04:10:25 +08:00
2022-04-01 22:24:43 +08:00
2007-03-23 04:27:14 +08:00
def gitBranchExists ( branch ) :
2007-05-24 05:49:35 +08:00
proc = subprocess . Popen ( [ " git " , " rev-parse " , branch ] ,
2022-04-01 22:24:44 +08:00
stderr = subprocess . PIPE , stdout = subprocess . PIPE )
return proc . wait ( ) == 0
2007-03-23 04:27:14 +08:00
2022-04-01 22:24:43 +08:00
2018-05-24 06:20:26 +08:00
def gitUpdateRef ( ref , newvalue ) :
subprocess . check_call ( [ " git " , " update-ref " , ref , newvalue ] )
2022-04-01 22:24:43 +08:00
2018-05-24 06:20:26 +08:00
def gitDeleteRef ( ref ) :
subprocess . check_call ( [ " git " , " update-ref " , " -d " , ref ] )
2022-04-01 22:24:43 +08:00
2008-11-08 11:22:49 +08:00
_gitConfig = { }
2013-01-27 11:11:23 +08:00
2022-04-01 22:24:43 +08:00
2015-09-26 15:54:58 +08:00
def gitConfig ( key , typeSpecifier = None ) :
2018-06-19 16:04:07 +08:00
if key not in _gitConfig :
2022-04-01 22:24:50 +08:00
cmd = [ " git " , " config " ]
2015-09-26 15:54:58 +08:00
if typeSpecifier :
2022-04-01 22:24:50 +08:00
cmd + = [ typeSpecifier ]
cmd + = [ key ]
2013-01-27 11:11:23 +08:00
s = read_pipe ( cmd , ignore_error = True )
_gitConfig [ key ] = s . strip ( )
2008-11-08 11:22:49 +08:00
return _gitConfig [ key ]
2007-05-25 16:36:10 +08:00
2022-04-01 22:24:43 +08:00
2013-01-27 11:11:24 +08:00
def gitConfigBool ( key ) :
""" Return a bool, using git config --bool. It is True only if the
variable is set to true , and False if set to false or not present
2022-04-01 22:24:46 +08:00
in the config .
"""
2013-01-27 11:11:24 +08:00
2018-06-19 16:04:07 +08:00
if key not in _gitConfig :
2015-09-26 15:54:58 +08:00
_gitConfig [ key ] = gitConfig ( key , ' --bool ' ) == " true "
2008-11-08 11:22:49 +08:00
return _gitConfig [ key ]
2007-05-25 16:36:10 +08:00
2022-04-01 22:24:43 +08:00
2015-09-26 15:54:59 +08:00
def gitConfigInt ( key ) :
2018-06-19 16:04:07 +08:00
if key not in _gitConfig :
2022-04-01 22:24:50 +08:00
cmd = [ " git " , " config " , " --int " , key ]
2013-01-27 11:11:24 +08:00
s = read_pipe ( cmd , ignore_error = True )
v = s . strip ( )
2015-09-26 15:54:59 +08:00
try :
_gitConfig [ key ] = int ( gitConfig ( key , ' --int ' ) )
except ValueError :
_gitConfig [ key ] = None
2008-11-08 11:22:49 +08:00
return _gitConfig [ key ]
2007-05-25 16:36:10 +08:00
2022-04-01 22:24:43 +08:00
2011-08-19 07:44:05 +08:00
def gitConfigList ( key ) :
2018-06-19 16:04:07 +08:00
if key not in _gitConfig :
2013-01-27 11:11:22 +08:00
s = read_pipe ( [ " git " , " config " , " --get-all " , key ] , ignore_error = True )
2017-01-25 17:17:29 +08:00
_gitConfig [ key ] = s . strip ( ) . splitlines ( )
2015-09-26 15:55:00 +08:00
if _gitConfig [ key ] == [ ' ' ] :
_gitConfig [ key ] = [ ]
2011-08-19 07:44:05 +08:00
return _gitConfig [ key ]
git-p4: support explicit sync of arbitrary existing git-p4 refs
With the --branch argument of the "sync" subcommand, git-p4 enables
you to import a perforce branch/path to an arbitrary git ref, using
a full ref path, or to refs/remotes/p4/* or refs/heads/p4/*,
depending on --import-local, using a short ref name.
However, when you later want to explicitly sync such a given ref to
pick up subsequent p4 changes, it only works if the ref was placed
in the p4 path *and* has only one path component (no "/").
This limitation results from a bad assumption in the
existing-branch sync logic, and also means you cannot individually
sync branches detected by --detect-branches, as these also get a
"/" in their names.
Fix "git p4 sync --branch", when called with an existing ref, so
that it works correctly regardless of whether the ref is in the p4
path or not, and (in the case of refs in the p4 path) regardless of
whether it has a "/" in its short name or not.
Also add tests to validate that these branch-specific syncs work
as expected.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-04-04 13:10:54 +08:00
def fullP4Ref ( incomingRef , importIntoRemotes = True ) :
""" Standardize a given provided p4 ref value to a full git ref:
refs / foo / bar / branch - > use it exactly
p4 / branch - > prepend refs / remotes / or refs / heads /
branch - > prepend refs / remotes / p4 / or refs / heads / p4 / """
if incomingRef . startswith ( " refs/ " ) :
return incomingRef
if importIntoRemotes :
prepend = " refs/remotes/ "
else :
prepend = " refs/heads/ "
if not incomingRef . startswith ( " p4/ " ) :
prepend + = " p4/ "
return prepend + incomingRef
def shortP4Ref ( incomingRef , importIntoRemotes = True ) :
""" Standardize to a " short ref " if possible:
refs / foo / bar / branch - > ignore
refs / remotes / p4 / branch or refs / heads / p4 / branch - > shorten
p4 / branch - > shorten """
if importIntoRemotes :
longprefix = " refs/remotes/p4/ "
else :
longprefix = " refs/heads/p4/ "
if incomingRef . startswith ( longprefix ) :
return incomingRef [ len ( longprefix ) : ]
if incomingRef . startswith ( " p4/ " ) :
return incomingRef [ 3 : ]
return incomingRef
2022-04-01 22:24:43 +08:00
2013-01-15 08:46:57 +08:00
def p4BranchesInGit ( branchesAreInRemotes = True ) :
""" Find all the branches whose names start with " p4/ " , looking
in remotes or heads as specified by the argument . Return
a dictionary of { branch : revision } for each one found .
The branch names are the short names , without any
2022-04-01 22:24:46 +08:00
" p4/ " prefix .
"""
2013-01-15 08:46:57 +08:00
2007-07-18 16:56:31 +08:00
branches = { }
2022-01-07 05:40:34 +08:00
cmdline = [ " git " , " rev-parse " , " --symbolic " ]
2007-07-18 16:56:31 +08:00
if branchesAreInRemotes :
2022-01-07 05:40:34 +08:00
cmdline . append ( " --remotes " )
2007-07-18 16:56:31 +08:00
else :
2022-01-07 05:40:34 +08:00
cmdline . append ( " --branches " )
2007-07-18 16:56:31 +08:00
for line in read_pipe_lines ( cmdline ) :
line = line . strip ( )
2013-01-15 08:46:57 +08:00
# only import to p4/
if not line . startswith ( ' p4/ ' ) :
continue
# special symbolic ref to p4/master
if line == " p4/HEAD " :
2007-07-18 16:56:31 +08:00
continue
2013-01-15 08:46:57 +08:00
# strip off p4/ prefix
branch = line [ len ( " p4/ " ) : ]
2007-07-18 16:56:31 +08:00
branches [ branch ] = parseRevision ( line )
2013-01-15 08:46:57 +08:00
2007-07-18 16:56:31 +08:00
return branches
2022-04-01 22:24:43 +08:00
2013-01-15 08:47:05 +08:00
def branch_exists ( branch ) :
""" Make sure that the given ref name really exists. """
2022-04-01 22:24:50 +08:00
cmd = [ " git " , " rev-parse " , " --symbolic " , " --verify " , branch ]
2013-01-15 08:47:05 +08:00
p = subprocess . Popen ( cmd , stdout = subprocess . PIPE , stderr = subprocess . PIPE )
out , _ = p . communicate ( )
2019-12-14 07:52:38 +08:00
out = decode_text_stream ( out )
2013-01-15 08:47:05 +08:00
if p . returncode :
return False
# expect exactly one line of output: the branch name
return out . rstrip ( ) == branch
2022-04-01 22:24:43 +08:00
2022-04-01 22:24:51 +08:00
def findUpstreamBranchPoint ( head = " HEAD " ) :
2007-07-18 18:40:12 +08:00
branches = p4BranchesInGit ( )
# map from depot-path to branch name
branchByDepotPath = { }
for branch in branches . keys ( ) :
tip = branches [ branch ]
log = extractLogMessageFromGitCommit ( tip )
settings = extractSettingsGitLog ( log )
2018-06-19 16:04:07 +08:00
if " depot-paths " in settings :
2022-03-21 20:43:22 +08:00
git_branch = " remotes/p4/ " + branch
2007-07-18 18:40:12 +08:00
paths = " , " . join ( settings [ " depot-paths " ] )
2022-03-21 20:43:22 +08:00
branchByDepotPath [ paths ] = git_branch
if " change " in settings :
paths = paths + " ; " + settings [ " change " ]
branchByDepotPath [ paths ] = git_branch
2007-07-18 18:40:12 +08:00
2007-06-12 20:31:59 +08:00
settings = None
parent = 0
while parent < 65535 :
2007-06-22 06:01:57 +08:00
commit = head + " ~ %s " % parent
2007-06-12 20:31:59 +08:00
log = extractLogMessageFromGitCommit ( commit )
settings = extractSettingsGitLog ( log )
2018-06-19 16:04:07 +08:00
if " depot-paths " in settings :
2007-07-18 18:40:12 +08:00
paths = " , " . join ( settings [ " depot-paths " ] )
2022-03-21 20:43:22 +08:00
if " change " in settings :
expaths = paths + " ; " + settings [ " change " ]
if expaths in branchByDepotPath :
return [ branchByDepotPath [ expaths ] , settings ]
2018-06-19 16:04:07 +08:00
if paths in branchByDepotPath :
2007-07-18 18:40:12 +08:00
return [ branchByDepotPath [ paths ] , settings ]
2007-06-12 20:31:59 +08:00
2007-07-18 18:40:12 +08:00
parent = parent + 1
2007-06-12 20:31:59 +08:00
2007-07-18 18:40:12 +08:00
return [ " " , settings ]
2007-06-12 20:31:59 +08:00
2022-04-01 22:24:43 +08:00
2022-04-01 22:24:51 +08:00
def createOrUpdateBranchesFromOrigin ( localRefPrefix = " refs/remotes/p4/ " , silent = True ) :
2007-08-24 23:44:16 +08:00
if not silent :
2018-06-19 16:04:10 +08:00
print ( " Creating/updating branch(es) in %s based on origin branch(es) "
2007-08-24 23:44:16 +08:00
% localRefPrefix )
originPrefix = " origin/p4/ "
2022-01-07 05:40:34 +08:00
for line in read_pipe_lines ( [ " git " , " rev-parse " , " --symbolic " , " --remotes " ] ) :
2007-08-24 23:44:16 +08:00
line = line . strip ( )
if ( not line . startswith ( originPrefix ) ) or line . endswith ( " HEAD " ) :
continue
headName = line [ len ( originPrefix ) : ]
remoteHead = localRefPrefix + headName
originHead = line
original = extractSettingsGitLog ( extractLogMessageFromGitCommit ( originHead ) )
2022-04-01 22:24:59 +08:00
if ' depot-paths ' not in original or ' change ' not in original :
2007-08-24 23:44:16 +08:00
continue
update = False
if not gitBranchExists ( remoteHead ) :
if verbose :
2018-06-19 16:04:10 +08:00
print ( " creating %s " % remoteHead )
2007-08-24 23:44:16 +08:00
update = True
else :
settings = extractSettingsGitLog ( extractLogMessageFromGitCommit ( remoteHead ) )
2018-06-19 16:04:07 +08:00
if ' change ' in settings :
2007-08-24 23:44:16 +08:00
if settings [ ' depot-paths ' ] == original [ ' depot-paths ' ] :
originP4Change = int ( original [ ' change ' ] )
p4Change = int ( settings [ ' change ' ] )
if originP4Change > p4Change :
2018-06-19 16:04:10 +08:00
print ( " %s ( %s ) is newer than %s ( %s ). "
2007-08-24 23:44:16 +08:00
" Updating p4 branch from origin. "
% ( originHead , originP4Change ,
remoteHead , p4Change ) )
update = True
else :
2018-06-19 16:04:10 +08:00
print ( " Ignoring: %s was imported from %s while "
2007-08-24 23:44:16 +08:00
" %s was imported from %s "
% ( originHead , ' , ' . join ( original [ ' depot-paths ' ] ) ,
remoteHead , ' , ' . join ( settings [ ' depot-paths ' ] ) ) )
if update :
2022-01-07 05:40:34 +08:00
system ( [ " git " , " update-ref " , remoteHead , originHead ] )
2007-08-24 23:44:16 +08:00
2022-04-01 22:24:43 +08:00
2007-08-24 23:44:16 +08:00
def originP4BranchesExist ( ) :
2022-04-01 22:24:45 +08:00
return gitBranchExists ( " origin " ) or gitBranchExists ( " origin/p4 " ) or gitBranchExists ( " origin/p4/master " )
2007-08-24 23:44:16 +08:00
2015-06-10 15:30:59 +08:00
def p4ParseNumericChangeRange ( parts ) :
changeStart = int ( parts [ 0 ] [ 1 : ] )
if parts [ 1 ] == ' #head ' :
changeEnd = p4_last_change ( )
else :
changeEnd = int ( parts [ 1 ] )
return ( changeStart , changeEnd )
2022-04-01 22:24:43 +08:00
2015-06-10 15:30:59 +08:00
def chooseBlockSize ( blockSize ) :
if blockSize :
return blockSize
else :
return defaultBlockSize
2022-04-01 22:24:43 +08:00
2015-06-10 15:30:59 +08:00
def p4ChangesForPaths ( depotPaths , changeRange , requestedBlockSize ) :
2007-08-26 21:56:36 +08:00
assert depotPaths
2015-04-20 23:00:20 +08:00
2015-06-10 15:30:59 +08:00
# Parse the change range into start and end. Try to find integer
# revision ranges as these can be broken up into blocks to avoid
# hitting server-side limits (maxrows, maxscanresults). But if
# that doesn't work, fall back to using the raw revision specifier
# strings, without using block mode.
2015-04-20 23:00:20 +08:00
if changeRange is None or changeRange == ' ' :
2015-06-10 15:30:59 +08:00
changeStart = 1
changeEnd = p4_last_change ( )
block_size = chooseBlockSize ( requestedBlockSize )
2015-04-20 23:00:20 +08:00
else :
parts = changeRange . split ( ' , ' )
assert len ( parts ) == 2
2015-06-10 15:30:59 +08:00
try :
2022-04-01 22:24:52 +08:00
changeStart , changeEnd = p4ParseNumericChangeRange ( parts )
2015-06-10 15:30:59 +08:00
block_size = chooseBlockSize ( requestedBlockSize )
2018-06-09 04:32:47 +08:00
except ValueError :
2015-06-10 15:30:59 +08:00
changeStart = parts [ 0 ] [ 1 : ]
changeEnd = parts [ 1 ]
if requestedBlockSize :
die ( " cannot use --changes-block-size with non-numeric revisions " )
block_size = None
2007-08-26 21:56:36 +08:00
2016-12-18 06:11:23 +08:00
changes = set ( )
2015-04-20 23:00:20 +08:00
2015-12-19 17:39:40 +08:00
# Retrieve changes a block at a time, to prevent running
git-p4: auto-size the block
git-p4 originally would fetch changes in one query. On large repos this
could fail because of the limits that Perforce imposes on the number of
items returned and the number of queries in the database.
To fix this, git-p4 learned to query changes in blocks of 512 changes,
However, this can be very slow - if you have a few million changes,
with each chunk taking about a second, it can be an hour or so.
Although it's possible to tune this value manually with the
"--changes-block-size" option, it's far from obvious to ordinary users
that this is what needs doing.
This change alters the block size dynamically by looking for the
specific error messages returned from the Perforce server, and reducing
the block size if the error is seen, either to the limit reported by the
server, or to half the current block size.
That means we can start out with a very large block size, and then let
it automatically drop down to a value that works without error, while
still failing correctly if some other error occurs.
Signed-off-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-09 04:32:48 +08:00
# into a MaxResults/MaxScanRows error from the server. If
# we _do_ hit one of those errors, turn down the block size
2015-06-10 15:30:59 +08:00
2015-12-19 17:39:40 +08:00
while True :
cmd = [ ' changes ' ]
2015-06-10 15:30:59 +08:00
2015-12-19 17:39:40 +08:00
if block_size :
end = min ( changeEnd , changeStart + block_size )
revisionRange = " %d , %d " % ( changeStart , end )
else :
revisionRange = " %s , %s " % ( changeStart , changeEnd )
2015-06-10 15:30:59 +08:00
2015-12-19 17:39:40 +08:00
for p in depotPaths :
2015-06-10 15:30:59 +08:00
cmd + = [ " %s ...@ %s " % ( p , revisionRange ) ]
git-p4: auto-size the block
git-p4 originally would fetch changes in one query. On large repos this
could fail because of the limits that Perforce imposes on the number of
items returned and the number of queries in the database.
To fix this, git-p4 learned to query changes in blocks of 512 changes,
However, this can be very slow - if you have a few million changes,
with each chunk taking about a second, it can be an hour or so.
Although it's possible to tune this value manually with the
"--changes-block-size" option, it's far from obvious to ordinary users
that this is what needs doing.
This change alters the block size dynamically by looking for the
specific error messages returned from the Perforce server, and reducing
the block size if the error is seen, either to the limit reported by the
server, or to half the current block size.
That means we can start out with a very large block size, and then let
it automatically drop down to a value that works without error, while
still failing correctly if some other error occurs.
Signed-off-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-09 04:32:48 +08:00
# fetch the changes
try :
result = p4CmdList ( cmd , errors_as_exceptions = True )
except P4RequestSizeException as e :
if not block_size :
block_size = e . limit
elif block_size > e . limit :
block_size = e . limit
else :
block_size = max ( 2 , block_size / / 2 )
2022-04-01 22:25:03 +08:00
if verbose :
print ( " block size error, retrying with block size {0} " . format ( block_size ) )
git-p4: auto-size the block
git-p4 originally would fetch changes in one query. On large repos this
could fail because of the limits that Perforce imposes on the number of
items returned and the number of queries in the database.
To fix this, git-p4 learned to query changes in blocks of 512 changes,
However, this can be very slow - if you have a few million changes,
with each chunk taking about a second, it can be an hour or so.
Although it's possible to tune this value manually with the
"--changes-block-size" option, it's far from obvious to ordinary users
that this is what needs doing.
This change alters the block size dynamically by looking for the
specific error messages returned from the Perforce server, and reducing
the block size if the error is seen, either to the limit reported by the
server, or to half the current block size.
That means we can start out with a very large block size, and then let
it automatically drop down to a value that works without error, while
still failing correctly if some other error occurs.
Signed-off-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-09 04:32:48 +08:00
continue
except P4Exception as e :
die ( ' Error retrieving changes description ( {0} ) ' . format ( e . p4ExitCode ) )
2015-12-19 17:39:40 +08:00
# Insert changes in chronological order
git-p4: auto-size the block
git-p4 originally would fetch changes in one query. On large repos this
could fail because of the limits that Perforce imposes on the number of
items returned and the number of queries in the database.
To fix this, git-p4 learned to query changes in blocks of 512 changes,
However, this can be very slow - if you have a few million changes,
with each chunk taking about a second, it can be an hour or so.
Although it's possible to tune this value manually with the
"--changes-block-size" option, it's far from obvious to ordinary users
that this is what needs doing.
This change alters the block size dynamically by looking for the
specific error messages returned from the Perforce server, and reducing
the block size if the error is seen, either to the limit reported by the
server, or to half the current block size.
That means we can start out with a very large block size, and then let
it automatically drop down to a value that works without error, while
still failing correctly if some other error occurs.
Signed-off-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-09 04:32:48 +08:00
for entry in reversed ( result ) :
2018-06-19 16:04:07 +08:00
if ' change ' not in entry :
2017-07-13 15:00:34 +08:00
continue
changes . add ( int ( entry [ ' change ' ] ) )
2015-06-10 15:30:59 +08:00
2015-12-19 17:39:40 +08:00
if not block_size :
break
2015-06-10 15:30:59 +08:00
2015-12-19 17:39:40 +08:00
if end > = changeEnd :
break
2015-06-10 15:30:59 +08:00
2015-12-19 17:39:40 +08:00
changeStart = end + 1
2007-08-26 21:56:36 +08:00
2015-12-19 17:39:40 +08:00
changes = sorted ( changes )
return changes
2007-08-26 21:56:36 +08:00
2022-04-01 22:24:43 +08:00
2011-03-15 20:08:02 +08:00
def p4PathStartsWith ( path , prefix ) :
2022-04-01 22:24:47 +08:00
""" This method tries to remedy a potential mixed-case issue:
If UserA adds / / depot / DirA / file1
and UserB adds / / depot / dira / file2
we may or may not have a problem . If you have core . ignorecase = true ,
we treat DirA and dira as the same directory .
"""
2013-01-27 11:11:24 +08:00
if gitConfigBool ( " core.ignorecase " ) :
2011-03-15 20:08:02 +08:00
return path . lower ( ) . startswith ( prefix . lower ( ) )
return path . startswith ( prefix )
2022-04-01 22:24:43 +08:00
2012-02-26 09:06:25 +08:00
def getClientSpec ( ) :
""" Look at the p4 client spec, create a View() object that contains
2022-04-01 22:24:46 +08:00
all the mappings , and return it .
"""
2012-02-26 09:06:25 +08:00
2022-01-07 05:40:34 +08:00
specList = p4CmdList ( [ " client " , " -o " ] )
2012-02-26 09:06:25 +08:00
if len ( specList ) != 1 :
die ( ' Output from " client -o " is %d lines, expecting 1 ' %
len ( specList ) )
# dictionary of all client parameters
entry = specList [ 0 ]
2013-08-30 18:02:06 +08:00
# the //client/ name
client_name = entry [ " Client " ]
2012-02-26 09:06:25 +08:00
# just the keys that start with "View"
2022-04-01 22:24:50 +08:00
view_keys = [ k for k in entry . keys ( ) if k . startswith ( " View " ) ]
2012-02-26 09:06:25 +08:00
# hold this new View
2013-08-30 18:02:06 +08:00
view = View ( client_name )
2012-02-26 09:06:25 +08:00
# append the lines, in order, to the view
for view_num in range ( len ( view_keys ) ) :
k = " View %d " % view_num
if k not in view_keys :
die ( " Expected view key %s missing " % k )
view . append ( entry [ k ] )
return view
2022-04-01 22:24:43 +08:00
2012-02-26 09:06:25 +08:00
def getClientRoot ( ) :
""" Grab the client directory. """
2022-01-07 05:40:34 +08:00
output = p4CmdList ( [ " client " , " -o " ] )
2012-02-26 09:06:25 +08:00
if len ( output ) != 1 :
die ( ' Output from " client -o " is %d lines, expecting 1 ' % len ( output ) )
entry = output [ 0 ]
if " Root " not in entry :
die ( ' Client has no " Root " ' )
return entry [ " Root " ]
2022-04-01 22:24:43 +08:00
2012-04-30 08:57:17 +08:00
def wildcard_decode ( path ) :
2022-04-01 22:24:47 +08:00
""" Decode P4 wildcards into %x x encoding
P4 wildcards are not allowed in filenames . P4 complains if you simply
add them , but you can force it with " -f " , in which case it translates
them into % xx encoding internally .
"""
2012-04-30 08:57:17 +08:00
# Search for and fix just these four characters. Do % last so
# that fixing it does not inadvertently create new %-escapes.
# Cannot have * in a filename in windows; untested as to
# what p4 would do in such a case.
if not platform . system ( ) == " Windows " :
path = path . replace ( " % 2A " , " * " )
path = path . replace ( " % 23 " , " # " ) \
. replace ( " % 40 " , " @ " ) \
. replace ( " % 25 " , " % " )
return path
2022-04-01 22:24:43 +08:00
2012-04-30 08:57:17 +08:00
def wildcard_encode ( path ) :
2022-04-01 22:24:47 +08:00
""" Encode %x x coded wildcards into P4 coding. """
2012-04-30 08:57:17 +08:00
# do % first to avoid double-encoding the %s introduced here
path = path . replace ( " % " , " % 25 " ) \
. replace ( " * " , " % 2A " ) \
. replace ( " # " , " % 23 " ) \
. replace ( " @ " , " % 40 " )
return path
2022-04-01 22:24:43 +08:00
2012-04-30 08:57:17 +08:00
def wildcard_present ( path ) :
2013-01-27 03:14:32 +08:00
m = re . search ( " [*#@ % ] " , path )
return m is not None
2012-04-30 08:57:17 +08:00
2022-04-01 22:24:43 +08:00
2015-09-26 15:55:03 +08:00
class LargeFileSystem ( object ) :
""" Base class for large file system support. """
def __init__ ( self , writeToGitStream ) :
self . largeFiles = set ( )
self . writeToGitStream = writeToGitStream
def generatePointer ( self , cloneDestination , contentFile ) :
2022-04-01 22:24:46 +08:00
""" Return the content of a pointer file that is stored in Git instead
of the actual content .
"""
2015-09-26 15:55:03 +08:00
assert False , " Method ' generatePointer ' required in " + self . __class__ . __name__
def pushFile ( self , localLargeFile ) :
""" Push the actual content which is not stored in the Git repository to
2022-04-01 22:24:46 +08:00
a server .
"""
2015-09-26 15:55:03 +08:00
assert False , " Method ' pushFile ' required in " + self . __class__ . __name__
def hasLargeFileExtension ( self , relPath ) :
2019-12-14 07:52:44 +08:00
return functools . reduce (
2015-09-26 15:55:03 +08:00
lambda a , b : a or b ,
[ relPath . endswith ( ' . ' + e ) for e in gitConfigList ( ' git-p4.largeFileExtensions ' ) ] ,
False
)
def generateTempFile ( self , contents ) :
contentFile = tempfile . NamedTemporaryFile ( prefix = ' git-p4-large-file ' , delete = False )
for d in contents :
contentFile . write ( d )
contentFile . close ( )
return contentFile . name
def exceedsLargeFileThreshold ( self , relPath , contents ) :
if gitConfigInt ( ' git-p4.largeFileThreshold ' ) :
contentsSize = sum ( len ( d ) for d in contents )
if contentsSize > gitConfigInt ( ' git-p4.largeFileThreshold ' ) :
return True
if gitConfigInt ( ' git-p4.largeFileCompressedThreshold ' ) :
contentsSize = sum ( len ( d ) for d in contents )
if contentsSize < = gitConfigInt ( ' git-p4.largeFileCompressedThreshold ' ) :
return False
contentTempFile = self . generateTempFile ( contents )
2019-08-27 11:43:58 +08:00
compressedContentFile = tempfile . NamedTemporaryFile ( prefix = ' git-p4-large-file ' , delete = True )
with zipfile . ZipFile ( compressedContentFile , mode = ' w ' ) as zf :
zf . write ( contentTempFile , compress_type = zipfile . ZIP_DEFLATED )
compressedContentsSize = zf . infolist ( ) [ 0 ] . compress_size
2015-09-26 15:55:03 +08:00
os . remove ( contentTempFile )
if compressedContentsSize > gitConfigInt ( ' git-p4.largeFileCompressedThreshold ' ) :
return True
return False
def addLargeFile ( self , relPath ) :
self . largeFiles . add ( relPath )
def removeLargeFile ( self , relPath ) :
self . largeFiles . remove ( relPath )
def isLargeFile ( self , relPath ) :
return relPath in self . largeFiles
def processContent ( self , git_mode , relPath , contents ) :
""" Processes the content of git fast import. This method decides if a
file is stored in the large file system and handles all necessary
2022-04-01 22:24:46 +08:00
steps .
"""
2015-09-26 15:55:03 +08:00
if self . exceedsLargeFileThreshold ( relPath , contents ) or self . hasLargeFileExtension ( relPath ) :
contentTempFile = self . generateTempFile ( contents )
2022-04-01 22:24:52 +08:00
pointer_git_mode , contents , localLargeFile = self . generatePointer ( contentTempFile )
2016-12-05 00:03:37 +08:00
if pointer_git_mode :
git_mode = pointer_git_mode
if localLargeFile :
# Move temp file to final location in large file system
largeFileDir = os . path . dirname ( localLargeFile )
if not os . path . isdir ( largeFileDir ) :
os . makedirs ( largeFileDir )
shutil . move ( contentTempFile , localLargeFile )
self . addLargeFile ( relPath )
if gitConfigBool ( ' git-p4.largeFilePush ' ) :
self . pushFile ( localLargeFile )
if verbose :
sys . stderr . write ( " %s moved to large file system ( %s ) \n " % ( relPath , localLargeFile ) )
2015-09-26 15:55:03 +08:00
return ( git_mode , contents )
2022-04-01 22:24:43 +08:00
2015-09-26 15:55:03 +08:00
class MockLFS ( LargeFileSystem ) :
""" Mock large file system for testing. """
def generatePointer ( self , contentFile ) :
""" The pointer content is the original content prefixed with " pointer- " .
2022-04-01 22:24:46 +08:00
The local filename of the large file storage is derived from the
file content .
2015-09-26 15:55:03 +08:00
"""
with open ( contentFile , ' r ' ) as f :
content = next ( f )
gitMode = ' 100644 '
pointerContents = ' pointer- ' + content
localLargeFile = os . path . join ( os . getcwd ( ) , ' .git ' , ' mock-storage ' , ' local ' , content [ : - 1 ] )
return ( gitMode , pointerContents , localLargeFile )
def pushFile ( self , localLargeFile ) :
2022-04-01 22:24:46 +08:00
""" The remote filename of the large file storage is the same as the
local one but in a different directory .
2015-09-26 15:55:03 +08:00
"""
remotePath = os . path . join ( os . path . dirname ( localLargeFile ) , ' .. ' , ' remote ' )
if not os . path . exists ( remotePath ) :
os . makedirs ( remotePath )
shutil . copyfile ( localLargeFile , os . path . join ( remotePath , os . path . basename ( localLargeFile ) ) )
2022-04-01 22:24:43 +08:00
2015-09-26 15:55:04 +08:00
class GitLFS ( LargeFileSystem ) :
""" Git LFS as backend for the git-p4 large file system.
2022-04-01 22:24:46 +08:00
See https : / / git - lfs . github . com / for details .
"""
2015-09-26 15:55:04 +08:00
def __init__ ( self , * args ) :
LargeFileSystem . __init__ ( self , * args )
self . baseGitAttributes = [ ]
def generatePointer ( self , contentFile ) :
""" Generate a Git LFS pointer for the content. Return LFS Pointer file
mode and content which is stored in the Git repository instead of
the actual content . Return also the new location of the actual
content .
"""
2016-12-05 00:03:37 +08:00
if os . path . getsize ( contentFile ) == 0 :
return ( None , ' ' , None )
2015-09-26 15:55:04 +08:00
pointerProcess = subprocess . Popen (
[ ' git ' , ' lfs ' , ' pointer ' , ' --file= ' + contentFile ] ,
stdout = subprocess . PIPE
)
2019-12-14 07:52:39 +08:00
pointerFile = decode_text_stream ( pointerProcess . stdout . read ( ) )
2015-09-26 15:55:04 +08:00
if pointerProcess . wait ( ) :
os . remove ( contentFile )
die ( ' git-lfs pointer command failed. Did you install the extension? ' )
2016-04-28 14:26:33 +08:00
# Git LFS removed the preamble in the output of the 'pointer' command
# starting from version 1.2.0. Check for the preamble here to support
# earlier versions.
# c.f. https://github.com/github/git-lfs/commit/da2935d9a739592bc775c98d8ef4df9c72ea3b43
if pointerFile . startswith ( ' Git LFS pointer for ' ) :
pointerFile = re . sub ( r ' Git LFS pointer for.* \ n \ n ' , ' ' , pointerFile )
oid = re . search ( r ' ^oid \ w+:( \ w+) ' , pointerFile , re . MULTILINE ) . group ( 1 )
2019-12-12 01:47:23 +08:00
# if someone use external lfs.storage ( not in local repo git )
lfs_path = gitConfig ( ' lfs.storage ' )
if not lfs_path :
lfs_path = ' lfs '
if not os . path . isabs ( lfs_path ) :
lfs_path = os . path . join ( os . getcwd ( ) , ' .git ' , lfs_path )
2015-09-26 15:55:04 +08:00
localLargeFile = os . path . join (
2019-12-12 01:47:23 +08:00
lfs_path ,
' objects ' , oid [ : 2 ] , oid [ 2 : 4 ] ,
2015-09-26 15:55:04 +08:00
oid ,
)
# LFS Spec states that pointer files should not have the executable bit set.
gitMode = ' 100644 '
2016-04-28 14:26:33 +08:00
return ( gitMode , pointerFile , localLargeFile )
2015-09-26 15:55:04 +08:00
def pushFile ( self , localLargeFile ) :
uploadProcess = subprocess . Popen (
[ ' git ' , ' lfs ' , ' push ' , ' --object-id ' , ' origin ' , os . path . basename ( localLargeFile ) ]
)
if uploadProcess . wait ( ) :
die ( ' git-lfs push command failed. Did you define a remote? ' )
def generateGitAttributes ( self ) :
return (
self . baseGitAttributes +
[
' \n ' ,
' # \n ' ,
' # Git LFS (see https://git-lfs.github.com/) \n ' ,
' # \n ' ,
] +
2016-12-19 03:01:40 +08:00
[ ' *. ' + f . replace ( ' ' , ' [[:space:]] ' ) + ' filter=lfs diff=lfs merge=lfs -text \n '
2015-09-26 15:55:04 +08:00
for f in sorted ( gitConfigList ( ' git-p4.largeFileExtensions ' ) )
] +
2016-12-19 03:01:40 +08:00
[ ' / ' + f . replace ( ' ' , ' [[:space:]] ' ) + ' filter=lfs diff=lfs merge=lfs -text \n '
2015-09-26 15:55:04 +08:00
for f in sorted ( self . largeFiles ) if not self . hasLargeFileExtension ( f )
]
)
def addLargeFile ( self , relPath ) :
LargeFileSystem . addLargeFile ( self , relPath )
self . writeToGitStream ( ' 100644 ' , ' .gitattributes ' , self . generateGitAttributes ( ) )
def removeLargeFile ( self , relPath ) :
LargeFileSystem . removeLargeFile ( self , relPath )
self . writeToGitStream ( ' 100644 ' , ' .gitattributes ' , self . generateGitAttributes ( ) )
def processContent ( self , git_mode , relPath , contents ) :
if relPath == ' .gitattributes ' :
self . baseGitAttributes = contents
return ( git_mode , self . generateGitAttributes ( ) )
else :
return LargeFileSystem . processContent ( self , git_mode , relPath , contents )
2022-04-01 22:24:43 +08:00
2007-03-21 03:54:23 +08:00
class Command :
2022-04-01 22:24:50 +08:00
delete_actions = ( " delete " , " move/delete " , " purge " )
add_actions = ( " add " , " branch " , " move/add " )
2018-10-15 19:14:08 +08:00
2007-03-21 03:54:23 +08:00
def __init__ ( self ) :
self . usage = " usage: % prog [options] "
2007-03-26 14:18:55 +08:00
self . needsGit = True
2012-04-24 16:33:23 +08:00
self . verbose = False
2007-03-21 03:54:23 +08:00
2019-04-02 02:02:26 +08:00
# This is required for the "append" update_shelve action
2017-12-21 19:06:14 +08:00
def ensure_value ( self , attr , value ) :
if not hasattr ( self , attr ) or getattr ( self , attr ) is None :
setattr ( self , attr , value )
return getattr ( self , attr )
2022-04-01 22:24:43 +08:00
2011-04-22 03:50:23 +08:00
class P4UserMap :
def __init__ ( self ) :
self . userMapFromPerforceServer = False
2012-01-19 17:52:27 +08:00
self . myP4UserId = None
def p4UserId ( self ) :
if self . myP4UserId :
return self . myP4UserId
2022-01-07 05:40:34 +08:00
results = p4CmdList ( [ " user " , " -o " ] )
2012-01-19 17:52:27 +08:00
for r in results :
2018-06-19 16:04:07 +08:00
if ' User ' in r :
2012-01-19 17:52:27 +08:00
self . myP4UserId = r [ ' User ' ]
return r [ ' User ' ]
die ( " Could not find your p4 user id " )
def p4UserIsMe ( self , p4User ) :
2022-04-01 22:24:47 +08:00
""" Return True if the given p4 user is actually me. """
2012-01-19 17:52:27 +08:00
me = self . p4UserId ( )
if not p4User or p4User != me :
return False
else :
return True
2011-04-22 03:50:23 +08:00
def getUserCacheFilename ( self ) :
home = os . environ . get ( " HOME " , os . environ . get ( " USERPROFILE " ) )
return home + " /.gitp4-usercache.txt "
def getUserMapFromPerforceServer ( self ) :
if self . userMapFromPerforceServer :
return
self . users = { }
self . emails = { }
2022-01-07 05:40:34 +08:00
for output in p4CmdList ( [ " users " ] ) :
2018-06-19 16:04:07 +08:00
if " User " not in output :
2011-04-22 03:50:23 +08:00
continue
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
# "FullName" is bytes. "Email" on the other hand might be bytes
# or unicode string depending on whether we are running under
# python2 or python3. To support
# git-p4.metadataDecodingStrategy=fallback, self.users dict values
# are always bytes, ready to be written to git.
emailbytes = metadata_stream_to_writable_bytes ( output [ " Email " ] )
self . users [ output [ " User " ] ] = output [ " FullName " ] + b " < " + emailbytes + b " > "
2011-04-22 03:50:23 +08:00
self . emails [ output [ " Email " ] ] = output [ " User " ]
2016-03-01 18:49:56 +08:00
mapUserConfigRegex = re . compile ( r " ^ \ s*( \ S+) \ s*= \ s*(.+) \ s*<( \ S+)> \ s*$ " , re . VERBOSE )
for mapUserConfig in gitConfigList ( " git-p4.mapUser " ) :
mapUser = mapUserConfigRegex . findall ( mapUserConfig )
if mapUser and len ( mapUser [ 0 ] ) == 3 :
user = mapUser [ 0 ] [ 0 ]
fullname = mapUser [ 0 ] [ 1 ]
email = mapUser [ 0 ] [ 2 ]
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
fulluser = fullname + " < " + email + " > "
self . users [ user ] = metadata_stream_to_writable_bytes ( fulluser )
2016-03-01 18:49:56 +08:00
self . emails [ email ] = user
2011-04-22 03:50:23 +08:00
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
s = b ' '
2011-04-22 03:50:23 +08:00
for ( key , val ) in self . users . items ( ) :
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
keybytes = metadata_stream_to_writable_bytes ( key )
s + = b " %s \t %s \n " % ( keybytes . expandtabs ( 1 ) , val . expandtabs ( 1 ) )
2011-04-22 03:50:23 +08:00
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
open ( self . getUserCacheFilename ( ) , ' wb ' ) . write ( s )
2011-04-22 03:50:23 +08:00
self . userMapFromPerforceServer = True
def loadUserMapFromCache ( self ) :
self . users = { }
self . userMapFromPerforceServer = False
try :
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
cache = open ( self . getUserCacheFilename ( ) , ' rb ' )
2011-04-22 03:50:23 +08:00
lines = cache . readlines ( )
cache . close ( )
for line in lines :
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
entry = line . strip ( ) . split ( b " \t " )
self . users [ entry [ 0 ] . decode ( ' utf_8 ' ) ] = entry [ 1 ]
2011-04-22 03:50:23 +08:00
except IOError :
self . getUserMapFromPerforceServer ( )
2022-04-01 22:24:43 +08:00
2011-04-22 03:50:23 +08:00
class P4Submit ( Command , P4UserMap ) :
2012-09-10 04:16:13 +08:00
conflict_behavior_choices = ( " ask " , " skip " , " quit " )
2007-03-20 05:25:17 +08:00
def __init__ ( self ) :
2007-03-21 03:54:23 +08:00
Command . __init__ ( self )
2011-04-22 03:50:23 +08:00
P4UserMap . __init__ ( self )
2007-03-20 05:25:17 +08:00
self . options = [
optparse . make_option ( " --origin " , dest = " origin " ) ,
2011-02-20 09:18:24 +08:00
optparse . make_option ( " -M " , dest = " detectRenames " , action = " store_true " ) ,
2011-04-22 03:50:23 +08:00
# preserve the user, requires relevant p4 permissions
optparse . make_option ( " --preserve-user " , dest = " preserveUser " , action = " store_true " ) ,
2012-04-11 23:21:24 +08:00
optparse . make_option ( " --export-labels " , dest = " exportLabels " , action = " store_true " ) ,
2012-09-10 04:16:11 +08:00
optparse . make_option ( " --dry-run " , " -n " , dest = " dry_run " , action = " store_true " ) ,
2012-09-10 04:16:12 +08:00
optparse . make_option ( " --prepare-p4-only " , dest = " prepare_p4_only " , action = " store_true " ) ,
2012-09-10 04:16:13 +08:00
optparse . make_option ( " --conflict " , dest = " conflict_behavior " ,
2013-01-15 08:47:08 +08:00
choices = self . conflict_behavior_choices ) ,
optparse . make_option ( " --branch " , dest = " branch " ) ,
2016-11-28 17:33:18 +08:00
optparse . make_option ( " --shelve " , dest = " shelve " , action = " store_true " ,
help = " Shelve instead of submit. Shelved files are reverted, "
" restoring the workspace to the state before the shelve " ) ,
2017-12-21 19:06:14 +08:00
optparse . make_option ( " --update-shelve " , dest = " update_shelve " , action = " append " , type = " int " ,
2016-12-03 06:43:19 +08:00
metavar = " CHANGELIST " ,
2017-12-21 19:06:14 +08:00
help = " update an existing shelved changelist, implies --shelve, "
2018-06-01 15:46:14 +08:00
" repeat in-order for multiple shelved changelists " ) ,
optparse . make_option ( " --commit " , dest = " commit " , metavar = " COMMIT " ,
help = " submit only the specified commit(s), one commit or xxx..xxx " ) ,
optparse . make_option ( " --disable-rebase " , dest = " disable_rebase " , action = " store_true " ,
help = " Disable rebase after submit is completed. Can be useful if you "
2018-06-09 04:32:44 +08:00
" work from a local git branch that is not master " ) ,
optparse . make_option ( " --disable-p4sync " , dest = " disable_p4sync " , action = " store_true " ,
help = " Skip Perforce sync of p4/master after submit or shelve " ) ,
2020-02-12 02:58:01 +08:00
optparse . make_option ( " --no-verify " , dest = " no_verify " , action = " store_true " ,
2020-02-14 22:44:45 +08:00
help = " Bypass p4-pre-submit and p4-changelist hooks " ) ,
2007-03-20 05:25:17 +08:00
]
2018-07-27 19:22:22 +08:00
self . description = """ Submit changes from git to the perforce depot. \n
2020-02-12 02:58:01 +08:00
The ` p4 - pre - submit ` hook is executed if it exists and is executable . It
can be bypassed with the ` - - no - verify ` command line option . The hook takes
no parameters and nothing from standard input . Exiting with a non - zero status
from this script prevents ` git - p4 submit ` from launching .
2018-07-27 19:22:22 +08:00
2020-02-12 02:58:01 +08:00
One usage scenario is to run unit tests in the hook .
2020-02-14 22:44:45 +08:00
The ` p4 - prepare - changelist ` hook is executed right after preparing the default
changelist message and before the editor is started . It takes one parameter ,
the name of the file that contains the changelist text . Exiting with a non - zero
status from the script will abort the process .
The purpose of the hook is to edit the message file in place , and it is not
supressed by the ` - - no - verify ` option . This hook is called even if
` - - prepare - p4 - only ` is set .
The ` p4 - changelist ` hook is executed after the changelist message has been
edited by the user . It can be bypassed with the ` - - no - verify ` option . It
takes a single parameter , the name of the file that holds the proposed
changelist text . Exiting with a non - zero status causes the command to abort .
The hook is allowed to edit the changelist file and can be used to normalize
the text into some project standard format . It can also be used to refuse the
Submit after inspect the message file .
The ` p4 - post - changelist ` hook is invoked after the submit has successfully
2020-11-06 04:48:14 +08:00
occurred in P4 . It takes no parameters and is meant primarily for notification
2020-02-14 22:44:45 +08:00
and cannot affect the outcome of the git p4 submit action .
2020-02-12 02:58:01 +08:00
"""
2018-07-27 19:22:22 +08:00
2007-03-30 01:15:24 +08:00
self . usage + = " [name of git branch to submit into perforce depot] "
2007-03-23 16:16:07 +08:00
self . origin = " "
2011-02-20 09:18:24 +08:00
self . detectRenames = False
2013-01-27 11:11:24 +08:00
self . preserveUser = gitConfigBool ( " git-p4.preserveUser " )
2012-09-10 04:16:11 +08:00
self . dry_run = False
2016-11-28 17:33:18 +08:00
self . shelve = False
2017-12-21 19:06:14 +08:00
self . update_shelve = list ( )
2018-06-01 15:46:14 +08:00
self . commit = " "
2018-06-09 04:32:43 +08:00
self . disable_rebase = gitConfigBool ( " git-p4.disableRebase " )
2018-06-09 04:32:44 +08:00
self . disable_p4sync = gitConfigBool ( " git-p4.disableP4Sync " )
2012-09-10 04:16:12 +08:00
self . prepare_p4_only = False
2012-09-10 04:16:13 +08:00
self . conflict_behavior = None
2007-06-07 20:07:01 +08:00
self . isWindows = ( platform . system ( ) == " Windows " )
2012-04-11 23:21:24 +08:00
self . exportLabels = False
2012-11-24 06:35:35 +08:00
self . p4HasMoveCommand = p4_has_move_command ( )
2013-01-15 08:47:08 +08:00
self . branch = None
2020-02-12 02:58:01 +08:00
self . no_verify = False
2007-03-20 05:25:17 +08:00
2015-09-26 15:55:03 +08:00
if gitConfig ( ' git-p4.largeFileSystem ' ) :
die ( " Large file system not supported for git-p4 submit command. Please remove it from config. " )
2007-03-20 05:25:17 +08:00
def check ( self ) :
2022-01-07 05:40:34 +08:00
if len ( p4CmdList ( [ " opened " , " ... " ] ) ) > 0 :
2007-03-20 05:25:17 +08:00
die ( " You have files opened with perforce! Close them before starting the sync. " )
2012-07-04 21:34:20 +08:00
def separate_jobs_from_description ( self , message ) :
2022-04-01 22:24:46 +08:00
""" Extract and return a possible Jobs field in the commit message. It
goes into a separate section in the p4 change specification .
2012-07-04 21:34:20 +08:00
2022-04-01 22:24:46 +08:00
A jobs line starts with " Jobs: " and looks like a new field in a
form . Values are white - space separated on the same line or on
following lines that start with a tab .
2012-07-04 21:34:20 +08:00
2022-04-01 22:24:46 +08:00
This does not parse and extract the full git commit message like a
p4 form . It just sees the Jobs : line as a marker to pass everything
from then on directly into the p4 form , but outside the description
section .
2012-07-04 21:34:20 +08:00
2022-04-01 22:24:46 +08:00
Return a tuple ( stripped log message , jobs string ) .
"""
2012-07-04 21:34:20 +08:00
m = re . search ( r ' ^Jobs: ' , message , re . MULTILINE )
if m is None :
return ( message , None )
jobtext = message [ m . start ( ) : ]
stripped_message = message [ : m . start ( ) ] . rstrip ( )
return ( stripped_message , jobtext )
def prepareLogMessage ( self , template , message , jobs ) :
2022-04-01 22:24:46 +08:00
""" Edits the template returned from " p4 change -o " to insert the
message in the Description field , and the jobs text in the Jobs
field .
"""
2007-03-20 05:25:17 +08:00
result = " "
2008-02-19 16:29:06 +08:00
inDescriptionSection = False
2007-03-20 05:25:17 +08:00
for line in template . split ( " \n " ) :
if line . startswith ( " # " ) :
result + = line + " \n "
continue
2008-02-19 16:29:06 +08:00
if inDescriptionSection :
2011-02-26 10:31:13 +08:00
if line . startswith ( " Files: " ) or line . startswith ( " Jobs: " ) :
2008-02-19 16:29:06 +08:00
inDescriptionSection = False
2012-07-04 21:34:20 +08:00
# insert Jobs section
if jobs :
result + = jobs + " \n "
2008-02-19 16:29:06 +08:00
else :
continue
else :
if line . startswith ( " Description: " ) :
inDescriptionSection = True
line + = " \n "
for messageLine in message . split ( " \n " ) :
line + = " \t " + messageLine + " \n "
result + = line + " \n "
2007-03-20 05:25:17 +08:00
return result
2021-12-16 21:46:16 +08:00
def patchRCSKeywords ( self , file , regexp ) :
2022-04-01 22:24:47 +08:00
""" Attempt to zap the RCS keywords in a p4 controlled file matching the
given regex .
"""
2022-04-01 22:24:52 +08:00
handle , outFileName = tempfile . mkstemp ( dir = ' . ' )
2012-02-23 15:51:30 +08:00
try :
git-p4: resolve RCS keywords in bytes not utf-8
RCS keywords are strings that are replaced with information from
Perforce. Examples include $Date$, $Author$, $File$, $Change$ etc.
Perforce resolves these by expanding them with their expanded values
when files are synced, but Git's data model requires these expanded
values to be converted back into their unexpanded form.
Previously, git-p4.py would implement this behaviour through the use of
regular expressions. However, the regular expression substitution was
applied using decoded strings i.e. the content of incoming commit diffs
was first decoded from bytes into UTF-8, processed with regular
expressions, then converted back to bytes.
Not only is this behaviour inefficient, but it is also a cause of a
common issue caused by text files containing invalid UTF-8 data. For
files created in Windows, CP1252 Smart Quote Characters (0x93 and 0x94)
are seen fairly frequently. These codes are invalid in UTF-8, so if the
script encountered any file containing them, on Python 2 the symbols
will be corrupted, and on Python 3 the script will fail with an
exception.
This patch replaces this decoding/encoding with bytes object regular
expressions, so that the substitution is performed directly upon the
source data with no conversions.
A test for smart quote handling has been added to the
t9810-git-p4-rcs.sh test suite.
Signed-off-by: Joel Holdsworth <jholdsworth@nvidia.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-16 21:46:19 +08:00
with os . fdopen ( handle , " wb " ) as outFile , open ( file , " rb " ) as inFile :
2021-12-16 21:46:15 +08:00
for line in inFile . readlines ( ) :
git-p4: resolve RCS keywords in bytes not utf-8
RCS keywords are strings that are replaced with information from
Perforce. Examples include $Date$, $Author$, $File$, $Change$ etc.
Perforce resolves these by expanding them with their expanded values
when files are synced, but Git's data model requires these expanded
values to be converted back into their unexpanded form.
Previously, git-p4.py would implement this behaviour through the use of
regular expressions. However, the regular expression substitution was
applied using decoded strings i.e. the content of incoming commit diffs
was first decoded from bytes into UTF-8, processed with regular
expressions, then converted back to bytes.
Not only is this behaviour inefficient, but it is also a cause of a
common issue caused by text files containing invalid UTF-8 data. For
files created in Windows, CP1252 Smart Quote Characters (0x93 and 0x94)
are seen fairly frequently. These codes are invalid in UTF-8, so if the
script encountered any file containing them, on Python 2 the symbols
will be corrupted, and on Python 3 the script will fail with an
exception.
This patch replaces this decoding/encoding with bytes object regular
expressions, so that the substitution is performed directly upon the
source data with no conversions.
A test for smart quote handling has been added to the
t9810-git-p4-rcs.sh test suite.
Signed-off-by: Joel Holdsworth <jholdsworth@nvidia.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-16 21:46:19 +08:00
outFile . write ( regexp . sub ( br ' $ \ 1$ ' , line ) )
2012-02-23 15:51:30 +08:00
# Forcibly overwrite the original file
os . unlink ( file )
shutil . move ( outFileName , file )
except :
# cleanup our temporary file
os . unlink ( outFileName )
2018-06-19 16:04:10 +08:00
print ( " Failed to strip RCS keywords in %s " % file )
2012-02-23 15:51:30 +08:00
raise
2018-06-19 16:04:10 +08:00
print ( " Patched up RCS keywords in %s " % file )
2012-02-23 15:51:30 +08:00
2022-04-01 22:24:53 +08:00
def p4UserForCommit ( self , id ) :
2022-04-01 22:24:47 +08:00
""" Return the tuple (perforce user,git email) for a given git commit
id .
"""
2011-04-22 03:50:23 +08:00
self . getUserMapFromPerforceServer ( )
2013-01-27 11:11:20 +08:00
gitEmail = read_pipe ( [ " git " , " log " , " --max-count=1 " ,
" --format= %a e " , id ] )
2011-04-22 03:50:23 +08:00
gitEmail = gitEmail . strip ( )
2018-06-19 16:04:07 +08:00
if gitEmail not in self . emails :
2022-04-01 22:24:53 +08:00
return ( None , gitEmail )
2011-04-22 03:50:23 +08:00
else :
2022-04-01 22:24:53 +08:00
return ( self . emails [ gitEmail ] , gitEmail )
2011-04-22 03:50:23 +08:00
2022-04-01 22:24:53 +08:00
def checkValidP4Users ( self , commits ) :
2022-04-01 22:24:47 +08:00
""" Check if any git authors cannot be mapped to p4 users. """
2011-04-22 03:50:23 +08:00
for id in commits :
2022-04-01 22:24:52 +08:00
user , email = self . p4UserForCommit ( id )
2011-04-22 03:50:23 +08:00
if not user :
msg = " Cannot find p4 user for email %s in commit %s . " % ( email , id )
2013-01-27 11:11:24 +08:00
if gitConfigBool ( " git-p4.allowMissingP4Users " ) :
2018-06-19 16:04:10 +08:00
print ( " %s " % msg )
2011-04-22 03:50:23 +08:00
else :
die ( " Error: %s \n Set git-p4.allowMissingP4Users to true to allow this. " % msg )
def lastP4Changelist ( self ) :
2022-04-01 22:24:47 +08:00
""" Get back the last changelist number submitted in this client spec.
This then gets used to patch up the username in the change . If the
same client spec is being used by multiple processes then this might
go wrong .
"""
2022-01-07 05:40:34 +08:00
results = p4CmdList ( [ " client " , " -o " ] ) # find the current client
2011-04-22 03:50:23 +08:00
client = None
for r in results :
2018-06-19 16:04:07 +08:00
if ' Client ' in r :
2011-04-22 03:50:23 +08:00
client = r [ ' Client ' ]
break
if not client :
die ( " could not get client spec " )
2011-10-16 22:47:52 +08:00
results = p4CmdList ( [ " changes " , " -c " , client , " -m " , " 1 " ] )
2011-04-22 03:50:23 +08:00
for r in results :
2018-06-19 16:04:07 +08:00
if ' change ' in r :
2011-04-22 03:50:23 +08:00
return r [ ' change ' ]
die ( " Could not get changelist number for last submit - cannot patch up user details " )
def modifyChangelistUser ( self , changelist , newUser ) :
2022-04-01 22:24:47 +08:00
""" Fixup the user field of a changelist after it has been submitted. """
2022-01-07 05:40:34 +08:00
changes = p4CmdList ( [ " change " , " -o " , changelist ] )
2011-05-07 18:19:43 +08:00
if len ( changes ) != 1 :
die ( " Bad output from p4 change modifying %s to user %s " %
( changelist , newUser ) )
c = changes [ 0 ]
2022-04-01 22:25:03 +08:00
if c [ ' User ' ] == newUser :
# Nothing to do
return
2011-05-07 18:19:43 +08:00
c [ ' User ' ] = newUser
2019-12-14 07:52:42 +08:00
# p4 does not understand format version 3 and above
input = marshal . dumps ( c , 2 )
2011-05-07 18:19:43 +08:00
2022-01-07 05:40:34 +08:00
result = p4CmdList ( [ " change " , " -f " , " -i " ] , stdin = input )
2011-04-22 03:50:23 +08:00
for r in result :
2018-06-19 16:04:07 +08:00
if ' code ' in r :
2011-04-22 03:50:23 +08:00
if r [ ' code ' ] == ' error ' :
die ( " Could not modify user field of changelist %s to %s : %s " % ( changelist , newUser , r [ ' data ' ] ) )
2018-06-19 16:04:07 +08:00
if ' data ' in r :
2011-04-22 03:50:23 +08:00
print ( " Updated user field for changelist %s to %s " % ( changelist , newUser ) )
return
die ( " Could not modify user field of changelist %s to %s " % ( changelist , newUser ) )
def canChangeChangelists ( self ) :
2022-04-01 22:24:47 +08:00
""" Check to see if we have p4 admin or super-user permissions, either
of which are required to modify changelists .
"""
2012-01-19 17:52:25 +08:00
results = p4CmdList ( [ " protects " , self . depotPath ] )
2011-04-22 03:50:23 +08:00
for r in results :
2018-06-19 16:04:07 +08:00
if ' perm ' in r :
2011-04-22 03:50:23 +08:00
if r [ ' perm ' ] == ' admin ' :
return 1
if r [ ' perm ' ] == ' super ' :
return 1
return 0
2016-12-03 06:43:19 +08:00
def prepareSubmitTemplate ( self , changelist = None ) :
2012-07-04 21:34:20 +08:00
""" Run " p4 change -o " to grab a change specification template.
2022-04-01 22:24:46 +08:00
2012-07-04 21:34:20 +08:00
This does not use " p4 -G " , as it is nice to keep the submission
template in original order , since a human might edit it .
Remove lines in the Files section that show changes to files
2022-04-01 22:24:46 +08:00
outside the depot path we ' re committing into.
"""
2012-07-04 21:34:20 +08:00
2022-04-01 22:24:52 +08:00
upstream , settings = findUpstreamBranchPoint ( )
2015-12-19 17:39:39 +08:00
2017-07-13 15:00:34 +08:00
template = """ \
# A Perforce Change Specification.
#
# Change: The change number. 'new' on a new changelist.
# Date: The date this specification was last modified.
# Client: The client on which the changelist was created. Read-only.
# User: The user who created the changelist.
# Status: Either 'pending' or 'submitted'. Read-only.
# Type: Either 'public' or 'restricted'. Default is 'public'.
# Description: Comments about the changelist. Required.
# Jobs: What opened jobs are to be closed by this changelist.
# You may delete jobs from this list. (New changelists only.)
# Files: What opened files from the default changelist are to be added
# to this changelist. You may delete files from this list.
# (New changelists only.)
"""
files_list = [ ]
2007-08-08 23:06:55 +08:00
inFilesSection = False
2017-07-13 15:00:34 +08:00
change_entry = None
2016-12-03 06:43:19 +08:00
args = [ ' change ' , ' -o ' ]
if changelist :
args . append ( str ( changelist ) )
2017-07-13 15:00:34 +08:00
for entry in p4CmdList ( args ) :
2018-06-19 16:04:07 +08:00
if ' code ' not in entry :
2017-07-13 15:00:34 +08:00
continue
if entry [ ' code ' ] == ' stat ' :
change_entry = entry
break
if not change_entry :
die ( ' Failed to decode output of p4 change -o ' )
2019-12-14 07:52:45 +08:00
for key , value in change_entry . items ( ) :
2017-07-13 15:00:34 +08:00
if key . startswith ( ' File ' ) :
2018-06-19 16:04:07 +08:00
if ' depot-paths ' in settings :
2017-07-13 15:00:34 +08:00
if not [ p for p in settings [ ' depot-paths ' ]
if p4PathStartsWith ( value , p ) ] :
continue
2007-08-08 23:06:55 +08:00
else :
2017-07-13 15:00:34 +08:00
if not p4PathStartsWith ( value , self . depotPath ) :
continue
files_list . append ( value )
continue
# Output in the order expected by prepareLogMessage
for key in [ ' Change ' , ' Client ' , ' User ' , ' Status ' , ' Description ' , ' Jobs ' ] :
2018-06-19 16:04:07 +08:00
if key not in change_entry :
2017-07-13 15:00:34 +08:00
continue
template + = ' \n '
template + = key + ' : '
if key == ' Description ' :
template + = ' \n '
for field_line in change_entry [ key ] . splitlines ( ) :
template + = ' \t ' + field_line + ' \n '
if len ( files_list ) > 0 :
template + = ' \n '
template + = ' Files: \n '
for path in files_list :
template + = ' \t ' + path + ' \n '
2007-08-08 23:06:55 +08:00
return template
2011-12-05 08:22:45 +08:00
def edit_template ( self , template_file ) :
2022-04-01 22:24:46 +08:00
""" Invoke the editor to let the user change the submission message.
Return true if okay to continue with the submit .
"""
2011-12-05 08:22:45 +08:00
# if configured to skip the editing part, just submit
2013-01-27 11:11:24 +08:00
if gitConfigBool ( " git-p4.skipSubmitEdit " ) :
2011-12-05 08:22:45 +08:00
return True
# look at the modification time, to check later if the user saved
# the file
mtime = os . stat ( template_file ) . st_mtime
# invoke the editor
2018-06-19 16:04:07 +08:00
if " P4EDITOR " in os . environ and ( os . environ . get ( " P4EDITOR " ) != " " ) :
2011-12-05 08:22:45 +08:00
editor = os . environ . get ( " P4EDITOR " )
else :
2022-01-07 05:40:34 +08:00
editor = read_pipe ( [ " git " , " var " , " GIT_EDITOR " ] ) . strip ( )
2015-05-20 06:23:17 +08:00
system ( [ " sh " , " -c " , ( ' %s " $@ " ' % editor ) , editor , template_file ] )
2011-12-05 08:22:45 +08:00
# If the file was not saved, prompt to see if this patch should
# be skipped. But skip this verification step if configured so.
2013-01-27 11:11:24 +08:00
if gitConfigBool ( " git-p4.skipSubmitEditCheck " ) :
2011-12-05 08:22:45 +08:00
return True
2011-12-18 01:39:03 +08:00
# modification time updated means user saved the file
if os . stat ( template_file ) . st_mtime > mtime :
return True
2019-12-16 22:02:19 +08:00
response = prompt ( " Submit template unchanged. Submit anyway? [y]es, [n]o (skip this patch) " )
if response == ' y ' :
return True
if response == ' n ' :
return False
2011-12-05 08:22:45 +08:00
2016-12-17 09:00:40 +08:00
def get_diff_description ( self , editedFiles , filesToAdd , symlinks ) :
2014-05-25 01:40:35 +08:00
# diff
2018-06-19 16:04:07 +08:00
if " P4DIFF " in os . environ :
2014-05-25 01:40:35 +08:00
del ( os . environ [ " P4DIFF " ] )
diff = " "
for editedFile in editedFiles :
diff + = p4_read_pipe ( [ ' diff ' , ' -du ' ,
wildcard_encode ( editedFile ) ] )
# new file diff
newdiff = " "
for newFile in filesToAdd :
newdiff + = " ==== new file ==== \n "
newdiff + = " --- /dev/null \n "
newdiff + = " +++ %s \n " % newFile
2016-12-17 09:00:40 +08:00
is_link = os . path . islink ( newFile )
expect_link = newFile in symlinks
if is_link and expect_link :
newdiff + = " + %s \n " % os . readlink ( newFile )
else :
f = open ( newFile , " r " )
2021-06-21 13:16:13 +08:00
try :
for line in f . readlines ( ) :
newdiff + = " + " + line
except UnicodeDecodeError :
2022-04-01 22:25:02 +08:00
# Found non-text data and skip, since diff description
# should only include text
pass
2016-12-17 09:00:40 +08:00
f . close ( )
2014-05-25 01:40:35 +08:00
2014-06-11 21:09:59 +08:00
return ( diff + newdiff ) . replace ( ' \r \n ' , ' \n ' )
2014-05-25 01:40:35 +08:00
2007-05-24 03:55:48 +08:00
def applyCommit ( self , id ) :
git p4: gracefully fail if some commits could not be applied
If a commit fails to apply cleanly to the p4 tree, an interactive
prompt asks what to do next. In all cases (skip, apply, write),
the behavior after the prompt had a few problems.
Change it so that it does not claim erroneously that all commits
were applied. Instead list the set of the patches under
consideration, and mark with an asterisk those that were
applied successfully. Like this example:
Applying 592f1f9 line5 in file1 will conflict
...
Unfortunately applying the change failed!
What do you want to do?
[s]kip this patch / [a]pply the patch forcibly and with .rej files / [w]rite the patch to a file (patch.txt) s
Skipping! Good luck with the next patches...
//depot/file1#4 - was edit, reverted
Applying b8db1c6 okay_commit_after_skip
...
Change 6 submitted.
Applied only the commits marked with '*':
592f1f9 line5 in file1 will conflict
* b8db1c6 okay_commit_after_skip
Do not try to sync and rebase unless all patches were applied.
If there was a conflict during the submit, there is sure to be one
at the rebase. Let the user to do the sync and rebase manually.
This changes how a couple tets in t9810-git-p4-rcs.sh behave:
- git p4 now does not leave files open and edited in the
client
- If a git commit contains a change to a file that was
deleted in p4, the test used to check that the sync/rebase
loop happened after the failure to apply the change. Since
now sync/rebase does not happen after failure, do not test
this. Normal rebase machinery, outside of git p4, will let
rebase --skip work.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Acked-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-09-10 04:16:03 +08:00
""" Apply one commit, return True if it succeeded. """
2018-06-19 16:04:10 +08:00
print ( " Applying " , read_pipe ( [ " git " , " show " , " -s " ,
" --format=format: % h %s " , id ] ) )
2011-02-20 09:18:24 +08:00
2022-04-01 22:24:52 +08:00
p4User , gitEmail = self . p4UserForCommit ( id )
2011-04-22 03:50:23 +08:00
2022-01-07 05:40:33 +08:00
diff = read_pipe_lines (
2022-01-07 05:40:34 +08:00
[ " git " , " diff-tree " , " -r " ] + self . diffOpts + [ " {} ^ " . format ( id ) , id ] )
2007-03-20 05:25:17 +08:00
filesToAdd = set ( )
2016-01-12 20:43:47 +08:00
filesToChangeType = set ( )
2007-03-20 05:25:17 +08:00
filesToDelete = set ( )
2007-05-16 15:41:26 +08:00
editedFiles = set ( )
2012-04-30 08:57:16 +08:00
pureRenameCopy = set ( )
2016-12-17 09:00:40 +08:00
symlinks = set ( )
2007-11-02 11:43:14 +08:00
filesToChangeExecBit = { }
2016-12-03 06:43:19 +08:00
all_files = list ( )
2012-02-23 15:51:30 +08:00
2007-03-20 05:25:17 +08:00
for line in diff :
2007-11-02 11:43:13 +08:00
diff = parseDiffTreeEntry ( line )
modifier = diff [ ' status ' ]
path = diff [ ' src ' ]
2016-12-03 06:43:19 +08:00
all_files . append ( path )
2007-03-20 05:25:17 +08:00
if modifier == " M " :
2011-10-16 22:47:52 +08:00
p4_edit ( path )
2007-11-02 11:43:14 +08:00
if isModeExecChanged ( diff [ ' src_mode ' ] , diff [ ' dst_mode ' ] ) :
filesToChangeExecBit [ path ] = diff [ ' dst_mode ' ]
2007-05-16 15:41:26 +08:00
editedFiles . add ( path )
2007-03-20 05:25:17 +08:00
elif modifier == " A " :
filesToAdd . add ( path )
2007-11-02 11:43:14 +08:00
filesToChangeExecBit [ path ] = diff [ ' dst_mode ' ]
2007-03-20 05:25:17 +08:00
if path in filesToDelete :
filesToDelete . remove ( path )
2016-12-17 09:00:40 +08:00
dst_mode = int ( diff [ ' dst_mode ' ] , 8 )
2018-06-19 16:04:11 +08:00
if dst_mode == 0o120000 :
2016-12-17 09:00:40 +08:00
symlinks . add ( path )
2007-03-20 05:25:17 +08:00
elif modifier == " D " :
filesToDelete . add ( path )
if path in filesToAdd :
filesToAdd . remove ( path )
2011-02-20 09:18:25 +08:00
elif modifier == " C " :
src , dest = diff [ ' src ' ] , diff [ ' dst ' ]
2019-01-18 17:36:56 +08:00
all_files . append ( dest )
2011-10-16 22:47:52 +08:00
p4_integrate ( src , dest )
2012-04-30 08:57:16 +08:00
pureRenameCopy . add ( dest )
2011-02-20 09:18:25 +08:00
if diff [ ' src_sha1 ' ] != diff [ ' dst_sha1 ' ] :
2011-10-16 22:47:52 +08:00
p4_edit ( dest )
2012-04-30 08:57:16 +08:00
pureRenameCopy . discard ( dest )
2011-02-20 09:18:25 +08:00
if isModeExecChanged ( diff [ ' src_mode ' ] , diff [ ' dst_mode ' ] ) :
2011-10-16 22:47:52 +08:00
p4_edit ( dest )
2012-04-30 08:57:16 +08:00
pureRenameCopy . discard ( dest )
2011-02-20 09:18:25 +08:00
filesToChangeExecBit [ dest ] = diff [ ' dst_mode ' ]
2013-01-27 11:11:19 +08:00
if self . isWindows :
# turn off read-only attribute
os . chmod ( dest , stat . S_IWRITE )
2011-02-20 09:18:25 +08:00
os . unlink ( dest )
editedFiles . add ( dest )
2007-10-16 13:15:06 +08:00
elif modifier == " R " :
2007-11-02 11:43:13 +08:00
src , dest = diff [ ' src ' ] , diff [ ' dst ' ]
2019-01-18 17:36:56 +08:00
all_files . append ( dest )
2012-07-13 07:29:00 +08:00
if self . p4HasMoveCommand :
p4_edit ( src ) # src must be open before move
p4_move ( src , dest ) # opens for (move/delete, move/add)
2012-04-30 08:57:16 +08:00
else :
2012-07-13 07:29:00 +08:00
p4_integrate ( src , dest )
if diff [ ' src_sha1 ' ] != diff [ ' dst_sha1 ' ] :
p4_edit ( dest )
else :
pureRenameCopy . add ( dest )
2007-11-02 11:43:14 +08:00
if isModeExecChanged ( diff [ ' src_mode ' ] , diff [ ' dst_mode ' ] ) :
2012-07-13 07:29:00 +08:00
if not self . p4HasMoveCommand :
p4_edit ( dest ) # with move: already open, writable
2007-11-02 11:43:14 +08:00
filesToChangeExecBit [ dest ] = diff [ ' dst_mode ' ]
2012-07-13 07:29:00 +08:00
if not self . p4HasMoveCommand :
2013-01-27 11:11:19 +08:00
if self . isWindows :
os . chmod ( dest , stat . S_IWRITE )
2012-07-13 07:29:00 +08:00
os . unlink ( dest )
filesToDelete . add ( src )
2007-10-16 13:15:06 +08:00
editedFiles . add ( dest )
2016-01-12 20:43:47 +08:00
elif modifier == " T " :
filesToChangeType . add ( path )
2007-03-20 05:25:17 +08:00
else :
die ( " unknown modifier %s for %s " % ( modifier , path ) )
2014-05-07 13:48:54 +08:00
diffcmd = " git diff-tree --full-index -p \" %s \" " % ( id )
2007-05-20 22:33:21 +08:00
patchcmd = diffcmd + " | git apply "
2007-05-20 22:55:05 +08:00
tryPatchCmd = patchcmd + " --check - "
applyPatchCmd = patchcmd + " --check --apply - "
2012-02-23 15:51:30 +08:00
patch_succeeded = True
2007-04-15 15:59:56 +08:00
2020-02-14 22:44:46 +08:00
if verbose :
print ( " TryPatch: %s " % tryPatchCmd )
2007-05-20 22:33:21 +08:00
if os . system ( tryPatchCmd ) != 0 :
2012-02-23 15:51:30 +08:00
fixed_rcs_keywords = False
patch_succeeded = False
2018-06-19 16:04:10 +08:00
print ( " Unfortunately applying the change failed! " )
2012-02-23 15:51:30 +08:00
# Patch failed, maybe it's just RCS keyword woes. Look through
# the patch to see if that's possible.
2013-01-27 11:11:24 +08:00
if gitConfigBool ( " git-p4.attemptRCSCleanup " ) :
2012-02-23 15:51:30 +08:00
file = None
kwfiles = { }
for file in editedFiles | filesToDelete :
# did this file's delta contain RCS keywords?
2021-12-16 21:46:16 +08:00
regexp = p4_keywords_regexp_for_file ( file )
if regexp :
2012-02-23 15:51:30 +08:00
# this file is a possibility...look for RCS keywords.
git-p4: resolve RCS keywords in bytes not utf-8
RCS keywords are strings that are replaced with information from
Perforce. Examples include $Date$, $Author$, $File$, $Change$ etc.
Perforce resolves these by expanding them with their expanded values
when files are synced, but Git's data model requires these expanded
values to be converted back into their unexpanded form.
Previously, git-p4.py would implement this behaviour through the use of
regular expressions. However, the regular expression substitution was
applied using decoded strings i.e. the content of incoming commit diffs
was first decoded from bytes into UTF-8, processed with regular
expressions, then converted back to bytes.
Not only is this behaviour inefficient, but it is also a cause of a
common issue caused by text files containing invalid UTF-8 data. For
files created in Windows, CP1252 Smart Quote Characters (0x93 and 0x94)
are seen fairly frequently. These codes are invalid in UTF-8, so if the
script encountered any file containing them, on Python 2 the symbols
will be corrupted, and on Python 3 the script will fail with an
exception.
This patch replaces this decoding/encoding with bytes object regular
expressions, so that the substitution is performed directly upon the
source data with no conversions.
A test for smart quote handling has been added to the
t9810-git-p4-rcs.sh test suite.
Signed-off-by: Joel Holdsworth <jholdsworth@nvidia.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-16 21:46:19 +08:00
for line in read_pipe_lines (
2022-04-01 22:24:59 +08:00
[ " git " , " diff " , " %s ^.. %s " % ( id , id ) , file ] ,
raw = True ) :
2012-02-23 15:51:30 +08:00
if regexp . search ( line ) :
if verbose :
2022-07-21 02:55:29 +08:00
print ( " got keyword match on %s in %s in %s " % ( regexp . pattern , line , file ) )
2021-12-16 21:46:16 +08:00
kwfiles [ file ] = regexp
2012-02-23 15:51:30 +08:00
break
2021-12-16 21:46:16 +08:00
for file , regexp in kwfiles . items ( ) :
2012-02-23 15:51:30 +08:00
if verbose :
2021-12-16 21:46:16 +08:00
print ( " zapping %s with %s " % ( line , regexp . pattern ) )
2013-01-27 11:11:19 +08:00
# File is being deleted, so not open in p4. Must
# disable the read-only bit on windows.
if self . isWindows and file not in editedFiles :
os . chmod ( file , stat . S_IWRITE )
2012-02-23 15:51:30 +08:00
self . patchRCSKeywords ( file , kwfiles [ file ] )
fixed_rcs_keywords = True
if fixed_rcs_keywords :
2018-06-19 16:04:10 +08:00
print ( " Retrying the patch with RCS keywords cleaned up " )
2012-02-23 15:51:30 +08:00
if os . system ( tryPatchCmd ) == 0 :
patch_succeeded = True
2020-02-14 22:44:46 +08:00
print ( " Patch succeesed this time with RCS keywords cleaned " )
2012-02-23 15:51:30 +08:00
if not patch_succeeded :
2012-09-10 04:16:05 +08:00
for f in editedFiles :
p4_revert ( f )
return False
2007-04-15 15:59:56 +08:00
2012-09-10 04:16:08 +08:00
#
# Apply the patch for real, and do add/delete/+x handling.
#
2022-01-07 05:40:33 +08:00
system ( applyPatchCmd , shell = True )
2007-03-20 05:25:17 +08:00
2016-01-12 20:43:47 +08:00
for f in filesToChangeType :
p4_edit ( f , " -t " , " auto " )
2007-03-20 05:25:17 +08:00
for f in filesToAdd :
2011-10-16 22:47:52 +08:00
p4_add ( f )
2007-03-20 05:25:17 +08:00
for f in filesToDelete :
2011-10-16 22:47:52 +08:00
p4_revert ( f )
p4_delete ( f )
2007-03-20 05:25:17 +08:00
2007-11-02 11:43:14 +08:00
# Set/clear executable bits
for f in filesToChangeExecBit . keys ( ) :
mode = filesToChangeExecBit [ f ]
setP4ExecBit ( f , mode )
2017-12-21 19:06:14 +08:00
update_shelve = 0
if len ( self . update_shelve ) > 0 :
update_shelve = self . update_shelve . pop ( 0 )
p4_reopen_in_change ( update_shelve , all_files )
2016-12-03 06:43:19 +08:00
2012-09-10 04:16:08 +08:00
#
# Build p4 change description, starting with the contents
# of the git commit message.
#
2008-02-19 16:33:08 +08:00
logMessage = extractLogMessageFromGitCommit ( id )
logMessage = logMessage . strip ( )
2022-04-01 22:24:52 +08:00
logMessage , jobs = self . separate_jobs_from_description ( logMessage )
2007-03-20 05:25:17 +08:00
2017-12-21 19:06:14 +08:00
template = self . prepareSubmitTemplate ( update_shelve )
2012-07-04 21:34:20 +08:00
submitTemplate = self . prepareLogMessage ( template , logMessage , jobs )
2011-05-07 18:19:43 +08:00
2012-07-04 21:34:18 +08:00
if self . preserveUser :
2022-04-01 22:24:45 +08:00
submitTemplate + = " \n ######## Actual user %s , modified after commit \n " % p4User
2012-07-04 21:34:18 +08:00
2012-09-10 04:16:08 +08:00
if self . checkAuthorship and not self . p4UserIsMe ( p4User ) :
submitTemplate + = " ######## git author %s does not match your p4 account. \n " % gitEmail
submitTemplate + = " ######## Use option --preserve-user to modify authorship. \n "
submitTemplate + = " ######## Variable git-p4.skipUserNameCheck hides this message. \n "
2012-07-04 21:34:18 +08:00
2012-09-10 04:16:08 +08:00
separatorLine = " ######## everything below this line is just the diff ####### \n "
2014-05-25 01:40:35 +08:00
if not self . prepare_p4_only :
submitTemplate + = separatorLine
2016-12-17 09:00:40 +08:00
submitTemplate + = self . get_diff_description ( editedFiles , filesToAdd , symlinks )
2012-09-10 04:16:08 +08:00
2022-04-01 22:24:52 +08:00
handle , fileName = tempfile . mkstemp ( )
2014-06-11 21:09:59 +08:00
tmpFile = os . fdopen ( handle , " w+b " )
2012-07-04 21:34:18 +08:00
if self . isWindows :
submitTemplate = submitTemplate . replace ( " \n " , " \r \n " )
2019-12-14 07:52:38 +08:00
tmpFile . write ( encode_text_stream ( submitTemplate ) )
2012-07-04 21:34:18 +08:00
tmpFile . close ( )
2015-11-24 15:43:59 +08:00
submitted = False
2008-08-27 15:30:29 +08:00
2015-11-24 15:43:59 +08:00
try :
2020-02-14 22:44:45 +08:00
# Allow the hook to edit the changelist text before presenting it
# to the user.
if not run_git_hook ( " p4-prepare-changelist " , [ fileName ] ) :
return False
2020-02-14 22:44:44 +08:00
if self . prepare_p4_only :
#
# Leave the p4 tree prepared, and the submit template around
# and let the user decide what to do next
#
submitted = True
print ( " " )
print ( " P4 workspace prepared for submission. " )
print ( " To submit or revert, go to client workspace " )
print ( " " + self . clientPath )
print ( " " )
print ( " To submit, use \" p4 submit \" to write a new description, " )
2022-04-01 22:24:55 +08:00
print ( " or \" p4 submit -i < %s \" to use the one prepared by "
2020-02-14 22:44:44 +08:00
" \" git p4 \" . " % fileName )
print ( " You can delete the file \" %s \" when finished. " % fileName )
if self . preserveUser and p4User and not self . p4UserIsMe ( p4User ) :
2022-04-01 22:24:55 +08:00
print ( " To preserve change ownership by user %s , you must \n "
" do \" p4 change -f <change> \" after submitting and \n "
2020-02-14 22:44:44 +08:00
" edit the User field. " )
if pureRenameCopy :
print ( " After submitting, renamed files must be re-synced. " )
print ( " Invoke \" p4 sync -f \" on each of these files: " )
for f in pureRenameCopy :
print ( " " + f )
print ( " " )
print ( " To revert the changes, use \" p4 revert ... \" , and delete " )
print ( " the submit template file \" %s \" " % fileName )
if filesToAdd :
print ( " Since the commit adds new files, they must be deleted: " )
for f in filesToAdd :
print ( " " + f )
print ( " " )
sys . stdout . flush ( )
return True
2015-11-24 15:43:59 +08:00
if self . edit_template ( fileName ) :
2020-02-14 22:44:45 +08:00
if not self . no_verify :
if not run_git_hook ( " p4-changelist " , [ fileName ] ) :
print ( " The p4-changelist hook failed. " )
sys . stdout . flush ( )
return False
2015-11-24 15:43:59 +08:00
# read the edited message and submit
tmpFile = open ( fileName , " rb " )
2019-12-14 07:52:38 +08:00
message = decode_text_stream ( tmpFile . read ( ) )
2015-11-24 15:43:59 +08:00
tmpFile . close ( )
if self . isWindows :
message = message . replace ( " \r \n " , " \n " )
2020-02-14 22:44:44 +08:00
if message . find ( separatorLine ) != - 1 :
submitTemplate = message [ : message . index ( separatorLine ) ]
else :
submitTemplate = message
if len ( submitTemplate . strip ( ) ) == 0 :
print ( " Changelist is empty, aborting this changelist. " )
sys . stdout . flush ( )
return False
2016-12-03 06:43:19 +08:00
2017-12-21 19:06:14 +08:00
if update_shelve :
2016-12-03 06:43:19 +08:00
p4_write_pipe ( [ ' shelve ' , ' -r ' , ' -i ' ] , submitTemplate )
elif self . shelve :
2016-11-28 17:33:18 +08:00
p4_write_pipe ( [ ' shelve ' , ' -i ' ] , submitTemplate )
else :
p4_write_pipe ( [ ' submit ' , ' -i ' ] , submitTemplate )
# The rename/copy happened by applying a patch that created a
# new file. This leaves it writable, which confuses p4.
for f in pureRenameCopy :
p4_sync ( f , " -f " )
2015-11-24 15:43:59 +08:00
if self . preserveUser :
if p4User :
# Get last changelist number. Cannot easily get it from
# the submit command output as the output is
# unmarshalled.
changelist = self . lastP4Changelist ( )
self . modifyChangelistUser ( changelist , p4User )
submitted = True
2020-02-14 22:44:45 +08:00
run_git_hook ( " p4-post-changelist " )
2015-11-24 15:43:59 +08:00
finally :
2020-02-14 22:44:44 +08:00
# Revert changes if we skip this patch
2016-11-28 17:33:18 +08:00
if not submitted or self . shelve :
if self . shelve :
2022-04-01 22:24:54 +08:00
print ( " Reverting shelved files. " )
2016-11-28 17:33:18 +08:00
else :
2022-04-01 22:24:54 +08:00
print ( " Submission cancelled, undoing p4 changes. " )
2020-02-14 22:44:44 +08:00
sys . stdout . flush ( )
2016-11-28 17:33:18 +08:00
for f in editedFiles | filesToDelete :
2015-11-24 15:43:59 +08:00
p4_revert ( f )
for f in filesToAdd :
p4_revert ( f )
os . remove ( f )
2012-07-04 21:34:18 +08:00
2020-02-14 22:44:44 +08:00
if not self . prepare_p4_only :
os . remove ( fileName )
2015-11-24 15:43:59 +08:00
return submitted
2007-03-20 05:25:17 +08:00
2012-04-11 23:21:24 +08:00
def exportGitTags ( self , gitTags ) :
2022-04-01 22:24:47 +08:00
""" Export git tags as p4 labels. Create a p4 label and then tag with
that .
"""
2012-04-11 23:21:24 +08:00
validLabelRegexp = gitConfig ( " git-p4.labelExportRegexp " )
if len ( validLabelRegexp ) == 0 :
validLabelRegexp = defaultLabelRegexp
m = re . compile ( validLabelRegexp )
2012-04-11 23:21:24 +08:00
for name in gitTags :
if not m . match ( name ) :
if verbose :
2018-06-19 16:04:10 +08:00
print ( " tag %s does not match regexp %s " % ( name , validLabelRegexp ) )
2012-04-11 23:21:24 +08:00
continue
# Get the p4 commit this corresponds to
2012-04-11 23:21:24 +08:00
logMessage = extractLogMessageFromGitCommit ( name )
values = extractSettingsGitLog ( logMessage )
2012-04-11 23:21:24 +08:00
2018-06-19 16:04:07 +08:00
if ' change ' not in values :
2012-04-11 23:21:24 +08:00
# a tag pointing to something not sent to p4; ignore
if verbose :
2018-06-19 16:04:10 +08:00
print ( " git tag %s does not give a p4 commit " % name )
2012-04-11 23:21:24 +08:00
continue
2012-04-11 23:21:24 +08:00
else :
changelist = values [ ' change ' ]
2012-04-11 23:21:24 +08:00
# Get the tag details.
inHeader = True
isAnnotated = False
body = [ ]
for l in read_pipe_lines ( [ " git " , " cat-file " , " -p " , name ] ) :
l = l . strip ( )
if inHeader :
if re . match ( r ' tag \ s+ ' , l ) :
isAnnotated = True
elif re . match ( r ' \ s*$ ' , l ) :
inHeader = False
continue
else :
body . append ( l )
if not isAnnotated :
body = [ " lightweight tag imported by git p4 \n " ]
# Create the label - use the same view as the client spec we are using
clientSpec = getClientSpec ( )
2022-04-01 22:24:58 +08:00
labelTemplate = " Label: %s \n " % name
2012-04-11 23:21:24 +08:00
labelTemplate + = " Description: \n "
for b in body :
labelTemplate + = " \t " + b + " \n "
labelTemplate + = " View: \n "
2013-08-30 18:02:06 +08:00
for depot_side in clientSpec . mappings :
labelTemplate + = " \t %s \n " % depot_side
2012-04-11 23:21:24 +08:00
2012-09-10 04:16:11 +08:00
if self . dry_run :
2018-06-19 16:04:10 +08:00
print ( " Would create p4 label %s for tag " % name )
2012-09-10 04:16:12 +08:00
elif self . prepare_p4_only :
2022-04-01 22:24:55 +08:00
print ( " Not creating p4 label %s for tag due to option "
2018-06-19 16:04:10 +08:00
" --prepare-p4-only " % name )
2012-09-10 04:16:11 +08:00
else :
p4_write_pipe ( [ " label " , " -i " ] , labelTemplate )
2012-04-11 23:21:24 +08:00
2012-09-10 04:16:11 +08:00
# Use the label
p4_system ( [ " tag " , " -l " , name ] +
2013-08-30 18:02:06 +08:00
[ " %s @ %s " % ( depot_side , changelist ) for depot_side in clientSpec . mappings ] )
2012-04-11 23:21:24 +08:00
2012-09-10 04:16:11 +08:00
if verbose :
2018-06-19 16:04:10 +08:00
print ( " created p4 label for tag %s " % name )
2012-04-11 23:21:24 +08:00
2007-03-20 05:25:17 +08:00
def run ( self , args ) :
2007-03-30 01:15:24 +08:00
if len ( args ) == 0 :
self . master = currentGitBranch ( )
elif len ( args ) == 1 :
self . master = args [ 0 ]
2011-12-25 10:07:40 +08:00
if not branchExists ( self . master ) :
die ( " Branch %s does not exist " % self . master )
2007-03-30 01:15:24 +08:00
else :
return False
2017-12-21 19:06:14 +08:00
for i in self . update_shelve :
if i < = 0 :
sys . exit ( " invalid changelist %d " % i )
2015-11-21 17:54:41 +08:00
if self . master :
allowSubmit = gitConfig ( " git-p4.allowSubmit " )
if len ( allowSubmit ) > 0 and not self . master in allowSubmit . split ( " , " ) :
die ( " %s is not in git-p4.allowSubmit " % self . master )
2008-06-23 02:12:39 +08:00
2022-04-01 22:24:52 +08:00
upstream , settings = findUpstreamBranchPoint ( )
2007-08-08 23:06:55 +08:00
self . depotPath = settings [ ' depot-paths ' ] [ 0 ]
2007-06-12 20:31:59 +08:00
if len ( self . origin ) == 0 :
self . origin = upstream
2007-06-08 04:54:32 +08:00
2017-12-21 19:06:14 +08:00
if len ( self . update_shelve ) > 0 :
2016-12-03 06:43:19 +08:00
self . shelve = True
2011-04-22 03:50:23 +08:00
if self . preserveUser :
if not self . canChangeChangelists ( ) :
die ( " Cannot preserve user names without p4 super-user or admin permissions " )
2012-09-10 04:16:13 +08:00
# if not set from the command line, try the config file
if self . conflict_behavior is None :
val = gitConfig ( " git-p4.conflict " )
if val :
if val not in self . conflict_behavior_choices :
die ( " Invalid value ' %s ' for config git-p4.conflict " % val )
else :
val = " ask "
self . conflict_behavior = val
2007-06-08 04:54:32 +08:00
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " Origin branch is " + self . origin )
2007-03-23 16:16:07 +08:00
2007-08-08 23:06:55 +08:00
if len ( self . depotPath ) == 0 :
2018-06-19 16:04:10 +08:00
print ( " Internal error: cannot locate perforce depot path from existing branches " )
2007-03-23 16:16:07 +08:00
sys . exit ( 128 )
2012-02-26 09:06:25 +08:00
self . useClientSpec = False
2013-01-27 11:11:24 +08:00
if gitConfigBool ( " git-p4.useclientspec " ) :
2012-02-26 09:06:25 +08:00
self . useClientSpec = True
if self . useClientSpec :
self . clientSpecDirs = getClientSpec ( )
2007-03-23 16:16:07 +08:00
2016-08-09 16:53:38 +08:00
# Check for the existence of P4 branches
2015-04-22 06:49:30 +08:00
branchesDetected = ( len ( p4BranchesInGit ( ) . keys ( ) ) > 1 )
if self . useClientSpec and not branchesDetected :
2012-02-26 09:06:25 +08:00
# all files are relative to the client spec
self . clientPath = getClientRoot ( )
else :
self . clientPath = p4Where ( self . depotPath )
2007-03-23 16:16:07 +08:00
2012-02-26 09:06:25 +08:00
if self . clientPath == " " :
die ( " Error: Cannot locate perforce checkout of %s in client view " % self . depotPath )
2007-03-23 16:16:07 +08:00
2018-06-19 16:04:10 +08:00
print ( " Perforce checkout for depot path %s located at %s " % ( self . depotPath , self . clientPath ) )
2007-05-21 17:04:26 +08:00
self . oldWorkingDirectory = os . getcwd ( )
2007-05-20 22:55:05 +08:00
2011-12-10 07:48:14 +08:00
# ensure the clientPath exists
2012-04-30 08:57:14 +08:00
new_client_dir = False
2011-12-10 07:48:14 +08:00
if not os . path . exists ( self . clientPath ) :
2012-04-30 08:57:14 +08:00
new_client_dir = True
2011-12-10 07:48:14 +08:00
os . makedirs ( self . clientPath )
2013-03-12 05:45:29 +08:00
chdir ( self . clientPath , is_client_path = True )
2012-09-10 04:16:11 +08:00
if self . dry_run :
2018-06-19 16:04:10 +08:00
print ( " Would synchronize p4 checkout in %s " % self . clientPath )
2012-04-30 08:57:14 +08:00
else :
2018-06-19 16:04:10 +08:00
print ( " Synchronizing p4 checkout... " )
2012-09-10 04:16:11 +08:00
if new_client_dir :
# old one was destroyed, and maybe nobody told p4
p4_sync ( " ... " , " -f " )
else :
p4_sync ( " ... " )
2007-03-20 05:25:17 +08:00
self . check ( )
2008-02-19 16:37:16 +08:00
commits = [ ]
2015-11-21 17:54:41 +08:00
if self . master :
2018-05-10 20:43:00 +08:00
committish = self . master
2015-11-21 17:54:41 +08:00
else :
2018-05-10 20:43:00 +08:00
committish = ' HEAD '
2015-11-21 17:54:41 +08:00
2018-06-01 15:46:14 +08:00
if self . commit != " " :
if self . commit . find ( " .. " ) != - 1 :
limits_ish = self . commit . split ( " .. " )
for line in read_pipe_lines ( [ " git " , " rev-list " , " --no-merges " , " %s .. %s " % ( limits_ish [ 0 ] , limits_ish [ 1 ] ) ] ) :
commits . append ( line . strip ( ) )
commits . reverse ( )
else :
commits . append ( self . commit )
else :
2018-06-19 01:18:41 +08:00
for line in read_pipe_lines ( [ " git " , " rev-list " , " --no-merges " , " %s .. %s " % ( self . origin , committish ) ] ) :
2018-06-01 15:46:14 +08:00
commits . append ( line . strip ( ) )
commits . reverse ( )
2007-03-20 05:25:17 +08:00
2013-01-27 11:11:24 +08:00
if self . preserveUser or gitConfigBool ( " git-p4.skipUserNameCheck " ) :
2011-05-14 03:46:00 +08:00
self . checkAuthorship = False
else :
self . checkAuthorship = True
2011-04-22 03:50:23 +08:00
if self . preserveUser :
self . checkValidP4Users ( commits )
2012-07-04 21:40:19 +08:00
#
# Build up a set of options to be passed to diff when
# submitting each commit to p4.
#
if self . detectRenames :
# command-line -M arg
2022-01-07 05:40:34 +08:00
self . diffOpts = [ " -M " ]
2012-07-04 21:40:19 +08:00
else :
# If not explicitly set check the config variable
detectRenames = gitConfig ( " git-p4.detectRenames " )
if detectRenames . lower ( ) == " false " or detectRenames == " " :
2022-01-07 05:40:34 +08:00
self . diffOpts = [ ]
2012-07-04 21:40:19 +08:00
elif detectRenames . lower ( ) == " true " :
2022-01-07 05:40:34 +08:00
self . diffOpts = [ " -M " ]
2012-07-04 21:40:19 +08:00
else :
2022-01-07 05:40:34 +08:00
self . diffOpts = [ " -M {} " . format ( detectRenames ) ]
2012-07-04 21:40:19 +08:00
# no command-line arg for -C or --find-copies-harder, just
# config variables
detectCopies = gitConfig ( " git-p4.detectCopies " )
if detectCopies . lower ( ) == " false " or detectCopies == " " :
pass
elif detectCopies . lower ( ) == " true " :
2022-01-07 05:40:34 +08:00
self . diffOpts . append ( " -C " )
2012-07-04 21:40:19 +08:00
else :
2022-01-07 05:40:34 +08:00
self . diffOpts . append ( " -C {} " . format ( detectCopies ) )
2012-07-04 21:40:19 +08:00
2013-01-27 11:11:24 +08:00
if gitConfigBool ( " git-p4.detectCopiesHarder " ) :
2022-01-07 05:40:34 +08:00
self . diffOpts . append ( " --find-copies-harder " )
2012-07-04 21:40:19 +08:00
2017-12-21 19:06:14 +08:00
num_shelves = len ( self . update_shelve )
if num_shelves > 0 and num_shelves != len ( commits ) :
sys . exit ( " number of commits ( %d ) must match number of shelved changelist ( %d ) " %
( len ( commits ) , num_shelves ) )
2020-02-12 02:58:01 +08:00
if not self . no_verify :
try :
if not run_git_hook ( " p4-pre-submit " ) :
2022-04-01 22:24:55 +08:00
print ( " \n The p4-pre-submit hook failed, aborting the submit. \n \n You can skip "
" this pre-submission check by adding \n the command line option ' --no-verify ' , "
2020-02-12 02:58:01 +08:00
" however, \n this will also skip the p4-changelist hook as well. " )
sys . exit ( 1 )
except Exception as e :
2022-04-01 22:24:55 +08:00
print ( " \n The p4-pre-submit hook failed, aborting the submit. \n \n The hook failed "
2022-04-01 22:24:50 +08:00
" with the error ' {0} ' " . format ( e . message ) )
2020-02-12 02:58:00 +08:00
sys . exit ( 1 )
2018-07-27 19:22:22 +08:00
2012-09-10 04:16:05 +08:00
#
# Apply the commits, one at a time. On failure, ask if should
# continue to try the rest of the patches, or quit.
#
2012-09-10 04:16:11 +08:00
if self . dry_run :
2018-06-19 16:04:10 +08:00
print ( " Would apply " )
git p4: gracefully fail if some commits could not be applied
If a commit fails to apply cleanly to the p4 tree, an interactive
prompt asks what to do next. In all cases (skip, apply, write),
the behavior after the prompt had a few problems.
Change it so that it does not claim erroneously that all commits
were applied. Instead list the set of the patches under
consideration, and mark with an asterisk those that were
applied successfully. Like this example:
Applying 592f1f9 line5 in file1 will conflict
...
Unfortunately applying the change failed!
What do you want to do?
[s]kip this patch / [a]pply the patch forcibly and with .rej files / [w]rite the patch to a file (patch.txt) s
Skipping! Good luck with the next patches...
//depot/file1#4 - was edit, reverted
Applying b8db1c6 okay_commit_after_skip
...
Change 6 submitted.
Applied only the commits marked with '*':
592f1f9 line5 in file1 will conflict
* b8db1c6 okay_commit_after_skip
Do not try to sync and rebase unless all patches were applied.
If there was a conflict during the submit, there is sure to be one
at the rebase. Let the user to do the sync and rebase manually.
This changes how a couple tets in t9810-git-p4-rcs.sh behave:
- git p4 now does not leave files open and edited in the
client
- If a git commit contains a change to a file that was
deleted in p4, the test used to check that the sync/rebase
loop happened after the failure to apply the change. Since
now sync/rebase does not happen after failure, do not test
this. Normal rebase machinery, outside of git p4, will let
rebase --skip work.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Acked-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-09-10 04:16:03 +08:00
applied = [ ]
2012-09-10 04:16:05 +08:00
last = len ( commits ) - 1
for i , commit in enumerate ( commits ) :
2012-09-10 04:16:11 +08:00
if self . dry_run :
2018-06-19 16:04:10 +08:00
print ( " " , read_pipe ( [ " git " , " show " , " -s " ,
" --format=format: % h %s " , commit ] ) )
2012-09-10 04:16:11 +08:00
ok = True
else :
ok = self . applyCommit ( commit )
git p4: gracefully fail if some commits could not be applied
If a commit fails to apply cleanly to the p4 tree, an interactive
prompt asks what to do next. In all cases (skip, apply, write),
the behavior after the prompt had a few problems.
Change it so that it does not claim erroneously that all commits
were applied. Instead list the set of the patches under
consideration, and mark with an asterisk those that were
applied successfully. Like this example:
Applying 592f1f9 line5 in file1 will conflict
...
Unfortunately applying the change failed!
What do you want to do?
[s]kip this patch / [a]pply the patch forcibly and with .rej files / [w]rite the patch to a file (patch.txt) s
Skipping! Good luck with the next patches...
//depot/file1#4 - was edit, reverted
Applying b8db1c6 okay_commit_after_skip
...
Change 6 submitted.
Applied only the commits marked with '*':
592f1f9 line5 in file1 will conflict
* b8db1c6 okay_commit_after_skip
Do not try to sync and rebase unless all patches were applied.
If there was a conflict during the submit, there is sure to be one
at the rebase. Let the user to do the sync and rebase manually.
This changes how a couple tets in t9810-git-p4-rcs.sh behave:
- git p4 now does not leave files open and edited in the
client
- If a git commit contains a change to a file that was
deleted in p4, the test used to check that the sync/rebase
loop happened after the failure to apply the change. Since
now sync/rebase does not happen after failure, do not test
this. Normal rebase machinery, outside of git p4, will let
rebase --skip work.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Acked-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-09-10 04:16:03 +08:00
if ok :
applied . append ( commit )
2020-05-12 21:15:59 +08:00
if self . prepare_p4_only :
if i < last :
2022-04-01 22:24:55 +08:00
print ( " Processing only the first commit due to option "
2020-05-12 21:15:59 +08:00
" --prepare-p4-only " )
2012-09-10 04:16:12 +08:00
break
2020-05-12 21:15:59 +08:00
else :
2012-09-10 04:16:05 +08:00
if i < last :
2019-12-16 22:02:19 +08:00
# prompt for what to do, or use the option/variable
if self . conflict_behavior == " ask " :
print ( " What do you want to do? " )
response = prompt ( " [s]kip this commit but apply the rest, or [q]uit? " )
elif self . conflict_behavior == " skip " :
response = " s "
elif self . conflict_behavior == " quit " :
response = " q "
else :
die ( " Unknown conflict_behavior ' %s ' " %
self . conflict_behavior )
if response == " s " :
print ( " Skipping this commit, but applying the rest " )
if response == " q " :
print ( " Quitting " )
2012-09-10 04:16:05 +08:00
break
2007-03-20 05:25:17 +08:00
git p4: gracefully fail if some commits could not be applied
If a commit fails to apply cleanly to the p4 tree, an interactive
prompt asks what to do next. In all cases (skip, apply, write),
the behavior after the prompt had a few problems.
Change it so that it does not claim erroneously that all commits
were applied. Instead list the set of the patches under
consideration, and mark with an asterisk those that were
applied successfully. Like this example:
Applying 592f1f9 line5 in file1 will conflict
...
Unfortunately applying the change failed!
What do you want to do?
[s]kip this patch / [a]pply the patch forcibly and with .rej files / [w]rite the patch to a file (patch.txt) s
Skipping! Good luck with the next patches...
//depot/file1#4 - was edit, reverted
Applying b8db1c6 okay_commit_after_skip
...
Change 6 submitted.
Applied only the commits marked with '*':
592f1f9 line5 in file1 will conflict
* b8db1c6 okay_commit_after_skip
Do not try to sync and rebase unless all patches were applied.
If there was a conflict during the submit, there is sure to be one
at the rebase. Let the user to do the sync and rebase manually.
This changes how a couple tets in t9810-git-p4-rcs.sh behave:
- git p4 now does not leave files open and edited in the
client
- If a git commit contains a change to a file that was
deleted in p4, the test used to check that the sync/rebase
loop happened after the failure to apply the change. Since
now sync/rebase does not happen after failure, do not test
this. Normal rebase machinery, outside of git p4, will let
rebase --skip work.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Acked-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-09-10 04:16:03 +08:00
chdir ( self . oldWorkingDirectory )
2016-11-28 17:33:18 +08:00
shelved_applied = " shelved " if self . shelve else " applied "
2012-09-10 04:16:11 +08:00
if self . dry_run :
pass
2012-09-10 04:16:12 +08:00
elif self . prepare_p4_only :
pass
2012-09-10 04:16:11 +08:00
elif len ( commits ) == len ( applied ) :
2018-06-19 16:04:10 +08:00
print ( " All commits {0} ! " . format ( shelved_applied ) )
2007-08-22 15:07:15 +08:00
2008-02-19 16:37:16 +08:00
sync = P4Sync ( )
2013-01-15 08:47:08 +08:00
if self . branch :
sync . branch = self . branch
2018-06-09 04:32:44 +08:00
if self . disable_p4sync :
sync . sync_origin_only ( )
else :
sync . run ( [ ] )
2007-08-22 15:07:15 +08:00
2018-06-09 04:32:44 +08:00
if not self . disable_rebase :
rebase = P4Rebase ( )
rebase . rebase ( )
2007-03-20 05:25:17 +08:00
git p4: gracefully fail if some commits could not be applied
If a commit fails to apply cleanly to the p4 tree, an interactive
prompt asks what to do next. In all cases (skip, apply, write),
the behavior after the prompt had a few problems.
Change it so that it does not claim erroneously that all commits
were applied. Instead list the set of the patches under
consideration, and mark with an asterisk those that were
applied successfully. Like this example:
Applying 592f1f9 line5 in file1 will conflict
...
Unfortunately applying the change failed!
What do you want to do?
[s]kip this patch / [a]pply the patch forcibly and with .rej files / [w]rite the patch to a file (patch.txt) s
Skipping! Good luck with the next patches...
//depot/file1#4 - was edit, reverted
Applying b8db1c6 okay_commit_after_skip
...
Change 6 submitted.
Applied only the commits marked with '*':
592f1f9 line5 in file1 will conflict
* b8db1c6 okay_commit_after_skip
Do not try to sync and rebase unless all patches were applied.
If there was a conflict during the submit, there is sure to be one
at the rebase. Let the user to do the sync and rebase manually.
This changes how a couple tets in t9810-git-p4-rcs.sh behave:
- git p4 now does not leave files open and edited in the
client
- If a git commit contains a change to a file that was
deleted in p4, the test used to check that the sync/rebase
loop happened after the failure to apply the change. Since
now sync/rebase does not happen after failure, do not test
this. Normal rebase machinery, outside of git p4, will let
rebase --skip work.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Acked-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-09-10 04:16:03 +08:00
else :
if len ( applied ) == 0 :
2018-06-19 16:04:10 +08:00
print ( " No commits {0} . " . format ( shelved_applied ) )
git p4: gracefully fail if some commits could not be applied
If a commit fails to apply cleanly to the p4 tree, an interactive
prompt asks what to do next. In all cases (skip, apply, write),
the behavior after the prompt had a few problems.
Change it so that it does not claim erroneously that all commits
were applied. Instead list the set of the patches under
consideration, and mark with an asterisk those that were
applied successfully. Like this example:
Applying 592f1f9 line5 in file1 will conflict
...
Unfortunately applying the change failed!
What do you want to do?
[s]kip this patch / [a]pply the patch forcibly and with .rej files / [w]rite the patch to a file (patch.txt) s
Skipping! Good luck with the next patches...
//depot/file1#4 - was edit, reverted
Applying b8db1c6 okay_commit_after_skip
...
Change 6 submitted.
Applied only the commits marked with '*':
592f1f9 line5 in file1 will conflict
* b8db1c6 okay_commit_after_skip
Do not try to sync and rebase unless all patches were applied.
If there was a conflict during the submit, there is sure to be one
at the rebase. Let the user to do the sync and rebase manually.
This changes how a couple tets in t9810-git-p4-rcs.sh behave:
- git p4 now does not leave files open and edited in the
client
- If a git commit contains a change to a file that was
deleted in p4, the test used to check that the sync/rebase
loop happened after the failure to apply the change. Since
now sync/rebase does not happen after failure, do not test
this. Normal rebase machinery, outside of git p4, will let
rebase --skip work.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Acked-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-09-10 04:16:03 +08:00
else :
2018-06-19 16:04:10 +08:00
print ( " {0} only the commits marked with ' * ' : " . format ( shelved_applied . capitalize ( ) ) )
git p4: gracefully fail if some commits could not be applied
If a commit fails to apply cleanly to the p4 tree, an interactive
prompt asks what to do next. In all cases (skip, apply, write),
the behavior after the prompt had a few problems.
Change it so that it does not claim erroneously that all commits
were applied. Instead list the set of the patches under
consideration, and mark with an asterisk those that were
applied successfully. Like this example:
Applying 592f1f9 line5 in file1 will conflict
...
Unfortunately applying the change failed!
What do you want to do?
[s]kip this patch / [a]pply the patch forcibly and with .rej files / [w]rite the patch to a file (patch.txt) s
Skipping! Good luck with the next patches...
//depot/file1#4 - was edit, reverted
Applying b8db1c6 okay_commit_after_skip
...
Change 6 submitted.
Applied only the commits marked with '*':
592f1f9 line5 in file1 will conflict
* b8db1c6 okay_commit_after_skip
Do not try to sync and rebase unless all patches were applied.
If there was a conflict during the submit, there is sure to be one
at the rebase. Let the user to do the sync and rebase manually.
This changes how a couple tets in t9810-git-p4-rcs.sh behave:
- git p4 now does not leave files open and edited in the
client
- If a git commit contains a change to a file that was
deleted in p4, the test used to check that the sync/rebase
loop happened after the failure to apply the change. Since
now sync/rebase does not happen after failure, do not test
this. Normal rebase machinery, outside of git p4, will let
rebase --skip work.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Acked-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-09-10 04:16:03 +08:00
for c in commits :
if c in applied :
star = " * "
else :
star = " "
2018-06-19 16:04:10 +08:00
print ( star , read_pipe ( [ " git " , " show " , " -s " ,
" --format=format: % h %s " , c ] ) )
print ( " You will have to do ' git p4 sync ' and rebase. " )
git p4: gracefully fail if some commits could not be applied
If a commit fails to apply cleanly to the p4 tree, an interactive
prompt asks what to do next. In all cases (skip, apply, write),
the behavior after the prompt had a few problems.
Change it so that it does not claim erroneously that all commits
were applied. Instead list the set of the patches under
consideration, and mark with an asterisk those that were
applied successfully. Like this example:
Applying 592f1f9 line5 in file1 will conflict
...
Unfortunately applying the change failed!
What do you want to do?
[s]kip this patch / [a]pply the patch forcibly and with .rej files / [w]rite the patch to a file (patch.txt) s
Skipping! Good luck with the next patches...
//depot/file1#4 - was edit, reverted
Applying b8db1c6 okay_commit_after_skip
...
Change 6 submitted.
Applied only the commits marked with '*':
592f1f9 line5 in file1 will conflict
* b8db1c6 okay_commit_after_skip
Do not try to sync and rebase unless all patches were applied.
If there was a conflict during the submit, there is sure to be one
at the rebase. Let the user to do the sync and rebase manually.
This changes how a couple tets in t9810-git-p4-rcs.sh behave:
- git p4 now does not leave files open and edited in the
client
- If a git commit contains a change to a file that was
deleted in p4, the test used to check that the sync/rebase
loop happened after the failure to apply the change. Since
now sync/rebase does not happen after failure, do not test
this. Normal rebase machinery, outside of git p4, will let
rebase --skip work.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Acked-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-09-10 04:16:03 +08:00
2013-01-27 11:11:24 +08:00
if gitConfigBool ( " git-p4.exportLabels " ) :
2012-05-11 14:25:18 +08:00
self . exportLabels = True
2012-04-11 23:21:24 +08:00
if self . exportLabels :
p4Labels = getP4Labels ( self . depotPath )
gitTags = getGitTags ( )
missingGitTags = gitTags - p4Labels
self . exportGitTags ( missingGitTags )
2013-07-29 16:18:21 +08:00
# exit with error unless everything applied perfectly
git p4: gracefully fail if some commits could not be applied
If a commit fails to apply cleanly to the p4 tree, an interactive
prompt asks what to do next. In all cases (skip, apply, write),
the behavior after the prompt had a few problems.
Change it so that it does not claim erroneously that all commits
were applied. Instead list the set of the patches under
consideration, and mark with an asterisk those that were
applied successfully. Like this example:
Applying 592f1f9 line5 in file1 will conflict
...
Unfortunately applying the change failed!
What do you want to do?
[s]kip this patch / [a]pply the patch forcibly and with .rej files / [w]rite the patch to a file (patch.txt) s
Skipping! Good luck with the next patches...
//depot/file1#4 - was edit, reverted
Applying b8db1c6 okay_commit_after_skip
...
Change 6 submitted.
Applied only the commits marked with '*':
592f1f9 line5 in file1 will conflict
* b8db1c6 okay_commit_after_skip
Do not try to sync and rebase unless all patches were applied.
If there was a conflict during the submit, there is sure to be one
at the rebase. Let the user to do the sync and rebase manually.
This changes how a couple tets in t9810-git-p4-rcs.sh behave:
- git p4 now does not leave files open and edited in the
client
- If a git commit contains a change to a file that was
deleted in p4, the test used to check that the sync/rebase
loop happened after the failure to apply the change. Since
now sync/rebase does not happen after failure, do not test
this. Normal rebase machinery, outside of git p4, will let
rebase --skip work.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Acked-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-09-10 04:16:03 +08:00
if len ( commits ) != len ( applied ) :
2022-04-01 22:24:45 +08:00
sys . exit ( 1 )
git p4: gracefully fail if some commits could not be applied
If a commit fails to apply cleanly to the p4 tree, an interactive
prompt asks what to do next. In all cases (skip, apply, write),
the behavior after the prompt had a few problems.
Change it so that it does not claim erroneously that all commits
were applied. Instead list the set of the patches under
consideration, and mark with an asterisk those that were
applied successfully. Like this example:
Applying 592f1f9 line5 in file1 will conflict
...
Unfortunately applying the change failed!
What do you want to do?
[s]kip this patch / [a]pply the patch forcibly and with .rej files / [w]rite the patch to a file (patch.txt) s
Skipping! Good luck with the next patches...
//depot/file1#4 - was edit, reverted
Applying b8db1c6 okay_commit_after_skip
...
Change 6 submitted.
Applied only the commits marked with '*':
592f1f9 line5 in file1 will conflict
* b8db1c6 okay_commit_after_skip
Do not try to sync and rebase unless all patches were applied.
If there was a conflict during the submit, there is sure to be one
at the rebase. Let the user to do the sync and rebase manually.
This changes how a couple tets in t9810-git-p4-rcs.sh behave:
- git p4 now does not leave files open and edited in the
client
- If a git commit contains a change to a file that was
deleted in p4, the test used to check that the sync/rebase
loop happened after the failure to apply the change. Since
now sync/rebase does not happen after failure, do not test
this. Normal rebase machinery, outside of git p4, will let
rebase --skip work.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Acked-by: Luke Diamand <luke@diamand.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-09-10 04:16:03 +08:00
2007-03-21 03:54:23 +08:00
return True
2022-04-01 22:24:43 +08:00
2012-01-03 07:05:53 +08:00
class View ( object ) :
2022-04-01 22:24:46 +08:00
""" Represent a p4 view ( " p4 help views " ), and map files in a repo according
to the view .
"""
2012-01-03 07:05:53 +08:00
2013-08-30 18:02:06 +08:00
def __init__ ( self , client_name ) :
2012-01-03 07:05:53 +08:00
self . mappings = [ ]
2013-08-30 18:02:06 +08:00
self . client_prefix = " // %s / " % client_name
# cache results of "p4 where" to lookup client file locations
self . client_spec_path_cache = { }
2012-01-03 07:05:53 +08:00
def append ( self , view_line ) :
2022-04-01 22:24:46 +08:00
""" Parse a view line, splitting it into depot and client sides. Append
to self . mappings , preserving order . This is only needed for tag
creation .
"""
2012-01-03 07:05:53 +08:00
# Split the view line into exactly two words. P4 enforces
# structure on these lines that simplifies this quite a bit.
#
# Either or both words may be double-quoted.
# Single quotes do not matter.
# Double-quote marks cannot occur inside the words.
# A + or - prefix is also inside the quotes.
# There are no quotes unless they contain a space.
# The line is already white-space stripped.
# The two words are separated by a single space.
#
if view_line [ 0 ] == ' " ' :
# First word is double quoted. Find its end.
close_quote_index = view_line . find ( ' " ' , 1 )
if close_quote_index < = 0 :
die ( " No first-word closing quote found: %s " % view_line )
depot_side = view_line [ 1 : close_quote_index ]
# skip closing quote and space
rhs_index = close_quote_index + 1 + 1
else :
space_index = view_line . find ( " " )
if space_index < = 0 :
die ( " No word-splitting space found: %s " % view_line )
depot_side = view_line [ 0 : space_index ]
rhs_index = space_index + 1
# prefix + means overlay on previous mapping
if depot_side . startswith ( " + " ) :
depot_side = depot_side [ 1 : ]
2013-08-30 18:02:06 +08:00
# prefix - means exclude this path, leave out of mappings
2012-01-03 07:05:53 +08:00
exclude = False
if depot_side . startswith ( " - " ) :
exclude = True
depot_side = depot_side [ 1 : ]
2013-08-30 18:02:06 +08:00
if not exclude :
self . mappings . append ( depot_side )
2012-01-03 07:05:53 +08:00
2013-08-30 18:02:06 +08:00
def convert_client_path ( self , clientFile ) :
# chop off //client/ part to make it relative
2019-12-14 07:52:40 +08:00
if not decode_path ( clientFile ) . startswith ( self . client_prefix ) :
2013-08-30 18:02:06 +08:00
die ( " No prefix ' %s ' on clientFile ' %s ' " %
( self . client_prefix , clientFile ) )
return clientFile [ len ( self . client_prefix ) : ]
2012-01-03 07:05:53 +08:00
2013-08-30 18:02:06 +08:00
def update_client_spec_path_cache ( self , files ) :
2022-04-01 22:24:46 +08:00
""" Caching file paths by " p4 where " batch query. """
2012-01-03 07:05:53 +08:00
2013-08-30 18:02:06 +08:00
# List depot file paths exclude that already cached
2019-12-14 07:52:40 +08:00
fileArgs = [ f [ ' path ' ] for f in files if decode_path ( f [ ' path ' ] ) not in self . client_spec_path_cache ]
2012-01-03 07:05:53 +08:00
2013-08-30 18:02:06 +08:00
if len ( fileArgs ) == 0 :
return # All files in cache
2012-01-03 07:05:53 +08:00
2013-08-30 18:02:06 +08:00
where_result = p4CmdList ( [ " -x " , " - " , " where " ] , stdin = fileArgs )
for res in where_result :
if " code " in res and res [ " code " ] == " error " :
# assume error is "... file(s) not in client view"
continue
if " clientFile " not in res :
2014-01-22 07:16:46 +08:00
die ( " No clientFile in ' p4 where ' output " )
2013-08-30 18:02:06 +08:00
if " unmap " in res :
# it will list all of them, but only one not unmap-ped
continue
2019-12-14 07:52:40 +08:00
depot_path = decode_path ( res [ ' depotFile ' ] )
2015-08-28 20:00:34 +08:00
if gitConfigBool ( " core.ignorecase " ) :
2019-12-14 07:52:40 +08:00
depot_path = depot_path . lower ( )
self . client_spec_path_cache [ depot_path ] = self . convert_client_path ( res [ " clientFile " ] )
2012-01-03 07:05:53 +08:00
2013-08-30 18:02:06 +08:00
# not found files or unmap files set to ""
for depotFile in fileArgs :
2019-12-14 07:52:40 +08:00
depotFile = decode_path ( depotFile )
2015-08-28 20:00:34 +08:00
if gitConfigBool ( " core.ignorecase " ) :
depotFile = depotFile . lower ( )
2013-08-30 18:02:06 +08:00
if depotFile not in self . client_spec_path_cache :
2019-12-14 07:52:40 +08:00
self . client_spec_path_cache [ depotFile ] = b ' '
2012-01-03 07:05:53 +08:00
2013-08-30 18:02:06 +08:00
def map_in_client ( self , depot_path ) :
2022-04-01 22:24:46 +08:00
""" Return the relative location in the client where this depot file
should live .
Returns " " if the file should not be mapped in the client .
"""
2012-01-03 07:05:53 +08:00
2015-08-28 20:00:34 +08:00
if gitConfigBool ( " core.ignorecase " ) :
depot_path = depot_path . lower ( )
2013-08-30 18:02:06 +08:00
if depot_path in self . client_spec_path_cache :
return self . client_spec_path_cache [ depot_path ]
2022-04-01 22:24:50 +08:00
die ( " Error: %s is not found in client spec path " % depot_path )
2013-08-30 18:02:06 +08:00
return " "
2012-01-03 07:05:53 +08:00
2022-04-01 22:24:43 +08:00
2019-04-02 02:02:26 +08:00
def cloneExcludeCallback ( option , opt_str , value , parser ) :
# prepend "/" because the first "/" was consumed as part of the option itself.
# ("-//depot/A/..." becomes "/depot/A/..." after option parsing)
parser . values . cloneExclude + = [ " / " + re . sub ( r " \ . \ . \ .$ " , " " , value ) ]
2022-04-01 22:24:43 +08:00
2011-04-22 03:50:23 +08:00
class P4Sync ( Command , P4UserMap ) :
2011-02-19 21:17:57 +08:00
2007-03-21 03:54:23 +08:00
def __init__ ( self ) :
Command . __init__ ( self )
2011-04-22 03:50:23 +08:00
P4UserMap . __init__ ( self )
2007-03-21 03:54:23 +08:00
self . options = [
optparse . make_option ( " --branch " , dest = " branch " ) ,
optparse . make_option ( " --detect-branches " , dest = " detectBranches " , action = " store_true " ) ,
optparse . make_option ( " --changesfile " , dest = " changesFile " ) ,
optparse . make_option ( " --silent " , dest = " silent " , action = " store_true " ) ,
2007-05-18 04:17:49 +08:00
optparse . make_option ( " --detect-labels " , dest = " detectLabels " , action = " store_true " ) ,
2012-04-11 23:21:24 +08:00
optparse . make_option ( " --import-labels " , dest = " importLabels " , action = " store_true " ) ,
2007-05-24 05:49:35 +08:00
optparse . make_option ( " --import-local " , dest = " importIntoRemotes " , action = " store_false " ,
help = " Import into refs/heads/ , not refs/remotes " ) ,
2015-04-20 23:00:20 +08:00
optparse . make_option ( " --max-changes " , dest = " maxChanges " ,
help = " Maximum number of changes to import " ) ,
optparse . make_option ( " --changes-block-size " , dest = " changes_block_size " , type = " int " ,
help = " Internal block size to use when iteratively calling p4 changes " ) ,
2007-05-24 05:49:35 +08:00
optparse . make_option ( " --keep-path " , dest = " keepRepoPath " , action = ' store_true ' ,
2008-02-18 22:22:08 +08:00
help = " Keep entire BRANCH/DIR/SUBDIR prefix during import " ) ,
optparse . make_option ( " --use-client-spec " , dest = " useClientSpec " , action = ' store_true ' ,
2015-01-18 04:56:38 +08:00
help = " Only sync files that are included in the Perforce Client Spec " ) ,
optparse . make_option ( " -/ " , dest = " cloneExclude " ,
2019-04-02 02:02:26 +08:00
action = " callback " , callback = cloneExcludeCallback , type = " string " ,
2015-01-18 04:56:38 +08:00
help = " exclude depot path " ) ,
2007-03-21 03:54:23 +08:00
]
self . description = """ Imports from Perforce into a git repository. \n
example :
/ / depot / my / project / - - to import the current head
/ / depot / my / project / @all - - to import everything
/ / depot / my / project / @ 1 , 6 - - to import only from revision 1 to 6
( a . . . is not needed in the path p4 specification , it ' s added implicitly) " " "
self . usage + = " //depot/path[@revRange] "
self . silent = False
2009-09-10 15:02:38 +08:00
self . createdBranches = set ( )
self . committedChanges = set ( )
2007-03-23 04:34:16 +08:00
self . branch = " "
2007-03-21 03:54:23 +08:00
self . detectBranches = False
2007-04-08 06:12:02 +08:00
self . detectLabels = False
2012-04-11 23:21:24 +08:00
self . importLabels = False
2007-03-21 03:54:23 +08:00
self . changesFile = " "
2007-05-25 16:36:10 +08:00
self . syncWithOrigin = True
2007-05-23 06:03:08 +08:00
self . importIntoRemotes = True
2007-05-23 06:07:35 +08:00
self . maxChanges = " "
2015-06-10 15:30:59 +08:00
self . changes_block_size = None
2007-05-24 05:20:53 +08:00
self . keepRepoPath = False
2007-05-24 05:49:35 +08:00
self . depotPaths = None
2007-06-16 19:09:21 +08:00
self . p4BranchesInGit = [ ]
2008-02-04 02:38:51 +08:00
self . cloneExclude = [ ]
2008-02-18 22:22:08 +08:00
self . useClientSpec = False
2012-02-26 09:06:24 +08:00
self . useClientSpec_from_options = False
2012-01-03 07:05:53 +08:00
self . clientSpecDirs = None
2012-01-26 07:48:22 +08:00
self . tempBranches = [ ]
2016-06-29 15:35:27 +08:00
self . tempBranchLocation = " refs/git-p4-tmp "
2015-09-26 15:55:03 +08:00
self . largeFileSystem = None
2018-05-24 06:20:26 +08:00
self . suppress_meta_comment = False
2015-09-26 15:55:03 +08:00
if gitConfig ( ' git-p4.largeFileSystem ' ) :
largeFileSystemConstructor = globals ( ) [ gitConfig ( ' git-p4.largeFileSystem ' ) ]
self . largeFileSystem = largeFileSystemConstructor (
lambda git_mode , relPath , contents : self . writeToGitStream ( git_mode , relPath , contents )
)
2007-03-21 03:54:23 +08:00
2007-05-25 16:36:10 +08:00
if gitConfig ( " git-p4.syncFromOrigin " ) == " false " :
self . syncWithOrigin = False
2018-05-24 06:20:26 +08:00
self . depotPaths = [ ]
self . changeRange = " "
self . previousDepotPaths = [ ]
self . hasOrigin = False
# map from branch depot path to parent branch
self . knownBranches = { }
self . initialParents = { }
self . tz = " %+03d %02d " % ( - time . timezone / 3600 , ( ( - time . timezone % 3600 ) / 60 ) )
self . labels = { }
2012-01-26 07:48:22 +08:00
def checkpoint ( self ) :
2022-04-01 22:24:47 +08:00
""" Force a checkpoint in fast-import and wait for it to finish. """
2012-01-26 07:48:22 +08:00
self . gitStream . write ( " checkpoint \n \n " )
self . gitStream . write ( " progress checkpoint \n \n " )
2019-12-14 07:52:43 +08:00
self . gitStream . flush ( )
2012-01-26 07:48:22 +08:00
out = self . gitOutput . readline ( )
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " checkpoint finished: " + out )
2012-01-26 07:48:22 +08:00
2019-04-02 02:02:32 +08:00
def isPathWanted ( self , path ) :
for p in self . cloneExclude :
if p . endswith ( " / " ) :
if p4PathStartsWith ( path , p ) :
return False
# "-//depot/file1" without a trailing "/" should only exclude "file1", but not "file111" or "file1_dir/file2"
elif path . lower ( ) == p . lower ( ) :
return False
for p in self . depotPaths :
2019-12-14 07:52:40 +08:00
if p4PathStartsWith ( path , decode_path ( p ) ) :
2019-04-02 02:02:32 +08:00
return True
return False
2022-04-01 22:24:51 +08:00
def extractFilesFromCommit ( self , commit , shelved = False , shelved_cl = 0 ) :
2007-03-21 03:54:23 +08:00
files = [ ]
fnum = 0
2018-06-19 16:04:07 +08:00
while " depotFile %s " % fnum in commit :
2022-04-01 22:24:58 +08:00
path = commit [ " depotFile %s " % fnum ]
2019-12-14 07:52:40 +08:00
found = self . isPathWanted ( decode_path ( path ) )
2007-05-24 05:49:35 +08:00
if not found :
2007-03-21 03:54:23 +08:00
fnum = fnum + 1
continue
file = { }
file [ " path " ] = path
file [ " rev " ] = commit [ " rev %s " % fnum ]
file [ " action " ] = commit [ " action %s " % fnum ]
file [ " type " ] = commit [ " type %s " % fnum ]
2018-05-24 06:20:26 +08:00
if shelved :
file [ " shelved_cl " ] = int ( shelved_cl )
2007-03-21 03:54:23 +08:00
files . append ( file )
fnum = fnum + 1
return files
2016-04-20 03:49:41 +08:00
def extractJobsFromCommit ( self , commit ) :
jobs = [ ]
jnum = 0
2018-06-19 16:04:07 +08:00
while " job %s " % jnum in commit :
2016-04-20 03:49:41 +08:00
job = commit [ " job %s " % jnum ]
jobs . append ( job )
jnum = jnum + 1
return jobs
2007-05-24 05:49:35 +08:00
def stripRepoPath ( self , path , prefixes ) :
2022-04-01 22:24:46 +08:00
""" When streaming files, this is called to map a p4 depot path to where
it should go in git . The prefixes are either self . depotPaths , or
self . branchPrefixes in the case of branch detection .
"""
2012-08-12 00:55:04 +08:00
2011-02-12 08:33:48 +08:00
if self . useClientSpec :
2012-08-12 00:55:04 +08:00
# branch detection moves files up a level (the branch name)
# from what client spec interpretation gives
2019-12-14 07:52:40 +08:00
path = decode_path ( self . clientSpecDirs . map_in_client ( path ) )
2012-08-12 00:55:04 +08:00
if self . detectBranches :
for b in self . knownBranches :
2019-04-02 02:02:24 +08:00
if p4PathStartsWith ( path , b + " / " ) :
2012-08-12 00:55:04 +08:00
path = path [ len ( b ) + 1 : ]
elif self . keepRepoPath :
# Preserve everything in relative path name except leading
# //depot/; just look at first prefix as they all should
# be in the same depot.
depot = re . sub ( " ^(//[^/]+/).* " , r ' \ 1 ' , prefixes [ 0 ] )
if p4PathStartsWith ( path , depot ) :
path = path [ len ( depot ) : ]
2011-02-12 08:33:48 +08:00
2012-08-12 00:55:03 +08:00
else :
for p in prefixes :
if p4PathStartsWith ( path , p ) :
path = path [ len ( p ) : ]
2012-08-12 00:55:04 +08:00
break
2007-05-24 05:20:53 +08:00
2012-08-12 00:55:03 +08:00
path = wildcard_decode ( path )
2007-05-24 05:49:35 +08:00
return path
2007-05-24 04:41:50 +08:00
2007-05-19 17:54:11 +08:00
def splitFilesIntoBranches ( self , commit ) :
2022-04-01 22:24:46 +08:00
""" Look at each depotFile in the commit to figure out to what branch it
belongs .
"""
2012-08-12 00:55:04 +08:00
2013-08-30 18:02:06 +08:00
if self . clientSpecDirs :
files = self . extractFilesFromCommit ( commit )
self . clientSpecDirs . update_client_spec_path_cache ( files )
2007-05-19 17:07:32 +08:00
branches = { }
2007-05-19 17:54:11 +08:00
fnum = 0
2018-06-19 16:04:07 +08:00
while " depotFile %s " % fnum in commit :
2019-12-14 07:52:40 +08:00
raw_path = commit [ " depotFile %s " % fnum ]
path = decode_path ( raw_path )
2019-04-02 02:02:38 +08:00
found = self . isPathWanted ( path )
2007-05-24 05:49:35 +08:00
if not found :
2007-05-19 17:54:11 +08:00
fnum = fnum + 1
continue
file = { }
2019-12-14 07:52:40 +08:00
file [ " path " ] = raw_path
2007-05-19 17:54:11 +08:00
file [ " rev " ] = commit [ " rev %s " % fnum ]
file [ " action " ] = commit [ " action %s " % fnum ]
file [ " type " ] = commit [ " type %s " % fnum ]
fnum = fnum + 1
2012-08-12 00:55:04 +08:00
# start with the full relative path where this file would
# go in a p4 client
if self . useClientSpec :
2019-12-14 07:52:40 +08:00
relPath = decode_path ( self . clientSpecDirs . map_in_client ( path ) )
2012-08-12 00:55:04 +08:00
else :
relPath = self . stripRepoPath ( path , self . depotPaths )
2007-03-21 03:54:23 +08:00
2007-05-19 03:45:23 +08:00
for branch in self . knownBranches . keys ( ) :
2012-08-12 00:55:04 +08:00
# add a trailing slash so that a commit into qt/4.2foo
# doesn't end up in qt/4.2, e.g.
2019-04-02 02:02:24 +08:00
if p4PathStartsWith ( relPath , branch + " / " ) :
2007-05-19 17:07:32 +08:00
if branch not in branches :
branches [ branch ] = [ ]
2007-05-19 17:54:11 +08:00
branches [ branch ] . append ( file )
2007-06-17 17:25:34 +08:00
break
2007-03-21 03:54:23 +08:00
return branches
2015-09-26 15:55:03 +08:00
def writeToGitStream ( self , gitMode , relPath , contents ) :
2019-12-14 07:52:38 +08:00
self . gitStream . write ( encode_text_stream ( u ' M {} inline {} \n ' . format ( gitMode , relPath ) ) )
2015-09-26 15:55:03 +08:00
self . gitStream . write ( ' data %d \n ' % sum ( len ( d ) for d in contents ) )
for d in contents :
self . gitStream . write ( d )
self . gitStream . write ( ' \n ' )
2017-02-09 23:06:56 +08:00
def encodeWithUTF8 ( self , path ) :
try :
path . decode ( ' ascii ' )
except :
encoding = ' utf8 '
if gitConfig ( ' git-p4.pathEncoding ' ) :
encoding = gitConfig ( ' git-p4.pathEncoding ' )
path = path . decode ( encoding , ' replace ' ) . encode ( ' utf8 ' , ' replace ' )
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( ' Path with non-ASCII characters detected. Used %s to encode: %s ' % ( encoding , path ) )
2017-02-09 23:06:56 +08:00
return path
2009-07-30 07:13:46 +08:00
def streamOneP4File ( self , file , contents ) :
2022-04-01 22:24:47 +08:00
""" Output one file from the P4 stream.
This is a helper for streamP4Files ( ) .
"""
2019-12-14 07:52:40 +08:00
file_path = file [ ' depotFile ' ]
relPath = self . stripRepoPath ( decode_path ( file_path ) , self . branchPrefixes )
2009-07-30 07:13:46 +08:00
if verbose :
2018-10-12 13:28:31 +08:00
if ' fileSize ' in self . stream_file :
size = int ( self . stream_file [ ' fileSize ' ] )
else :
2022-04-01 22:25:02 +08:00
# Deleted files don't get a fileSize apparently
size = 0
git-p4: print size values in appropriate units
The git-p4 script reports file sizes in various log messages.
Previously, in each case the script would print them as the number of
bytes divided by 1048576 i.e. the size in mebibytes, rounded down to an
integer. This resulted in small files being described as having a size
of "0 MB".
This patch replaces the existing behaviour with a new helper function:
format_size_human_readable, which takes a number of bytes (or any other
quantity), and computes the appropriate prefix to use: none, Ki, Mi, Gi,
Ti, Pi, Ei, Zi, Yi.
For example, a size of 123456 will now be printed as "120.6 KiB" greatly
improving the readability of the log output.
Large valued prefixes such as pebi, exbi, zebi and yobi are included for
completeness, though they not expected to appear in any real-world
Perforce repository!
Signed-off-by: Joel Holdsworth <jholdsworth@nvidia.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-19 23:40:27 +08:00
sys . stdout . write ( ' \r %s --> %s ( %s ) \n ' % (
file_path , relPath , format_size_human_readable ( size ) ) )
2015-09-26 15:55:01 +08:00
sys . stdout . flush ( )
2009-07-30 07:13:46 +08:00
2022-04-01 22:24:52 +08:00
type_base , type_mods = split_p4_type ( file [ " type " ] )
2011-10-16 22:45:01 +08:00
git_mode = " 100644 "
if " x " in type_mods :
git_mode = " 100755 "
if type_base == " symlink " :
git_mode = " 120000 "
2013-08-08 21:17:38 +08:00
# p4 print on a symlink sometimes contains "target\n";
# if it does, remove the newline
2019-12-14 07:52:38 +08:00
data = ' ' . join ( decode_text_stream ( c ) for c in contents )
git p4: work around p4 bug that causes empty symlinks
Damien Gérard highlights an interesting problem. Some p4
repositories end up with symlinks that have an empty target. It
is not possible to create this with current p4, but they do
indeed exist.
The effect in git p4 is that "p4 print" on the symlink returns an
empty string, confusing the curret symlink-handling code.
Such broken repositories cause problems in p4 as well, even with
no git involved. In p4, syncing to a change that includes a
bogus symlink causes errors:
//depot/empty-symlink - updating /home/me/p4/empty-symlink
rename: /home/me/p4/empty-symlink: No such file or directory
and leaves no symlink.
In git, replicate the p4 behavior by ignoring these bad symlinks.
If, in a later p4 revision, the symlink happens to point to
something non-null, the symlink will be replaced properly.
Add a big test for all this too.
This happens to be a regression introduced by 1292df1 (git-p4:
Fix occasional truncation of symlink contents., 2013-08-08) and
appeared first in 1.8.5. But it shows up only in p4 repositories
of dubious character, so can wait for a proper release.
Tested-by: Damien Gérard <damien@iwi.me>
Signed-off-by: Pete Wyckoff <pw@padd.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-01-22 07:16:40 +08:00
if not data :
# Some version of p4 allowed creating a symlink that pointed
# to nothing. This causes p4 errors when checking out such
# a change, and errors here too. Work around it by ignoring
# the bad symlink; hopefully a future change fixes it.
2019-12-14 07:52:40 +08:00
print ( " \n Ignoring empty symlink in %s " % file_path )
git p4: work around p4 bug that causes empty symlinks
Damien Gérard highlights an interesting problem. Some p4
repositories end up with symlinks that have an empty target. It
is not possible to create this with current p4, but they do
indeed exist.
The effect in git p4 is that "p4 print" on the symlink returns an
empty string, confusing the curret symlink-handling code.
Such broken repositories cause problems in p4 as well, even with
no git involved. In p4, syncing to a change that includes a
bogus symlink causes errors:
//depot/empty-symlink - updating /home/me/p4/empty-symlink
rename: /home/me/p4/empty-symlink: No such file or directory
and leaves no symlink.
In git, replicate the p4 behavior by ignoring these bad symlinks.
If, in a later p4 revision, the symlink happens to point to
something non-null, the symlink will be replaced properly.
Add a big test for all this too.
This happens to be a regression introduced by 1292df1 (git-p4:
Fix occasional truncation of symlink contents., 2013-08-08) and
appeared first in 1.8.5. But it shows up only in p4 repositories
of dubious character, so can wait for a proper release.
Tested-by: Damien Gérard <damien@iwi.me>
Signed-off-by: Pete Wyckoff <pw@padd.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-01-22 07:16:40 +08:00
return
elif data [ - 1 ] == ' \n ' :
2013-08-08 21:17:38 +08:00
contents = [ data [ : - 1 ] ]
else :
contents = [ data ]
2009-07-30 07:13:46 +08:00
2011-10-16 22:45:01 +08:00
if type_base == " utf16 " :
2011-09-18 07:16:14 +08:00
# p4 delivers different text in the python output to -G
# than it does when using "print -o", or normal p4 client
# operations. utf16 is converted to ascii or utf8, perhaps.
# But ascii text saved as -t utf16 is completely mangled.
# Invoke print -o to get the real contents.
git p4: scrub crlf for utf16 files on windows
Files of type utf16 are handled with "p4 print" instead of the
normal "p4 -G print" interface due to how the latter does not
produce correct output. See 55aa571 (git-p4: handle utf16
filetype properly, 2011-09-17) for details.
On windows, though, "p4 print" can not be told which line
endings to use, as there is no underlying client, and always
chooses crlf, even for utf16 files. Convert the \r\n into \n
when importing utf16 files.
The fix for this is complex, in that the problem is a property
of the NT version of p4. There are old versions of p4 that
were compiled directly for cygwin that should not be subjected
to text replacement. The right check here, then, is to look
at the p4 version, not the OS version. Note also that on cygwin,
platform.system() is "CYGWIN_NT-5.1" or similar, not "Windows".
Add a function to memoize the p4 version string and use it to
check for "/NT", indicating the Windows build of p4.
Signed-off-by: Pete Wyckoff <pw@padd.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-27 11:11:13 +08:00
#
# On windows, the newlines will always be mangled by print, so put
# them back too. This is not needed to the cygwin windows version,
# just the native "NT" type.
#
2015-09-21 18:01:41 +08:00
try :
2019-12-14 07:52:40 +08:00
text = p4_read_pipe ( [ ' print ' , ' -q ' , ' -o ' , ' - ' , ' %s @ %s ' % ( decode_path ( file [ ' depotFile ' ] ) , file [ ' change ' ] ) ] , raw = True )
2015-09-21 18:01:41 +08:00
except Exception as e :
if ' Translation of file content failed ' in str ( e ) :
type_base = ' binary '
else :
raise e
else :
if p4_version_string ( ) . find ( ' /NT ' ) > = 0 :
2022-07-21 02:17:45 +08:00
text = text . replace ( b ' \x0d \x00 \x0a \x00 ' , b ' \x0a \x00 ' )
2022-04-01 22:24:50 +08:00
contents = [ text ]
2011-09-18 07:16:14 +08:00
2011-11-06 01:36:07 +08:00
if type_base == " apple " :
# Apple filetype files will be streamed as a concatenation of
# its appledouble header and the contents. This is useless
# on both macs and non-macs. If using "print -q -o xx", it
# will create "xx" with the data, and "%xx" with the header.
# This is also not very useful.
#
# Ideally, someday, this script can learn how to generate
# appledouble files directly and import those to git, but
# non-mac machines can never find a use for apple filetype.
2018-06-19 16:04:10 +08:00
print ( " \n Ignoring apple filetype file %s " % file [ ' depotFile ' ] )
2011-11-06 01:36:07 +08:00
return
2022-04-04 13:50:36 +08:00
if type_base == " utf8 " :
# The type utf8 explicitly means utf8 *with BOM*. These are
# streamed just like regular text files, however, without
# the BOM in the stream.
# Therefore, to accurately import these files into git, we
# need to explicitly re-add the BOM before writing.
# 'contents' is a set of bytes in this case, so create the
# BOM prefix as a b'' literal.
contents = [ b ' \xef \xbb \xbf ' + contents [ 0 ] ] + contents [ 1 : ]
2011-09-18 07:16:14 +08:00
# Note that we do not try to de-mangle keywords on utf16 files,
# even though in theory somebody may want that.
2021-12-16 21:46:16 +08:00
regexp = p4_keywords_regexp_for_type ( type_base , type_mods )
if regexp :
git-p4: resolve RCS keywords in bytes not utf-8
RCS keywords are strings that are replaced with information from
Perforce. Examples include $Date$, $Author$, $File$, $Change$ etc.
Perforce resolves these by expanding them with their expanded values
when files are synced, but Git's data model requires these expanded
values to be converted back into their unexpanded form.
Previously, git-p4.py would implement this behaviour through the use of
regular expressions. However, the regular expression substitution was
applied using decoded strings i.e. the content of incoming commit diffs
was first decoded from bytes into UTF-8, processed with regular
expressions, then converted back to bytes.
Not only is this behaviour inefficient, but it is also a cause of a
common issue caused by text files containing invalid UTF-8 data. For
files created in Windows, CP1252 Smart Quote Characters (0x93 and 0x94)
are seen fairly frequently. These codes are invalid in UTF-8, so if the
script encountered any file containing them, on Python 2 the symbols
will be corrupted, and on Python 3 the script will fail with an
exception.
This patch replaces this decoding/encoding with bytes object regular
expressions, so that the substitution is performed directly upon the
source data with no conversions.
A test for smart quote handling has been added to the
t9810-git-p4-rcs.sh test suite.
Signed-off-by: Joel Holdsworth <jholdsworth@nvidia.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-16 21:46:19 +08:00
contents = [ regexp . sub ( br ' $ \ 1$ ' , c ) for c in contents ]
2009-07-30 07:13:46 +08:00
2015-09-26 15:55:03 +08:00
if self . largeFileSystem :
2022-04-01 22:24:52 +08:00
git_mode , contents = self . largeFileSystem . processContent ( git_mode , relPath , contents )
2009-07-30 07:13:46 +08:00
2015-09-26 15:55:03 +08:00
self . writeToGitStream ( git_mode , relPath , contents )
2009-07-30 07:13:46 +08:00
def streamOneP4Deletion ( self , file ) :
2019-12-14 07:52:40 +08:00
relPath = self . stripRepoPath ( decode_path ( file [ ' path ' ] ) , self . branchPrefixes )
2009-07-30 07:13:46 +08:00
if verbose :
2015-09-26 15:55:01 +08:00
sys . stdout . write ( " delete %s \n " % relPath )
sys . stdout . flush ( )
2019-12-14 07:52:38 +08:00
self . gitStream . write ( encode_text_stream ( u ' D {} \n ' . format ( relPath ) ) )
2009-07-30 07:13:46 +08:00
2015-09-26 15:55:03 +08:00
if self . largeFileSystem and self . largeFileSystem . isLargeFile ( relPath ) :
self . largeFileSystem . removeLargeFile ( relPath )
2009-07-30 07:13:46 +08:00
def streamP4FilesCb ( self , marshalled ) :
2022-04-01 22:24:47 +08:00
""" Handle another chunk of streaming data. """
2009-07-30 07:13:46 +08:00
2012-11-24 06:35:36 +08:00
# catch p4 errors and complain
err = None
if " code " in marshalled :
if marshalled [ " code " ] == " error " :
if " data " in marshalled :
err = marshalled [ " data " ] . rstrip ( )
2015-09-26 15:55:02 +08:00
if not err and ' fileSize ' in self . stream_file :
required_bytes = int ( ( 4 * int ( self . stream_file [ " fileSize " ] ) ) - calcDiskFree ( ) )
if required_bytes > 0 :
git-p4: print size values in appropriate units
The git-p4 script reports file sizes in various log messages.
Previously, in each case the script would print them as the number of
bytes divided by 1048576 i.e. the size in mebibytes, rounded down to an
integer. This resulted in small files being described as having a size
of "0 MB".
This patch replaces the existing behaviour with a new helper function:
format_size_human_readable, which takes a number of bytes (or any other
quantity), and computes the appropriate prefix to use: none, Ki, Mi, Gi,
Ti, Pi, Ei, Zi, Yi.
For example, a size of 123456 will now be printed as "120.6 KiB" greatly
improving the readability of the log output.
Large valued prefixes such as pebi, exbi, zebi and yobi are included for
completeness, though they not expected to appear in any real-world
Perforce repository!
Signed-off-by: Joel Holdsworth <jholdsworth@nvidia.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-19 23:40:27 +08:00
err = ' Not enough space left on %s ! Free at least %s . ' % (
os . getcwd ( ) , format_size_human_readable ( required_bytes ) )
2015-09-26 15:55:02 +08:00
2012-11-24 06:35:36 +08:00
if err :
f = None
if self . stream_have_file_info :
if " depotFile " in self . stream_file :
f = self . stream_file [ " depotFile " ]
# force a failure in fast-import, else an empty
# commit will be made
self . gitStream . write ( " \n " )
self . gitStream . write ( " die-now \n " )
self . gitStream . close ( )
# ignore errors, but make sure it exits first
self . importProcess . wait ( )
if f :
die ( " Error from p4 print for %s : %s " % ( f , err ) )
else :
die ( " Error from p4 print: %s " % err )
2018-06-19 16:04:07 +08:00
if ' depotFile ' in marshalled and self . stream_have_file_info :
2011-04-07 14:01:21 +08:00
# start of a new file - output the old one first
self . streamOneP4File ( self . stream_file , self . stream_contents )
self . stream_file = { }
self . stream_contents = [ ]
self . stream_have_file_info = False
2009-07-30 07:13:46 +08:00
2011-04-07 14:01:21 +08:00
# pick up the new file information... for the
# 'data' field we need to append to our array
for k in marshalled . keys ( ) :
if k == ' data ' :
2015-09-26 15:55:01 +08:00
if ' streamContentSize ' not in self . stream_file :
self . stream_file [ ' streamContentSize ' ] = 0
self . stream_file [ ' streamContentSize ' ] + = len ( marshalled [ ' data ' ] )
2011-04-07 14:01:21 +08:00
self . stream_contents . append ( marshalled [ ' data ' ] )
else :
self . stream_file [ k ] = marshalled [ k ]
2009-07-30 07:13:46 +08:00
2015-09-26 15:55:01 +08:00
if ( verbose and
2022-04-01 22:24:59 +08:00
' streamContentSize ' in self . stream_file and
' fileSize ' in self . stream_file and
' depotFile ' in self . stream_file ) :
2015-09-26 15:55:01 +08:00
size = int ( self . stream_file [ " fileSize " ] )
if size > 0 :
progress = 100 * self . stream_file [ ' streamContentSize ' ] / size
git-p4: print size values in appropriate units
The git-p4 script reports file sizes in various log messages.
Previously, in each case the script would print them as the number of
bytes divided by 1048576 i.e. the size in mebibytes, rounded down to an
integer. This resulted in small files being described as having a size
of "0 MB".
This patch replaces the existing behaviour with a new helper function:
format_size_human_readable, which takes a number of bytes (or any other
quantity), and computes the appropriate prefix to use: none, Ki, Mi, Gi,
Ti, Pi, Ei, Zi, Yi.
For example, a size of 123456 will now be printed as "120.6 KiB" greatly
improving the readability of the log output.
Large valued prefixes such as pebi, exbi, zebi and yobi are included for
completeness, though they not expected to appear in any real-world
Perforce repository!
Signed-off-by: Joel Holdsworth <jholdsworth@nvidia.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-19 23:40:27 +08:00
sys . stdout . write ( ' \r %s %d %% ( %s ) ' % (
self . stream_file [ ' depotFile ' ] , progress ,
format_size_human_readable ( size ) ) )
2015-09-26 15:55:01 +08:00
sys . stdout . flush ( )
2011-04-07 14:01:21 +08:00
self . stream_have_file_info = True
2009-07-30 07:13:46 +08:00
def streamP4Files ( self , files ) :
2022-04-01 22:24:47 +08:00
""" Stream directly from " p4 files " into " git fast-import. """
2008-03-03 18:55:48 +08:00
filesForCommit = [ ]
filesToRead = [ ]
2009-07-30 07:13:46 +08:00
filesToDelete = [ ]
2008-03-03 18:55:48 +08:00
2008-02-18 22:22:08 +08:00
for f in files :
2012-01-03 07:05:53 +08:00
filesForCommit . append ( f )
if f [ ' action ' ] in self . delete_actions :
filesToDelete . append ( f )
else :
filesToRead . append ( f )
2007-05-24 05:49:35 +08:00
2009-07-30 07:13:46 +08:00
# deleted files...
for f in filesToDelete :
self . streamOneP4Deletion ( f )
2007-05-24 05:49:35 +08:00
2009-07-30 07:13:46 +08:00
if len ( filesToRead ) > 0 :
self . stream_file = { }
self . stream_contents = [ ]
self . stream_have_file_info = False
2008-03-03 20:42:47 +08:00
2011-04-07 14:01:21 +08:00
# curry self argument
def streamP4FilesCbSelf ( entry ) :
self . streamP4FilesCb ( entry )
2007-05-24 05:49:35 +08:00
2018-05-24 06:20:26 +08:00
fileArgs = [ ]
for f in filesToRead :
if ' shelved_cl ' in f :
# Handle shelved CLs using the "p4 print file@=N" syntax to print
# the contents
2019-12-14 07:52:38 +08:00
fileArg = f [ ' path ' ] + encode_text_stream ( ' @= {} ' . format ( f [ ' shelved_cl ' ] ) )
2018-05-24 06:20:26 +08:00
else :
2019-12-14 07:52:38 +08:00
fileArg = f [ ' path ' ] + encode_text_stream ( ' # {} ' . format ( f [ ' rev ' ] ) )
2018-05-24 06:20:26 +08:00
fileArgs . append ( fileArg )
2011-10-16 22:47:52 +08:00
p4CmdList ( [ " -x " , " - " , " print " ] ,
stdin = fileArgs ,
cb = streamP4FilesCbSelf )
2008-03-03 18:55:48 +08:00
2009-07-30 07:13:46 +08:00
# do the last chunk
2018-06-19 16:04:07 +08:00
if ' depotFile ' in self . stream_file :
2009-07-30 07:13:46 +08:00
self . streamOneP4File ( self . stream_file , self . stream_contents )
2007-05-24 05:49:35 +08:00
2012-01-19 17:52:27 +08:00
def make_email ( self , userid ) :
if userid in self . users :
return self . users [ userid ]
else :
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
userid_bytes = metadata_stream_to_writable_bytes ( userid )
return b " %s <a@b> " % userid_bytes
2012-01-19 17:52:27 +08:00
2012-04-11 23:21:24 +08:00
def streamTag ( self , gitStream , labelName , labelDetails , commit , epoch ) :
2022-04-01 22:24:46 +08:00
""" Stream a p4 tag.
Commit is either a git commit , or a fast - import mark , " :<p4commit> " .
"""
2015-08-27 15:18:58 +08:00
2012-04-11 23:21:24 +08:00
if verbose :
2018-06-19 16:04:10 +08:00
print ( " writing tag %s for commit %s " % ( labelName , commit ) )
2012-04-11 23:21:24 +08:00
gitStream . write ( " tag %s \n " % labelName )
gitStream . write ( " from %s \n " % commit )
2018-06-19 16:04:07 +08:00
if ' Owner ' in labelDetails :
2012-04-11 23:21:24 +08:00
owner = labelDetails [ " Owner " ]
else :
owner = None
# Try to use the owner of the p4 label, or failing that,
# the current p4 user id.
if owner :
email = self . make_email ( owner )
else :
email = self . make_email ( self . p4UserId ( ) )
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
gitStream . write ( " tagger " )
gitStream . write ( email )
gitStream . write ( " %s %s \n " % ( epoch , self . tz ) )
2012-04-11 23:21:24 +08:00
2022-04-01 22:24:53 +08:00
print ( " labelDetails= " , labelDetails )
2018-06-19 16:04:07 +08:00
if ' Description ' in labelDetails :
2012-04-11 23:21:24 +08:00
description = labelDetails [ ' Description ' ]
else :
description = ' Label from git p4 '
gitStream . write ( " data %d \n " % len ( description ) )
gitStream . write ( description )
gitStream . write ( " \n " )
2015-12-08 17:36:22 +08:00
def inClientSpec ( self , path ) :
if not self . clientSpecDirs :
return True
inClientSpec = self . clientSpecDirs . map_in_client ( path )
if not inClientSpec and self . verbose :
print ( ' Ignoring file outside of client spec: {0} ' . format ( path ) )
return inClientSpec
def hasBranchPrefix ( self , path ) :
if not self . branchPrefixes :
return True
hasPrefix = [ p for p in self . branchPrefixes
if p4PathStartsWith ( path , p ) ]
2016-06-22 17:26:11 +08:00
if not hasPrefix and self . verbose :
2015-12-08 17:36:22 +08:00
print ( ' Ignoring file outside of prefix: {0} ' . format ( path ) )
return hasPrefix
2020-05-10 18:16:50 +08:00
def findShadowedFiles ( self , files , change ) :
2022-04-01 22:24:47 +08:00
""" Perforce allows you commit files and directories with the same name,
so you could have files / / depot / foo and / / depot / foo / bar both checked
in . A p4 sync of a repository in this state fails . Deleting one of
the files recovers the repository .
Git will not allow the broken state to exist and only the most
recent of the conflicting names is left in the repository . When one
of the conflicting files is deleted we need to re - add the other one
to make sure the git repository recovers in the same way as
perforce .
"""
2020-05-10 18:16:50 +08:00
deleted = [ f for f in files if f [ ' action ' ] in self . delete_actions ]
to_check = set ( )
for f in deleted :
path = decode_path ( f [ ' path ' ] )
to_check . add ( path + ' /... ' )
while True :
path = path . rsplit ( " / " , 1 ) [ 0 ]
if path == " / " or path in to_check :
break
to_check . add ( path )
to_check = [ ' %s @ %s ' % ( wildcard_encode ( p ) , change ) for p in to_check
if self . hasBranchPrefix ( p ) ]
if to_check :
stat_result = p4CmdList ( [ " -x " , " - " , " fstat " , " -T " ,
" depotFile,headAction,headRev,headType " ] , stdin = to_check )
for record in stat_result :
if record [ ' code ' ] != ' stat ' :
continue
if record [ ' headAction ' ] in self . delete_actions :
continue
files . append ( {
' action ' : ' add ' ,
' path ' : record [ ' depotFile ' ] ,
' rev ' : record [ ' headRev ' ] ,
' type ' : record [ ' headType ' ] } )
2022-04-01 22:24:51 +08:00
def commit ( self , details , files , branch , parent = " " , allow_empty = False ) :
2007-03-21 03:54:23 +08:00
epoch = details [ " time " ]
author = details [ " user " ]
2016-04-20 03:49:41 +08:00
jobs = self . extractJobsFromCommit ( details )
2007-03-21 03:54:23 +08:00
2007-05-19 03:45:23 +08:00
if self . verbose :
2015-12-08 17:36:22 +08:00
print ( ' commit into {0} ' . format ( branch ) )
2007-05-24 05:49:35 +08:00
2020-05-10 18:16:50 +08:00
files = [ f for f in files
if self . hasBranchPrefix ( decode_path ( f [ ' path ' ] ) ) ]
self . findShadowedFiles ( files , details [ ' change ' ] )
2013-08-30 18:02:06 +08:00
if self . clientSpecDirs :
self . clientSpecDirs . update_client_spec_path_cache ( files )
2020-05-10 18:16:50 +08:00
files = [ f for f in files if self . inClientSpec ( decode_path ( f [ ' path ' ] ) ) ]
2015-12-08 17:36:22 +08:00
2018-10-15 19:14:08 +08:00
if gitConfigBool ( ' git-p4.keepEmptyCommits ' ) :
allow_empty = True
if not files and not allow_empty :
2015-12-08 17:36:22 +08:00
print ( ' Ignoring revision {0} as it would produce an empty commit. '
. format ( details [ ' change ' ] ) )
return
2007-03-21 03:54:23 +08:00
self . gitStream . write ( " commit %s \n " % branch )
2015-08-27 15:18:58 +08:00
self . gitStream . write ( " mark : %s \n " % details [ " change " ] )
2007-03-21 03:54:23 +08:00
self . committedChanges . add ( int ( details [ " change " ] ) )
2007-05-20 16:55:54 +08:00
if author not in self . users :
self . getUserMapFromPerforceServer ( )
2007-03-21 03:54:23 +08:00
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
self . gitStream . write ( " committer " )
self . gitStream . write ( self . make_email ( author ) )
self . gitStream . write ( " %s %s \n " % ( epoch , self . tz ) )
2007-03-21 03:54:23 +08:00
self . gitStream . write ( " data <<EOT \n " )
self . gitStream . write ( details [ " desc " ] )
2016-04-20 03:49:41 +08:00
if len ( jobs ) > 0 :
self . gitStream . write ( " \n Jobs: %s " % ( ' ' . join ( jobs ) ) )
2018-05-24 06:20:26 +08:00
if not self . suppress_meta_comment :
self . gitStream . write ( " \n [git-p4: depot-paths = \" %s \" : change = %s " %
( ' , ' . join ( self . branchPrefixes ) , details [ " change " ] ) )
if len ( details [ ' options ' ] ) > 0 :
self . gitStream . write ( " : options = %s " % details [ ' options ' ] )
self . gitStream . write ( " ] \n " )
self . gitStream . write ( " EOT \n \n " )
2007-03-21 03:54:23 +08:00
if len ( parent ) > 0 :
2007-05-19 03:45:23 +08:00
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " parent %s " % parent )
2007-03-21 03:54:23 +08:00
self . gitStream . write ( " from %s \n " % parent )
2015-12-08 17:36:22 +08:00
self . streamP4Files ( files )
2007-03-21 03:54:23 +08:00
self . gitStream . write ( " \n " )
2007-03-27 04:34:34 +08:00
change = int ( details [ " change " ] )
2018-06-19 16:04:07 +08:00
if change in self . labels :
2007-03-27 04:34:34 +08:00
label = self . labels [ change ]
labelDetails = label [ 0 ]
labelRevisions = label [ 1 ]
2007-05-19 17:54:11 +08:00
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " Change %s is labelled %s " % ( change , labelDetails ) )
2007-03-27 04:34:34 +08:00
2011-10-16 22:47:52 +08:00
files = p4CmdList ( [ " files " ] + [ " %s ...@ %s " % ( p , change )
2012-08-12 00:55:02 +08:00
for p in self . branchPrefixes ] )
2007-03-27 04:34:34 +08:00
if len ( files ) == len ( labelRevisions ) :
cleanedFiles = { }
for info in files :
2011-02-19 21:17:57 +08:00
if info [ " action " ] in self . delete_actions :
2007-03-27 04:34:34 +08:00
continue
cleanedFiles [ info [ " depotFile " ] ] = info [ " rev " ]
if cleanedFiles == labelRevisions :
2012-04-11 23:21:24 +08:00
self . streamTag ( self . gitStream , ' tag_ %s ' % labelDetails [ ' label ' ] , labelDetails , branch , epoch )
2007-03-27 04:34:34 +08:00
else :
2007-03-28 23:05:38 +08:00
if not self . silent :
2018-06-19 16:04:10 +08:00
print ( " Tag %s does not match with change %s : files do not match. "
2007-05-24 03:53:11 +08:00
% ( labelDetails [ " label " ] , change ) )
2007-03-27 04:34:34 +08:00
else :
2007-03-28 23:05:38 +08:00
if not self . silent :
2018-06-19 16:04:10 +08:00
print ( " Tag %s does not match with change %s : file count is different. "
2007-05-24 03:53:11 +08:00
% ( labelDetails [ " label " ] , change ) )
2007-03-21 03:54:23 +08:00
2007-03-27 04:34:34 +08:00
def getLabels ( self ) :
2022-04-01 22:24:47 +08:00
""" Build a dictionary of changelists and labels, for " detect-labels "
option .
"""
2007-03-27 04:34:34 +08:00
self . labels = { }
2012-01-19 17:52:25 +08:00
l = p4CmdList ( [ " labels " ] + [ " %s ... " % p for p in self . depotPaths ] )
2007-04-08 16:15:47 +08:00
if len ( l ) > 0 and not self . silent :
2018-06-19 16:04:08 +08:00
print ( " Finding files belonging to labels in %s " % self . depotPaths )
2007-04-08 05:46:50 +08:00
for output in l :
2007-03-27 04:34:34 +08:00
label = output [ " label " ]
revisions = { }
newestChange = 0
2007-05-19 17:54:11 +08:00
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " Querying files for label %s " % label )
2011-10-16 22:47:52 +08:00
for file in p4CmdList ( [ " files " ] +
[ " %s ...@ %s " % ( p , label )
for p in self . depotPaths ] ) :
2007-03-27 04:34:34 +08:00
revisions [ file [ " depotFile " ] ] = file [ " rev " ]
change = int ( file [ " change " ] )
if change > newestChange :
newestChange = change
2007-05-19 18:05:40 +08:00
self . labels [ newestChange ] = [ output , revisions ]
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " Label changes: %s " % self . labels . keys ( ) )
2007-03-27 04:34:34 +08:00
2012-04-11 23:21:24 +08:00
def importP4Labels ( self , stream , p4Labels ) :
2022-04-01 22:24:47 +08:00
""" Import p4 labels as git tags. A direct mapping does not exist, so
assume that if all the files are at the same revision then we can
use that , or it ' s something more complicated we should just ignore.
"""
2012-04-11 23:21:24 +08:00
if verbose :
2018-06-19 16:04:10 +08:00
print ( " import p4 labels: " + ' ' . join ( p4Labels ) )
2012-04-11 23:21:24 +08:00
ignoredP4Labels = gitConfigList ( " git-p4.ignoredP4Labels " )
2012-04-11 23:21:24 +08:00
validLabelRegexp = gitConfig ( " git-p4.labelImportRegexp " )
2012-04-11 23:21:24 +08:00
if len ( validLabelRegexp ) == 0 :
validLabelRegexp = defaultLabelRegexp
m = re . compile ( validLabelRegexp )
for name in p4Labels :
commitFound = False
if not m . match ( name ) :
if verbose :
2022-04-01 22:24:53 +08:00
print ( " label %s does not match regexp %s " % ( name , validLabelRegexp ) )
2012-04-11 23:21:24 +08:00
continue
if name in ignoredP4Labels :
continue
labelDetails = p4CmdList ( [ ' label ' , " -o " , name ] ) [ 0 ]
# get the most recent changelist for each file in this label
change = p4Cmd ( [ " changes " , " -m " , " 1 " ] + [ " %s ...@ %s " % ( p , name )
for p in self . depotPaths ] )
2018-06-19 16:04:07 +08:00
if ' change ' in change :
2012-04-11 23:21:24 +08:00
# find the corresponding git commit; take the oldest commit
changelist = int ( change [ ' change ' ] )
2015-08-27 15:18:58 +08:00
if changelist in self . committedChanges :
gitCommit = " : %d " % changelist # use a fast-import mark
2012-04-11 23:21:24 +08:00
commitFound = True
2015-08-27 15:18:58 +08:00
else :
gitCommit = read_pipe ( [ " git " , " rev-list " , " --max-count=1 " ,
" --reverse " , " :/ \ [git-p4:.*change = %d \ ] " % changelist ] , ignore_error = True )
if len ( gitCommit ) == 0 :
2018-06-19 16:04:10 +08:00
print ( " importing label %s : could not find git commit for changelist %d " % ( name , changelist ) )
2015-08-27 15:18:58 +08:00
else :
commitFound = True
gitCommit = gitCommit . strip ( )
if commitFound :
2012-04-11 23:21:24 +08:00
# Convert from p4 time format
try :
tmwhen = time . strptime ( labelDetails [ ' Update ' ] , " % Y/ % m/ %d % H: % M: % S " )
except ValueError :
2018-06-19 16:04:10 +08:00
print ( " Could not convert label time %s " % labelDetails [ ' Update ' ] )
2012-04-11 23:21:24 +08:00
tmwhen = 1
when = int ( time . mktime ( tmwhen ) )
self . streamTag ( stream , name , labelDetails , gitCommit , when )
if verbose :
2018-06-19 16:04:10 +08:00
print ( " p4 label %s mapped to git commit %s " % ( name , gitCommit ) )
2012-04-11 23:21:24 +08:00
else :
if verbose :
2018-06-19 16:04:10 +08:00
print ( " Label %s has no changelists - possibly deleted? " % name )
2012-04-11 23:21:24 +08:00
if not commitFound :
# We can't import this label; don't try again as it will get very
# expensive repeatedly fetching all the files for labels that will
# never be imported. If the label is moved in the future, the
# ignore will need to be removed manually.
system ( [ " git " , " config " , " --add " , " git-p4.ignoredP4Labels " , name ] )
2007-05-24 05:49:35 +08:00
def guessProjectName ( self ) :
for p in self . depotPaths :
2007-06-11 14:50:57 +08:00
if p . endswith ( " / " ) :
p = p [ : - 1 ]
p = p [ p . strip ( ) . rfind ( " / " ) + 1 : ]
if not p . endswith ( " / " ) :
2022-04-01 22:24:45 +08:00
p + = " / "
2007-06-11 14:50:57 +08:00
return p
2007-05-24 05:49:35 +08:00
2007-05-19 03:45:23 +08:00
def getBranchMapping ( self ) :
2007-06-17 17:25:34 +08:00
lostAndFoundBranches = set ( )
2011-08-19 07:44:04 +08:00
user = gitConfig ( " git-p4.branchUser " )
2022-01-07 05:40:34 +08:00
for info in p4CmdList (
[ " branches " ] + ( [ " -u " , user ] if len ( user ) > 0 else [ ] ) ) :
2012-01-19 17:52:25 +08:00
details = p4Cmd ( [ " branch " , " -o " , info [ " branch " ] ] )
2007-05-19 03:45:23 +08:00
viewIdx = 0
2018-06-19 16:04:07 +08:00
while " View %s " % viewIdx in details :
2007-05-19 03:45:23 +08:00
paths = details [ " View %s " % viewIdx ] . split ( " " )
viewIdx = viewIdx + 1
# require standard //depot/foo/... //depot/bar/... mapping
if len ( paths ) != 2 or not paths [ 0 ] . endswith ( " /... " ) or not paths [ 1 ] . endswith ( " /... " ) :
continue
source = paths [ 0 ]
destination = paths [ 1 ]
2022-04-01 22:24:57 +08:00
# HACK
2011-03-15 20:08:02 +08:00
if p4PathStartsWith ( source , self . depotPaths [ 0 ] ) and p4PathStartsWith ( destination , self . depotPaths [ 0 ] ) :
2007-06-07 15:41:53 +08:00
source = source [ len ( self . depotPaths [ 0 ] ) : - 4 ]
destination = destination [ len ( self . depotPaths [ 0 ] ) : - 4 ]
2007-06-17 17:25:34 +08:00
2007-06-17 21:10:24 +08:00
if destination in self . knownBranches :
if not self . silent :
2018-06-19 16:04:10 +08:00
print ( " p4 branch %s defines a mapping from %s to %s " % ( info [ " branch " ] , source , destination ) )
print ( " but there exists another mapping from %s to %s already! " % ( self . knownBranches [ destination ] , destination ) )
2007-06-17 21:10:24 +08:00
continue
2007-06-17 17:25:34 +08:00
self . knownBranches [ destination ] = source
lostAndFoundBranches . discard ( destination )
2007-05-19 16:23:12 +08:00
if source not in self . knownBranches :
2007-06-17 17:25:34 +08:00
lostAndFoundBranches . add ( source )
2011-08-19 07:44:05 +08:00
# Perforce does not strictly require branches to be defined, so we also
# check git config for a branch list.
#
# Example of branch definition in git config file:
# [git-p4]
# branchList=main:branchA
# branchList=main:branchB
# branchList=branchA:branchC
configBranches = gitConfigList ( " git-p4.branchList " )
for branch in configBranches :
if branch :
2022-04-01 22:24:52 +08:00
source , destination = branch . split ( " : " )
2011-08-19 07:44:05 +08:00
self . knownBranches [ destination ] = source
lostAndFoundBranches . discard ( destination )
if source not in self . knownBranches :
lostAndFoundBranches . add ( source )
2007-06-17 17:25:34 +08:00
for branch in lostAndFoundBranches :
self . knownBranches [ branch ] = branch
2007-05-19 16:23:12 +08:00
2007-11-15 17:38:45 +08:00
def getBranchMappingFromGitBranches ( self ) :
branches = p4BranchesInGit ( self . importIntoRemotes )
for branch in branches . keys ( ) :
if branch == " master " :
branch = " main "
else :
branch = branch [ len ( self . projectName ) : ]
self . knownBranches [ branch ] = branch
2007-05-24 05:49:35 +08:00
def updateOptionDict ( self , d ) :
option_keys = { }
if self . keepRepoPath :
option_keys [ ' keepRepoPath ' ] = 1
d [ " options " ] = ' ' . join ( sorted ( option_keys . keys ( ) ) )
def readOptions ( self , d ) :
2018-06-19 16:04:07 +08:00
self . keepRepoPath = ( ' options ' in d
2007-05-24 05:49:35 +08:00
and ( ' keepRepoPath ' in d [ ' options ' ] ) )
2007-05-24 05:49:35 +08:00
2007-08-26 22:44:55 +08:00
def gitRefForBranch ( self , branch ) :
if branch == " main " :
return self . refPrefix + " master "
if len ( branch ) < = 0 :
return branch
return self . refPrefix + self . projectName + branch
2007-08-26 23:36:55 +08:00
def gitCommitByP4Change ( self , ref , change ) :
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " looking in ref " + ref + " for change %s using bisect... " % change )
2007-08-26 23:36:55 +08:00
earliestCommit = " "
latestCommit = parseRevision ( ref )
while True :
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " trying: earliest %s latest %s " % ( earliestCommit , latestCommit ) )
2022-01-07 05:40:34 +08:00
next = read_pipe ( [ " git " , " rev-list " , " --bisect " ,
latestCommit , earliestCommit ] ) . strip ( )
2007-08-26 23:36:55 +08:00
if len ( next ) == 0 :
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " argh " )
2007-08-26 23:36:55 +08:00
return " "
log = extractLogMessageFromGitCommit ( next )
settings = extractSettingsGitLog ( log )
currentChange = int ( settings [ ' change ' ] )
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " current change %s " % currentChange )
2007-08-26 23:36:55 +08:00
if currentChange == change :
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " found %s " % next )
2007-08-26 23:36:55 +08:00
return next
if currentChange < change :
earliestCommit = " ^ %s " % next
else :
2019-04-02 02:02:17 +08:00
if next == latestCommit :
die ( " Infinite loop while looking in ref %s for change %s . Check your branch mappings " % ( ref , change ) )
latestCommit = " %s ^@ " % next
2007-08-26 23:36:55 +08:00
return " "
def importNewBranch ( self , branch , maxChange ) :
# make fast-import flush all changes to disk and update the refs using the checkpoint
# command so that we can try to find the branch parent in the git history
2022-04-01 22:24:44 +08:00
self . gitStream . write ( " checkpoint \n \n " )
self . gitStream . flush ( )
2007-08-26 23:36:55 +08:00
branchPrefix = self . depotPaths [ 0 ] + branch + " / "
range = " @1, %s " % maxChange
2015-04-20 23:00:20 +08:00
changes = p4ChangesForPaths ( [ branchPrefix ] , range , self . changes_block_size )
2007-08-26 23:36:55 +08:00
if len ( changes ) < = 0 :
return False
firstChange = changes [ 0 ]
sourceBranch = self . knownBranches [ branch ]
sourceDepotPath = self . depotPaths [ 0 ] + sourceBranch
sourceRef = self . gitRefForBranch ( sourceBranch )
2012-01-19 17:52:25 +08:00
branchParentChange = int ( p4Cmd ( [ " changes " , " -m " , " 1 " , " %s ...@1, %s " % ( sourceDepotPath , firstChange ) ] ) [ " change " ] )
2007-08-26 23:36:55 +08:00
gitParent = self . gitCommitByP4Change ( sourceRef , branchParentChange )
if len ( gitParent ) > 0 :
self . initialParents [ self . gitRefForBranch ( branch ) ] = gitParent
self . importChanges ( changes )
return True
2012-01-26 07:48:22 +08:00
def searchParent ( self , parent , branch , target ) :
2021-05-05 19:56:26 +08:00
targetTree = read_pipe ( [ " git " , " rev-parse " ,
" {} ^ {{ tree}} " . format ( target ) ] ) . strip ( )
for line in read_pipe_lines ( [ " git " , " rev-list " , " --format= % H % T " ,
2013-01-27 11:11:21 +08:00
" --no-merges " , parent ] ) :
2021-05-05 19:56:26 +08:00
if line . startswith ( " commit " ) :
continue
commit , tree = line . strip ( ) . split ( " " )
if tree == targetTree :
2012-01-26 07:48:22 +08:00
if self . verbose :
2021-05-05 19:56:26 +08:00
print ( " Found parent of %s in commit %s " % ( branch , commit ) )
return commit
return None
2012-01-26 07:48:22 +08:00
2018-10-15 19:14:08 +08:00
def importChanges ( self , changes , origin_revision = 0 ) :
2007-08-26 22:00:52 +08:00
cnt = 1
for change in changes :
2018-10-15 19:14:08 +08:00
description = p4_describe ( change )
2007-08-26 22:00:52 +08:00
self . updateOptionDict ( description )
if not self . silent :
2021-12-19 23:40:28 +08:00
sys . stdout . write ( " \r Importing revision %s ( %d %% ) " % (
change , ( cnt * 100 ) / / len ( changes ) ) )
2007-08-26 22:00:52 +08:00
sys . stdout . flush ( )
cnt = cnt + 1
try :
if self . detectBranches :
branches = self . splitFilesIntoBranches ( description )
for branch in branches . keys ( ) :
2022-04-01 22:24:57 +08:00
# HACK --hwn
2007-08-26 22:00:52 +08:00
branchPrefix = self . depotPaths [ 0 ] + branch + " / "
2022-04-01 22:24:50 +08:00
self . branchPrefixes = [ branchPrefix ]
2007-08-26 22:00:52 +08:00
parent = " "
filesForCommit = branches [ branch ]
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " branch is %s " % branch )
2007-08-26 22:00:52 +08:00
self . updatedBranches . add ( branch )
if branch not in self . createdBranches :
self . createdBranches . add ( branch )
parent = self . knownBranches [ branch ]
if parent == branch :
parent = " "
2007-08-26 23:36:55 +08:00
else :
fullBranch = self . projectName + branch
if fullBranch not in self . p4BranchesInGit :
if not self . silent :
2022-04-01 22:24:44 +08:00
print ( " \n Importing new branch %s " % fullBranch )
2007-08-26 23:36:55 +08:00
if self . importNewBranch ( branch , change - 1 ) :
parent = " "
self . p4BranchesInGit . append ( fullBranch )
if not self . silent :
2022-04-01 22:24:44 +08:00
print ( " \n Resuming with change %s " % change )
2007-08-26 23:36:55 +08:00
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " parent determined through known branches: %s " % parent )
2007-08-26 22:00:52 +08:00
2007-08-26 22:44:55 +08:00
branch = self . gitRefForBranch ( branch )
parent = self . gitRefForBranch ( parent )
2007-08-26 22:00:52 +08:00
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " looking for initial parent for %s ; current parent is %s " % ( branch , parent ) )
2007-08-26 22:00:52 +08:00
if len ( parent ) == 0 and branch in self . initialParents :
parent = self . initialParents [ branch ]
del self . initialParents [ branch ]
2012-01-26 07:48:22 +08:00
blob = None
if len ( parent ) > 0 :
2013-01-27 11:11:04 +08:00
tempBranch = " %s / %d " % ( self . tempBranchLocation , change )
2012-01-26 07:48:22 +08:00
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " Creating temporary branch: " + tempBranch )
2012-08-12 00:55:02 +08:00
self . commit ( description , filesForCommit , tempBranch )
2012-01-26 07:48:22 +08:00
self . tempBranches . append ( tempBranch )
self . checkpoint ( )
blob = self . searchParent ( parent , branch , tempBranch )
if blob :
2012-08-12 00:55:02 +08:00
self . commit ( description , filesForCommit , branch , blob )
2012-01-26 07:48:22 +08:00
else :
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " Parent of %s not found. Committing into head of %s " % ( branch , parent ) )
2012-08-12 00:55:02 +08:00
self . commit ( description , filesForCommit , branch , parent )
2007-08-26 22:00:52 +08:00
else :
2018-10-15 19:14:08 +08:00
files = self . extractFilesFromCommit ( description )
2012-08-12 00:55:02 +08:00
self . commit ( description , files , self . branch ,
2007-08-26 22:00:52 +08:00
self . initialParent )
2013-01-15 08:47:04 +08:00
# only needed once, to connect to the previous commit
2007-08-26 22:00:52 +08:00
self . initialParent = " "
except IOError :
2018-06-19 16:04:10 +08:00
print ( self . gitError . read ( ) )
2007-08-26 22:00:52 +08:00
sys . exit ( 1 )
2018-06-09 04:32:44 +08:00
def sync_origin_only ( self ) :
if self . syncWithOrigin :
self . hasOrigin = originP4BranchesExist ( )
if self . hasOrigin :
if not self . silent :
2018-06-19 16:04:10 +08:00
print ( ' Syncing with origin first, using " git fetch origin " ' )
2022-01-07 05:40:34 +08:00
system ( [ " git " , " fetch " , " origin " ] )
2018-06-09 04:32:44 +08:00
2007-08-26 22:07:18 +08:00
def importHeadRevision ( self , revision ) :
2018-06-19 16:04:10 +08:00
print ( " Doing initial import of %s from revision %s into %s " % ( ' ' . join ( self . depotPaths ) , revision , self . branch ) )
2007-08-26 22:07:18 +08:00
2011-07-31 21:45:55 +08:00
details = { }
details [ " user " ] = " git perforce import user "
2011-02-19 21:17:56 +08:00
details [ " desc " ] = ( " Initial import of %s from the state at revision %s \n "
2007-08-26 22:07:18 +08:00
% ( ' ' . join ( self . depotPaths ) , revision ) )
details [ " change " ] = revision
newestRevision = 0
fileCnt = 0
2022-04-01 22:24:53 +08:00
fileArgs = [ " %s ... %s " % ( p , revision ) for p in self . depotPaths ]
2011-10-16 22:47:52 +08:00
for info in p4CmdList ( [ " files " ] + fileArgs ) :
2007-08-26 22:07:18 +08:00
2011-02-19 21:17:55 +08:00
if ' code ' in info and info [ ' code ' ] == ' error ' :
2007-08-26 22:07:18 +08:00
sys . stderr . write ( " p4 returned an error: %s \n "
% info [ ' data ' ] )
2011-02-19 21:17:58 +08:00
if info [ ' data ' ] . find ( " must refer to client " ) > = 0 :
sys . stderr . write ( " This particular p4 error is misleading. \n " )
2022-04-01 22:24:44 +08:00
sys . stderr . write ( " Perhaps the depot path was misspelled. \n " )
2011-02-19 21:17:58 +08:00
sys . stderr . write ( " Depot path: %s \n " % " " . join ( self . depotPaths ) )
2007-08-26 22:07:18 +08:00
sys . exit ( 1 )
2011-02-19 21:17:55 +08:00
if ' p4ExitCode ' in info :
sys . stderr . write ( " p4 exitcode: %s \n " % info [ ' p4ExitCode ' ] )
2007-08-26 22:07:18 +08:00
sys . exit ( 1 )
change = int ( info [ " change " ] )
if change > newestRevision :
newestRevision = change
2011-02-19 21:17:57 +08:00
if info [ " action " ] in self . delete_actions :
2007-08-26 22:07:18 +08:00
continue
2022-04-01 22:24:50 +08:00
for prop in [ " depotFile " , " rev " , " action " , " type " ] :
2007-08-26 22:07:18 +08:00
details [ " %s %s " % ( prop , fileCnt ) ] = info [ prop ]
fileCnt = fileCnt + 1
details [ " change " ] = newestRevision
2011-07-31 21:45:55 +08:00
2012-04-09 08:18:01 +08:00
# Use time from top-most change so that all git p4 clones of
2011-07-31 21:45:55 +08:00
# the same p4 repo have the same commit SHA1s.
2012-11-24 06:35:34 +08:00
res = p4_describe ( newestRevision )
details [ " time " ] = res [ " time " ]
2011-07-31 21:45:55 +08:00
2007-08-26 22:07:18 +08:00
self . updateOptionDict ( details )
try :
2012-08-12 00:55:02 +08:00
self . commit ( details , self . extractFilesFromCommit ( details ) , self . branch )
2019-08-27 11:43:58 +08:00
except IOError as err :
2018-06-19 16:04:10 +08:00
print ( " IO error with git fast-import. Is your git version recent enough? " )
2019-08-27 11:43:58 +08:00
print ( " IO error details: {} " . format ( err ) )
2018-06-19 16:04:10 +08:00
print ( self . gitError . read ( ) )
2007-08-26 22:07:18 +08:00
2020-01-29 19:12:44 +08:00
def importRevisions ( self , args , branch_arg_given ) :
changes = [ ]
if len ( self . changesFile ) > 0 :
2020-01-30 19:50:34 +08:00
with open ( self . changesFile ) as f :
output = f . readlines ( )
2020-01-29 19:12:44 +08:00
changeSet = set ( )
for line in output :
changeSet . add ( int ( line ) )
for change in changeSet :
changes . append ( change )
changes . sort ( )
else :
# catch "git p4 sync" with no new branches, in a repo that
# does not have any existing p4 branches
if len ( args ) == 0 :
if not self . p4BranchesInGit :
2020-01-29 19:12:45 +08:00
raise P4CommandException ( " No remote p4 branches. Perhaps you never did \" git p4 clone \" in here. " )
2020-01-29 19:12:44 +08:00
# The default branch is master, unless --branch is used to
# specify something else. Make sure it exists, or complain
# nicely about how to use --branch.
if not self . detectBranches :
if not branch_exists ( self . branch ) :
if branch_arg_given :
2020-01-29 19:12:45 +08:00
raise P4CommandException ( " Error: branch %s does not exist. " % self . branch )
2020-01-29 19:12:44 +08:00
else :
2020-01-29 19:12:45 +08:00
raise P4CommandException ( " Error: no branch %s ; perhaps specify one with --branch. " %
2020-01-29 19:12:44 +08:00
self . branch )
if self . verbose :
print ( " Getting p4 changes for %s ... %s " % ( ' , ' . join ( self . depotPaths ) ,
self . changeRange ) )
changes = p4ChangesForPaths ( self . depotPaths , self . changeRange , self . changes_block_size )
if len ( self . maxChanges ) > 0 :
changes = changes [ : min ( int ( self . maxChanges ) , len ( changes ) ) ]
if len ( changes ) == 0 :
if not self . silent :
print ( " No changes to import! " )
else :
if not self . silent and not self . detectBranches :
print ( " Import destination: %s " % self . branch )
self . updatedBranches = set ( )
if not self . detectBranches :
if args :
# start a new branch
self . initialParent = " "
else :
# build on a previous revision
self . initialParent = parseRevision ( self . branch )
self . importChanges ( changes )
if not self . silent :
print ( " " )
if len ( self . updatedBranches ) > 0 :
sys . stdout . write ( " Updated branches: " )
for b in self . updatedBranches :
sys . stdout . write ( " %s " % b )
sys . stdout . write ( " \n " )
2018-05-24 06:20:26 +08:00
def openStreams ( self ) :
self . importProcess = subprocess . Popen ( [ " git " , " fast-import " ] ,
stdin = subprocess . PIPE ,
stdout = subprocess . PIPE ,
2022-04-01 22:24:44 +08:00
stderr = subprocess . PIPE )
2018-05-24 06:20:26 +08:00
self . gitOutput = self . importProcess . stdout
self . gitStream = self . importProcess . stdin
self . gitError = self . importProcess . stderr
2007-08-26 22:07:18 +08:00
2019-12-14 07:52:39 +08:00
if bytes is not str :
# Wrap gitStream.write() so that it can be called using `str` arguments
def make_encoded_write ( write ) :
def encoded_write ( s ) :
return write ( s . encode ( ) if isinstance ( s , str ) else s )
return encoded_write
self . gitStream . write = make_encoded_write ( self . gitStream . write )
2018-05-24 06:20:26 +08:00
def closeStreams ( self ) :
2020-01-29 19:12:41 +08:00
if self . gitStream is None :
return
2018-05-24 06:20:26 +08:00
self . gitStream . close ( )
if self . importProcess . wait ( ) != 0 :
die ( " fast-import failed: %s " % self . gitError . read ( ) )
self . gitOutput . close ( )
self . gitError . close ( )
2020-01-29 19:12:41 +08:00
self . gitStream = None
2007-05-19 16:23:12 +08:00
2018-05-24 06:20:26 +08:00
def run ( self , args ) :
2007-05-23 06:03:08 +08:00
if self . importIntoRemotes :
self . refPrefix = " refs/remotes/p4/ "
else :
2007-06-07 21:13:59 +08:00
self . refPrefix = " refs/heads/p4/ "
2007-05-23 06:03:08 +08:00
2018-06-09 04:32:44 +08:00
self . sync_origin_only ( )
2007-05-25 04:28:28 +08:00
2013-01-15 08:47:05 +08:00
branch_arg_given = bool ( self . branch )
2007-03-23 04:34:16 +08:00
if len ( self . branch ) == 0 :
2007-06-07 21:13:59 +08:00
self . branch = self . refPrefix + " master "
2007-05-23 06:03:08 +08:00
if gitBranchExists ( " refs/heads/p4 " ) and self . importIntoRemotes :
2022-01-07 05:40:34 +08:00
system ( [ " git " , " update-ref " , self . branch , " refs/heads/p4 " ] )
system ( [ " git " , " branch " , " -D " , " p4 " ] )
2007-03-23 16:30:41 +08:00
2012-02-26 09:06:24 +08:00
# accept either the command-line option, or the configuration variable
if self . useClientSpec :
# will use this after clone to set the variable
self . useClientSpec_from_options = True
else :
2013-01-27 11:11:24 +08:00
if gitConfigBool ( " git-p4.useclientspec " ) :
2011-12-25 10:07:39 +08:00
self . useClientSpec = True
if self . useClientSpec :
2012-02-26 09:06:25 +08:00
self . clientSpecDirs = getClientSpec ( )
2008-02-18 22:22:08 +08:00
2007-05-24 05:49:35 +08:00
# TODO: should always look at previous commits,
# merge with previous imports, if possible.
if args == [ ] :
2007-05-25 17:36:42 +08:00
if self . hasOrigin :
2007-08-24 23:44:16 +08:00
createOrUpdateBranchesFromOrigin ( self . refPrefix , self . silent )
2013-01-15 08:46:58 +08:00
# branches holds mapping from branch name to sha1
branches = p4BranchesInGit ( self . importIntoRemotes )
2013-01-15 08:47:06 +08:00
# restrict to just this one, disabling detect-branches
if branch_arg_given :
git-p4: support explicit sync of arbitrary existing git-p4 refs
With the --branch argument of the "sync" subcommand, git-p4 enables
you to import a perforce branch/path to an arbitrary git ref, using
a full ref path, or to refs/remotes/p4/* or refs/heads/p4/*,
depending on --import-local, using a short ref name.
However, when you later want to explicitly sync such a given ref to
pick up subsequent p4 changes, it only works if the ref was placed
in the p4 path *and* has only one path component (no "/").
This limitation results from a bad assumption in the
existing-branch sync logic, and also means you cannot individually
sync branches detected by --detect-branches, as these also get a
"/" in their names.
Fix "git p4 sync --branch", when called with an existing ref, so
that it works correctly regardless of whether the ref is in the p4
path or not, and (in the case of refs in the p4 path) regardless of
whether it has a "/" in its short name or not.
Also add tests to validate that these branch-specific syncs work
as expected.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-04-04 13:10:54 +08:00
short = shortP4Ref ( self . branch , self . importIntoRemotes )
2013-01-15 08:47:06 +08:00
if short in branches :
2022-04-01 22:24:50 +08:00
self . p4BranchesInGit = [ short ]
git-p4: support explicit sync of arbitrary existing git-p4 refs
With the --branch argument of the "sync" subcommand, git-p4 enables
you to import a perforce branch/path to an arbitrary git ref, using
a full ref path, or to refs/remotes/p4/* or refs/heads/p4/*,
depending on --import-local, using a short ref name.
However, when you later want to explicitly sync such a given ref to
pick up subsequent p4 changes, it only works if the ref was placed
in the p4 path *and* has only one path component (no "/").
This limitation results from a bad assumption in the
existing-branch sync logic, and also means you cannot individually
sync branches detected by --detect-branches, as these also get a
"/" in their names.
Fix "git p4 sync --branch", when called with an existing ref, so
that it works correctly regardless of whether the ref is in the p4
path or not, and (in the case of refs in the p4 path) regardless of
whether it has a "/" in its short name or not.
Also add tests to validate that these branch-specific syncs work
as expected.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-04-04 13:10:54 +08:00
elif self . branch . startswith ( ' refs/ ' ) and \
branchExists ( self . branch ) and \
' [git-p4: ' in extractLogMessageFromGitCommit ( self . branch ) :
2022-05-21 06:26:55 +08:00
self . p4BranchesInGit = [ self . branch ]
2013-01-15 08:47:06 +08:00
else :
self . p4BranchesInGit = branches . keys ( )
2007-05-25 04:25:36 +08:00
if len ( self . p4BranchesInGit ) > 1 :
if not self . silent :
2018-06-19 16:04:10 +08:00
print ( " Importing from/into multiple branches " )
2007-05-25 04:25:36 +08:00
self . detectBranches = True
2013-01-15 08:47:06 +08:00
for branch in branches . keys ( ) :
self . initialParents [ self . refPrefix + branch ] = \
branches [ branch ]
2007-03-23 16:30:41 +08:00
2007-05-19 16:23:12 +08:00
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " branches: %s " % self . p4BranchesInGit )
2007-05-19 16:23:12 +08:00
p4Change = 0
for branch in self . p4BranchesInGit :
git-p4: support explicit sync of arbitrary existing git-p4 refs
With the --branch argument of the "sync" subcommand, git-p4 enables
you to import a perforce branch/path to an arbitrary git ref, using
a full ref path, or to refs/remotes/p4/* or refs/heads/p4/*,
depending on --import-local, using a short ref name.
However, when you later want to explicitly sync such a given ref to
pick up subsequent p4 changes, it only works if the ref was placed
in the p4 path *and* has only one path component (no "/").
This limitation results from a bad assumption in the
existing-branch sync logic, and also means you cannot individually
sync branches detected by --detect-branches, as these also get a
"/" in their names.
Fix "git p4 sync --branch", when called with an existing ref, so
that it works correctly regardless of whether the ref is in the p4
path or not, and (in the case of refs in the p4 path) regardless of
whether it has a "/" in its short name or not.
Also add tests to validate that these branch-specific syncs work
as expected.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-04-04 13:10:54 +08:00
logMsg = extractLogMessageFromGitCommit ( fullP4Ref ( branch ,
self . importIntoRemotes ) )
2007-05-24 05:49:35 +08:00
settings = extractSettingsGitLog ( logMsg )
2007-05-19 16:23:12 +08:00
2007-05-24 05:49:35 +08:00
self . readOptions ( settings )
2022-04-01 22:24:59 +08:00
if ' depot-paths ' in settings and ' change ' in settings :
2007-05-24 05:49:35 +08:00
change = int ( settings [ ' change ' ] ) + 1
2007-05-19 16:23:12 +08:00
p4Change = max ( p4Change , change )
2007-05-24 05:49:35 +08:00
depotPaths = sorted ( settings [ ' depot-paths ' ] )
if self . previousDepotPaths == [ ] :
2007-05-24 05:49:35 +08:00
self . previousDepotPaths = depotPaths
2007-05-19 16:23:12 +08:00
else :
2007-05-24 05:49:35 +08:00
paths = [ ]
for ( prev , cur ) in zip ( self . previousDepotPaths , depotPaths ) :
2011-08-19 07:44:03 +08:00
prev_list = prev . split ( " / " )
cur_list = cur . split ( " / " )
for i in range ( 0 , min ( len ( cur_list ) , len ( prev_list ) ) ) :
2018-06-19 16:04:06 +08:00
if cur_list [ i ] != prev_list [ i ] :
2007-06-07 15:37:13 +08:00
i = i - 1
2007-05-24 05:49:35 +08:00
break
2022-04-01 22:24:54 +08:00
paths . append ( " / " . join ( cur_list [ : i + 1 ] ) )
2007-05-24 05:49:35 +08:00
self . previousDepotPaths = paths
2007-05-19 16:23:12 +08:00
if p4Change > 0 :
2007-05-24 05:49:35 +08:00
self . depotPaths = sorted ( self . previousDepotPaths )
2007-05-19 17:07:32 +08:00
self . changeRange = " @ %s ,#head " % p4Change
2007-05-21 06:39:16 +08:00
if not self . silent and not self . detectBranches :
2018-06-19 16:04:10 +08:00
print ( " Performing incremental import into %s git branch " % self . branch )
2007-03-23 04:34:16 +08:00
git-p4: support explicit sync of arbitrary existing git-p4 refs
With the --branch argument of the "sync" subcommand, git-p4 enables
you to import a perforce branch/path to an arbitrary git ref, using
a full ref path, or to refs/remotes/p4/* or refs/heads/p4/*,
depending on --import-local, using a short ref name.
However, when you later want to explicitly sync such a given ref to
pick up subsequent p4 changes, it only works if the ref was placed
in the p4 path *and* has only one path component (no "/").
This limitation results from a bad assumption in the
existing-branch sync logic, and also means you cannot individually
sync branches detected by --detect-branches, as these also get a
"/" in their names.
Fix "git p4 sync --branch", when called with an existing ref, so
that it works correctly regardless of whether the ref is in the p4
path or not, and (in the case of refs in the p4 path) regardless of
whether it has a "/" in its short name or not.
Also add tests to validate that these branch-specific syncs work
as expected.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-04-04 13:10:54 +08:00
self . branch = fullP4Ref ( self . branch , self . importIntoRemotes )
2007-03-23 05:17:42 +08:00
2007-05-24 05:49:35 +08:00
if len ( args ) == 0 and self . depotPaths :
2007-03-21 03:54:23 +08:00
if not self . silent :
2018-06-19 16:04:10 +08:00
print ( " Depot paths: %s " % ' ' . join ( self . depotPaths ) )
2007-03-21 03:54:23 +08:00
else :
2007-05-24 05:49:35 +08:00
if self . depotPaths and self . depotPaths != args :
2018-06-19 16:04:10 +08:00
print ( " previous import used depot path %s and now %s was specified. "
2022-04-01 22:24:54 +08:00
" This doesn ' t work! " % ( ' ' . join ( self . depotPaths ) ,
' ' . join ( args ) ) )
2007-03-21 03:54:23 +08:00
sys . exit ( 1 )
2007-05-24 05:49:35 +08:00
2007-05-24 05:49:35 +08:00
self . depotPaths = sorted ( args )
2007-03-21 03:54:23 +08:00
2007-08-26 22:04:34 +08:00
revision = " "
2007-03-21 03:54:23 +08:00
self . users = { }
2011-12-25 10:07:35 +08:00
# Make sure no revision specifiers are used when --changesfile
# is specified.
bad_changesfile = False
if len ( self . changesFile ) > 0 :
for p in self . depotPaths :
if p . find ( " @ " ) > = 0 or p . find ( " # " ) > = 0 :
bad_changesfile = True
break
if bad_changesfile :
die ( " Option --changesfile is incompatible with revision specifiers " )
2007-05-24 05:49:35 +08:00
newPaths = [ ]
for p in self . depotPaths :
if p . find ( " @ " ) != - 1 :
atIdx = p . index ( " @ " )
self . changeRange = p [ atIdx : ]
if self . changeRange == " @all " :
self . changeRange = " "
2007-05-24 05:49:35 +08:00
elif ' , ' not in self . changeRange :
2007-08-26 22:04:34 +08:00
revision = self . changeRange
2007-05-24 05:49:35 +08:00
self . changeRange = " "
2007-07-24 06:56:37 +08:00
p = p [ : atIdx ]
2007-05-24 05:49:35 +08:00
elif p . find ( " # " ) != - 1 :
hashIdx = p . index ( " # " )
2007-08-26 22:04:34 +08:00
revision = p [ hashIdx : ]
2007-07-24 06:56:37 +08:00
p = p [ : hashIdx ]
2007-05-24 05:49:35 +08:00
elif self . previousDepotPaths == [ ] :
2011-12-25 10:07:35 +08:00
# pay attention to changesfile, if given, else import
# the entire p4 tree at the head revision
if len ( self . changesFile ) == 0 :
revision = " #head "
2007-05-24 05:49:35 +08:00
2022-04-01 22:24:54 +08:00
p = re . sub ( " \ . \ . \ .$ " , " " , p )
2007-05-24 05:49:35 +08:00
if not p . endswith ( " / " ) :
p + = " / "
newPaths . append ( p )
self . depotPaths = newPaths
2012-08-12 00:55:02 +08:00
# --detect-branches may change this for each branch
self . branchPrefixes = self . depotPaths
2007-05-20 16:55:54 +08:00
self . loadUserMapFromCache ( )
2007-04-08 06:12:02 +08:00
self . labels = { }
if self . detectLabels :
2022-04-01 22:24:44 +08:00
self . getLabels ( )
2007-03-21 03:54:23 +08:00
2007-05-19 03:45:23 +08:00
if self . detectBranches :
2022-04-01 22:24:57 +08:00
# FIXME - what's a P4 projectName ?
2007-06-08 14:49:22 +08:00
self . projectName = self . guessProjectName ( )
2007-11-15 17:38:45 +08:00
if self . hasOrigin :
self . getBranchMappingFromGitBranches ( )
else :
self . getBranchMapping ( )
2007-05-19 16:23:12 +08:00
if self . verbose :
2018-06-19 16:04:10 +08:00
print ( " p4-git branches: %s " % self . p4BranchesInGit )
print ( " initial parents: %s " % self . initialParents )
2007-05-19 16:23:12 +08:00
for b in self . p4BranchesInGit :
if b != " master " :
2007-05-24 05:49:35 +08:00
2022-04-01 22:24:57 +08:00
# FIXME
2007-05-19 16:23:12 +08:00
b = b [ len ( self . projectName ) : ]
self . createdBranches . add ( b )
2007-05-19 03:45:23 +08:00
2020-01-29 19:12:46 +08:00
p4_check_access ( )
2018-05-24 06:20:26 +08:00
self . openStreams ( )
2007-03-21 03:54:23 +08:00
2020-01-29 19:12:45 +08:00
err = None
2007-05-21 06:39:16 +08:00
2020-01-29 19:12:45 +08:00
try :
if revision :
self . importHeadRevision ( revision )
else :
self . importRevisions ( args , branch_arg_given )
2007-03-21 03:54:23 +08:00
2020-01-29 19:12:45 +08:00
if gitConfigBool ( " git-p4.importLabels " ) :
self . importLabels = True
2012-04-11 23:21:24 +08:00
2020-01-29 19:12:45 +08:00
if self . importLabels :
p4Labels = getP4Labels ( self . depotPaths )
gitTags = getGitTags ( )
2007-03-21 03:54:23 +08:00
2020-01-29 19:12:45 +08:00
missingP4Labels = p4Labels - gitTags
self . importP4Labels ( self . gitStream , missingP4Labels )
except P4CommandException as e :
err = e
finally :
self . closeStreams ( )
if err :
die ( str ( err ) )
2007-03-21 03:54:23 +08:00
2012-01-26 07:48:22 +08:00
# Cleanup temporary branches created during import
if self . tempBranches != [ ] :
for branch in self . tempBranches :
2022-01-07 05:40:34 +08:00
read_pipe ( [ " git " , " update-ref " , " -d " , branch ] )
2012-01-26 07:48:22 +08:00
os . rmdir ( os . path . join ( os . environ . get ( " GIT_DIR " , " .git " ) , self . tempBranchLocation ) )
2013-01-15 08:46:59 +08:00
# Create a symbolic ref p4/HEAD pointing to p4/<branch> to allow
# a convenient shortcut refname "p4".
if self . importIntoRemotes :
head_ref = self . refPrefix + " HEAD "
if not gitBranchExists ( head_ref ) and gitBranchExists ( self . branch ) :
system ( [ " git " , " symbolic-ref " , head_ref , self . branch ] )
2007-03-21 03:54:23 +08:00
return True
2022-04-01 22:24:43 +08:00
2007-04-08 05:46:50 +08:00
class P4Rebase ( Command ) :
def __init__ ( self ) :
Command . __init__ ( self )
2012-04-11 23:21:24 +08:00
self . options = [
optparse . make_option ( " --import-labels " , dest = " importLabels " , action = " store_true " ) ,
]
self . importLabels = False
2007-05-24 03:53:11 +08:00
self . description = ( " Fetches the latest revision from perforce and "
+ " rebases the current work (branch) against it " )
2007-04-08 05:46:50 +08:00
def run ( self , args ) :
sync = P4Sync ( )
2012-04-11 23:21:24 +08:00
sync . importLabels = self . importLabels
2007-04-08 05:46:50 +08:00
sync . run ( [ ] )
2007-06-12 20:34:46 +08:00
2007-08-22 15:07:15 +08:00
return self . rebase ( )
def rebase ( self ) :
2008-01-07 21:21:45 +08:00
if os . system ( " git update-index --refresh " ) != 0 :
2022-04-01 22:24:44 +08:00
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. " )
2022-01-07 05:40:34 +08:00
if len ( read_pipe ( [ " git " , " diff-index " , " HEAD " , " -- " ] ) ) > 0 :
2022-04-01 22:24:44 +08:00
die ( " You have uncommitted changes. Please commit them before rebasing or stash them away with git stash. " )
2008-01-07 21:21:45 +08:00
2022-04-01 22:24:52 +08:00
upstream , settings = findUpstreamBranchPoint ( )
2007-06-12 20:34:46 +08:00
if len ( upstream ) == 0 :
die ( " Cannot find upstream branchpoint for rebase " )
# the branchpoint may be p4/foo~3, so strip off the parent
upstream = re . sub ( " ~[0-9]+$ " , " " , upstream )
2018-06-19 16:04:10 +08:00
print ( " Rebasing the current branch onto %s " % upstream )
2022-01-07 05:40:34 +08:00
oldHead = read_pipe ( [ " git " , " rev-parse " , " HEAD " ] ) . strip ( )
system ( [ " git " , " rebase " , upstream ] )
system ( [ " git " , " diff-tree " , " --stat " , " --summary " , " -M " , oldHead ,
" HEAD " , " -- " ] )
2007-04-08 05:46:50 +08:00
return True
2022-04-01 22:24:43 +08:00
2007-04-08 16:08:26 +08:00
class P4Clone ( P4Sync ) :
def __init__ ( self ) :
P4Sync . __init__ ( self )
self . description = " Creates a new git repository and imports from Perforce into it "
2007-05-24 05:49:35 +08:00
self . usage = " usage: % prog [options] //depot/path[@revRange] "
2008-02-04 02:38:51 +08:00
self . options + = [
2007-05-24 05:49:35 +08:00
optparse . make_option ( " --destination " , dest = " cloneDestination " ,
action = ' store ' , default = None ,
2008-02-04 02:38:51 +08:00
help = " where to leave result of the clone " ) ,
2011-02-19 21:18:01 +08:00
optparse . make_option ( " --bare " , dest = " cloneBare " ,
action = " store_true " , default = False ) ,
2008-02-04 02:38:51 +08:00
]
2007-05-24 05:49:35 +08:00
self . cloneDestination = None
2007-04-08 16:08:26 +08:00
self . needsGit = False
2011-02-19 21:18:01 +08:00
self . cloneBare = False
2007-04-08 16:08:26 +08:00
2007-05-24 05:49:35 +08:00
def defaultDestination ( self , args ) :
2022-04-01 22:24:57 +08:00
# TODO: use common prefix of args?
2007-05-24 05:49:35 +08:00
depotPath = args [ 0 ]
depotDir = re . sub ( " (@[^@]*)$ " , " " , depotPath )
depotDir = re . sub ( " (#[^#]*)$ " , " " , depotDir )
2008-02-05 04:41:43 +08:00
depotDir = re . sub ( r " \ . \ . \ .$ " , " " , depotDir )
2007-05-24 05:49:35 +08:00
depotDir = re . sub ( r " /$ " , " " , depotDir )
return os . path . split ( depotDir ) [ 1 ]
2007-04-08 16:08:26 +08:00
def run ( self , args ) :
if len ( args ) < 1 :
return False
2007-05-24 05:49:35 +08:00
if self . keepRepoPath and not self . cloneDestination :
sys . stderr . write ( " Must specify destination for --keep-path \n " )
sys . exit ( 1 )
2007-04-08 16:08:26 +08:00
2007-05-24 05:49:35 +08:00
depotPaths = args
2007-06-08 03:12:25 +08:00
if not self . cloneDestination and len ( depotPaths ) > 1 :
self . cloneDestination = depotPaths [ - 1 ]
depotPaths = depotPaths [ : - 1 ]
2007-05-24 05:49:35 +08:00
for p in depotPaths :
if not p . startswith ( " // " ) :
2013-01-27 11:11:06 +08:00
sys . stderr . write ( ' Depot paths must start with " // " : %s \n ' % p )
2007-05-24 05:49:35 +08:00
return False
2007-04-08 16:08:26 +08:00
2007-05-24 05:49:35 +08:00
if not self . cloneDestination :
2007-06-07 21:08:33 +08:00
self . cloneDestination = self . defaultDestination ( args )
2007-04-08 16:08:26 +08:00
2018-06-19 16:04:10 +08:00
print ( " Importing from %s into %s " % ( ' , ' . join ( depotPaths ) , self . cloneDestination ) )
2011-02-19 21:18:01 +08:00
2007-06-12 04:48:07 +08:00
if not os . path . exists ( self . cloneDestination ) :
os . makedirs ( self . cloneDestination )
2008-08-02 03:50:03 +08:00
chdir ( self . cloneDestination )
2011-02-19 21:18:01 +08:00
2022-04-01 22:24:50 +08:00
init_cmd = [ " git " , " init " ]
2011-02-19 21:18:01 +08:00
if self . cloneBare :
init_cmd . append ( " --bare " )
2013-01-27 03:14:33 +08:00
retcode = subprocess . call ( init_cmd )
if retcode :
2022-01-07 05:41:56 +08:00
raise subprocess . CalledProcessError ( retcode , init_cmd )
2011-02-19 21:18:01 +08:00
2007-05-24 05:49:35 +08:00
if not P4Sync . run ( self , depotPaths ) :
2007-04-08 16:08:26 +08:00
return False
2013-01-15 08:47:01 +08:00
# create a master branch and check out a work tree
if gitBranchExists ( self . branch ) :
2022-04-01 22:24:50 +08:00
system ( [ " git " , " branch " , currentGitBranch ( ) , self . branch ] )
2013-01-15 08:47:01 +08:00
if not self . cloneBare :
2022-04-01 22:24:50 +08:00
system ( [ " git " , " checkout " , " -f " ] )
2013-01-15 08:47:01 +08:00
else :
2022-04-01 22:24:55 +08:00
print ( ' Not checking out any branch, use '
2018-06-19 16:04:10 +08:00
' " git checkout -q -b master <branch> " ' )
2007-05-24 05:49:35 +08:00
2012-02-26 09:06:24 +08:00
# auto-set this variable if invoked with --use-client-spec
if self . useClientSpec_from_options :
2022-01-07 05:40:34 +08:00
system ( [ " git " , " config " , " --bool " , " git-p4.useclientspec " , " true " ] )
2012-02-26 09:06:24 +08:00
git-p4: improve encoding handling to support inconsistent encodings
git-p4 is designed to run correctly under python2.7 and python3, but
its functional behavior wrt importing user-entered text differs across
these environments:
Under python2, git-p4 "naively" writes the Perforce bytestream into git
metadata (and does not set an "encoding" header on the commits); this
means that any non-utf-8 byte sequences end up creating invalidly-encoded
commit metadata in git.
Under python3, git-p4 attempts to decode the Perforce bytestream as utf-8
data, and fails badly (with an unhelpful error) when non-utf-8 data is
encountered.
Perforce clients (especially p4v) encourage user entry of changelist
descriptions (and user full names) in OS-local encoding, and store the
resulting bytestream to the server unmodified - such that different
clients can end up creating mutually-unintelligible messages. The most
common inconsistency, in many Perforce environments, is likely to be utf-8
(typical in linux) vs cp-1252 (typical in windows).
Make the changelist-description- and user-fullname-handling code
python-runtime-agnostic, introducing three "strategies" selectable via
config:
- 'passthrough', behaving as previously under python2,
- 'strict', behaving as previously under python3, and
- 'fallback', favoring utf-8 but supporting a secondary encoding when
utf-8 decoding fails, and finally escaping high-range bytes if the
decoding with the secondary encoding also fails.
Keep the python2 default behavior as-is ('legacy' strategy), but switch
the python3 default strategy to 'fallback' with default fallback encoding
'cp1252'.
Also include tests exercising these encoding strategies, documentation for
the new config, and improve the user-facing error messages when decoding
does fail.
Signed-off-by: Tao Klerks <tao@klerks.biz>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-05-01 03:26:52 +08:00
# persist any git-p4 encoding-handling config options passed in for clone:
if gitConfig ( ' git-p4.metadataDecodingStrategy ' ) :
system ( [ " git " , " config " , " git-p4.metadataDecodingStrategy " , gitConfig ( ' git-p4.metadataDecodingStrategy ' ) ] )
if gitConfig ( ' git-p4.metadataFallbackEncoding ' ) :
system ( [ " git " , " config " , " git-p4.metadataFallbackEncoding " , gitConfig ( ' git-p4.metadataFallbackEncoding ' ) ] )
if gitConfig ( ' git-p4.pathEncoding ' ) :
system ( [ " git " , " config " , " git-p4.pathEncoding " , gitConfig ( ' git-p4.pathEncoding ' ) ] )
2007-04-08 16:08:26 +08:00
return True
2022-04-01 22:24:43 +08:00
2018-05-24 06:20:26 +08:00
class P4Unshelve ( Command ) :
def __init__ ( self ) :
Command . __init__ ( self )
self . options = [ ]
self . origin = " HEAD "
self . description = " Unshelve a P4 changelist into a git commit "
self . usage = " usage: % prog [options] changelist "
self . options + = [
optparse . make_option ( " --origin " , dest = " origin " ,
help = " Use this base revision instead of the default ( %s ) " % self . origin ) ,
]
self . verbose = False
self . noCommit = False
2018-10-15 19:14:07 +08:00
self . destbranch = " refs/remotes/p4-unshelved "
2018-05-24 06:20:26 +08:00
def renameBranch ( self , branch_name ) :
2022-04-01 22:24:46 +08:00
""" Rename the existing branch to branch_name.N . """
2018-05-24 06:20:26 +08:00
2022-04-01 22:24:53 +08:00
for i in range ( 0 , 1000 ) :
2018-05-24 06:20:26 +08:00
backup_branch_name = " {0} . {1} " . format ( branch_name , i )
if not gitBranchExists ( backup_branch_name ) :
2022-04-01 22:25:02 +08:00
# Copy ref to backup
gitUpdateRef ( backup_branch_name , branch_name )
2018-05-24 06:20:26 +08:00
gitDeleteRef ( branch_name )
print ( " renamed old unshelve branch to {0} " . format ( backup_branch_name ) )
break
2022-07-21 02:55:30 +08:00
else :
sys . exit ( " gave up trying to rename existing branch {0} " . format ( branch_name ) )
2018-05-24 06:20:26 +08:00
def findLastP4Revision ( self , starting_point ) :
2022-04-01 22:24:46 +08:00
""" Look back from starting_point for the first commit created by git-p4
to find the P4 commit we are based on , and the depot - paths .
"""
2018-05-24 06:20:26 +08:00
for parent in ( range ( 65535 ) ) :
2020-09-19 16:54:41 +08:00
log = extractLogMessageFromGitCommit ( " {0} ~ {1} " . format ( starting_point , parent ) )
2018-05-24 06:20:26 +08:00
settings = extractSettingsGitLog ( log )
2018-06-19 16:04:07 +08:00
if ' change ' in settings :
2018-05-24 06:20:26 +08:00
return settings
sys . exit ( " could not find git-p4 commits in {0} " . format ( self . origin ) )
2018-10-15 19:14:08 +08:00
def createShelveParent ( self , change , branch_name , sync , origin ) :
2022-04-01 22:24:46 +08:00
""" Create a commit matching the parent of the shelved changelist
' change ' .
"""
2018-10-15 19:14:08 +08:00
parent_description = p4_describe ( change , shelved = True )
parent_description [ ' desc ' ] = ' parent for shelved changelist {} \n ' . format ( change )
files = sync . extractFilesFromCommit ( parent_description , shelved = False , shelved_cl = change )
parent_files = [ ]
for f in files :
# if it was added in the shelved changelist, it won't exist in the parent
if f [ ' action ' ] in self . add_actions :
continue
# if it was deleted in the shelved changelist it must not be deleted
# in the parent - we might even need to create it if the origin branch
# does not have it
if f [ ' action ' ] in self . delete_actions :
f [ ' action ' ] = ' add '
parent_files . append ( f )
sync . commit ( parent_description , parent_files , branch_name ,
parent = origin , allow_empty = True )
print ( " created parent commit for {0} based on {1} in {2} " . format (
change , self . origin , branch_name ) )
2018-05-24 06:20:26 +08:00
def run ( self , args ) :
if len ( args ) != 1 :
return False
if not gitBranchExists ( self . origin ) :
sys . exit ( " origin branch {0} does not exist " . format ( self . origin ) )
sync = P4Sync ( )
changes = args
2018-10-15 19:14:08 +08:00
# only one change at a time
2018-05-24 06:20:26 +08:00
change = changes [ 0 ]
# if the target branch already exists, rename it
branch_name = " {0} / {1} " . format ( self . destbranch , change )
if gitBranchExists ( branch_name ) :
self . renameBranch ( branch_name )
sync . branch = branch_name
sync . verbose = self . verbose
sync . suppress_meta_comment = True
settings = self . findLastP4Revision ( self . origin )
sync . depotPaths = settings [ ' depot-paths ' ]
sync . branchPrefixes = sync . depotPaths
sync . openStreams ( )
sync . loadUserMapFromCache ( )
sync . silent = True
2018-10-15 19:14:08 +08:00
# create a commit for the parent of the shelved changelist
self . createShelveParent ( change , branch_name , sync , self . origin )
# create the commit for the shelved changelist itself
description = p4_describe ( change , True )
files = sync . extractFilesFromCommit ( description , True , change )
sync . commit ( description , files , branch_name , " " )
2018-05-24 06:20:26 +08:00
sync . closeStreams ( )
print ( " unshelved changelist {0} into {1} " . format ( change , branch_name ) )
return True
2022-04-01 22:24:43 +08:00
2007-06-21 05:10:28 +08:00
class P4Branches ( Command ) :
def __init__ ( self ) :
Command . __init__ ( self )
2022-04-01 22:24:50 +08:00
self . options = [ ]
2007-06-21 05:10:28 +08:00
self . description = ( " Shows the git branches that hold imports and their "
+ " corresponding perforce depot paths " )
self . verbose = False
def run ( self , args ) :
2007-08-24 23:44:16 +08:00
if originP4BranchesExist ( ) :
createOrUpdateBranchesFromOrigin ( )
2022-01-07 05:40:34 +08:00
for line in read_pipe_lines ( [ " git " , " rev-parse " , " --symbolic " , " --remotes " ] ) :
2007-06-21 05:10:28 +08:00
line = line . strip ( )
if not line . startswith ( ' p4/ ' ) or line == " p4/HEAD " :
continue
branch = line
log = extractLogMessageFromGitCommit ( " refs/remotes/ %s " % branch )
settings = extractSettingsGitLog ( log )
2018-06-19 16:04:10 +08:00
print ( " %s <= %s ( %s ) " % ( branch , " , " . join ( settings [ " depot-paths " ] ) , settings [ " change " ] ) )
2007-06-21 05:10:28 +08:00
return True
2022-04-01 22:24:43 +08:00
2007-03-21 03:54:23 +08:00
class HelpFormatter ( optparse . IndentedHelpFormatter ) :
def __init__ ( self ) :
optparse . IndentedHelpFormatter . __init__ ( self )
def format_description ( self , description ) :
if description :
return description + " \n "
else :
return " "
2007-03-20 05:25:17 +08:00
2022-04-01 22:24:43 +08:00
2007-03-20 03:59:12 +08:00
def printUsage ( commands ) :
2018-06-19 16:04:10 +08:00
print ( " usage: %s <command> [options] " % sys . argv [ 0 ] )
print ( " " )
print ( " valid commands: %s " % " , " . join ( commands ) )
print ( " " )
print ( " Try %s <command> --help for command specific help. " % sys . argv [ 0 ] )
print ( " " )
2007-03-20 03:59:12 +08:00
2022-04-01 22:24:43 +08:00
2007-03-20 03:59:12 +08:00
commands = {
2022-04-01 22:24:56 +08:00
" submit " : P4Submit ,
" commit " : P4Submit ,
" sync " : P4Sync ,
" rebase " : P4Rebase ,
" clone " : P4Clone ,
" branches " : P4Branches ,
" unshelve " : P4Unshelve ,
2007-03-20 03:59:12 +08:00
}
2022-04-01 22:24:43 +08:00
2007-05-24 05:49:35 +08:00
def main ( ) :
if len ( sys . argv [ 1 : ] ) == 0 :
printUsage ( commands . keys ( ) )
sys . exit ( 2 )
2007-03-20 05:25:17 +08:00
2007-05-24 05:49:35 +08:00
cmdName = sys . argv [ 1 ]
try :
2007-05-24 05:49:35 +08:00
klass = commands [ cmdName ]
cmd = klass ( )
2007-05-24 05:49:35 +08:00
except KeyError :
2018-06-19 16:04:10 +08:00
print ( " unknown command %s " % cmdName )
print ( " " )
2007-05-24 05:49:35 +08:00
printUsage ( commands . keys ( ) )
sys . exit ( 2 )
options = cmd . options
2007-05-24 05:49:35 +08:00
cmd . gitdir = os . environ . get ( " GIT_DIR " , None )
2007-05-24 05:49:35 +08:00
args = sys . argv [ 2 : ]
2012-09-10 04:16:10 +08:00
options . append ( optparse . make_option ( " --verbose " , " -v " , dest = " verbose " , action = " store_true " ) )
2012-04-24 16:33:23 +08:00
if cmd . needsGit :
options . append ( optparse . make_option ( " --git-dir " , dest = " gitdir " ) )
2007-05-24 05:49:35 +08:00
2012-04-24 16:33:23 +08:00
parser = optparse . OptionParser ( cmd . usage . replace ( " % prog " , " % prog " + cmdName ) ,
options ,
2022-04-01 22:24:51 +08:00
description = cmd . description ,
formatter = HelpFormatter ( ) )
2007-05-24 05:49:35 +08:00
2019-12-16 22:02:20 +08:00
try :
2022-04-01 22:24:52 +08:00
cmd , args = parser . parse_args ( sys . argv [ 2 : ] , cmd )
2019-12-16 22:02:20 +08:00
except :
parser . print_help ( )
raise
2007-05-24 05:49:35 +08:00
global verbose
verbose = cmd . verbose
if cmd . needsGit :
2022-04-01 22:25:00 +08:00
if cmd . gitdir is None :
2007-05-24 05:49:35 +08:00
cmd . gitdir = os . path . abspath ( " .git " )
if not isValidGitDir ( cmd . gitdir ) :
2016-12-14 05:51:28 +08:00
# "rev-parse --git-dir" without arguments will try $PWD/.git
2022-01-07 05:40:34 +08:00
cmd . gitdir = read_pipe ( [ " git " , " rev-parse " , " --git-dir " ] ) . strip ( )
2007-05-24 05:49:35 +08:00
if os . path . exists ( cmd . gitdir ) :
2022-01-07 05:40:34 +08:00
cdup = read_pipe ( [ " git " , " rev-parse " , " --show-cdup " ] ) . strip ( )
2007-05-24 05:49:35 +08:00
if len ( cdup ) > 0 :
2022-04-01 22:24:44 +08:00
chdir ( cdup )
2007-03-26 06:13:51 +08:00
2007-05-24 05:49:35 +08:00
if not isValidGitDir ( cmd . gitdir ) :
if isValidGitDir ( cmd . gitdir + " /.git " ) :
cmd . gitdir + = " /.git "
2007-05-24 05:49:35 +08:00
else :
2007-05-24 05:49:35 +08:00
die ( " fatal: cannot locate git repository at %s " % cmd . gitdir )
2007-03-26 06:13:51 +08:00
2016-12-14 05:51:28 +08:00
# so git commands invoked from the P4 workspace will succeed
2007-05-24 05:49:35 +08:00
os . environ [ " GIT_DIR " ] = cmd . gitdir
2007-03-20 03:59:12 +08:00
2007-05-24 05:49:35 +08:00
if not cmd . run ( args ) :
parser . print_help ( )
2011-12-25 10:07:39 +08:00
sys . exit ( 2 )
2007-03-20 05:25:17 +08:00
2007-05-24 05:49:35 +08:00
if __name__ == ' __main__ ' :
main ( )