* [PATCH v3 1/5] git-p4: add optional type specifier to gitConfig reader
2015-09-07 12:21 [PATCH v3 0/5] git-p4: add support for large file systems larsxschneider
@ 2015-09-07 12:21 ` larsxschneider
2015-09-07 12:21 ` [PATCH v3 2/5] git-p4: add gitConfigInt reader larsxschneider
` (4 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: larsxschneider @ 2015-09-07 12:21 UTC (permalink / raw)
To: git; +Cc: luke, Lars Schneider
From: Lars Schneider <larsxschneider@gmail.com>
The functions “gitConfig” and “gitConfigBool” are almost identical. Make “gitConfig” more generic by adding an optional type specifier. Use the type specifier “—bool” with “gitConfig” to implement “gitConfigBool. This prepares the implementation of other type specifiers such as “—int”.
Signed-off-by: Lars Schneider <larsxschneider@gmail.com>
---
git-p4.py | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/git-p4.py b/git-p4.py
index 073f87b..c139cab 100755
--- a/git-p4.py
+++ b/git-p4.py
@@ -604,9 +604,12 @@ def gitBranchExists(branch):
_gitConfig = {}
-def gitConfig(key):
+def gitConfig(key, typeSpecifier=None):
if not _gitConfig.has_key(key):
- cmd = [ "git", "config", key ]
+ cmd = [ "git", "config" ]
+ if typeSpecifier:
+ cmd += [ typeSpecifier ]
+ cmd += [ key ]
s = read_pipe(cmd, ignore_error=True)
_gitConfig[key] = s.strip()
return _gitConfig[key]
@@ -617,10 +620,7 @@ def gitConfigBool(key):
in the config."""
if not _gitConfig.has_key(key):
- cmd = [ "git", "config", "--bool", key ]
- s = read_pipe(cmd, ignore_error=True)
- v = s.strip()
- _gitConfig[key] = v == "true"
+ _gitConfig[key] = gitConfig(key, '--bool') == "true"
return _gitConfig[key]
def gitConfigList(key):
--
2.5.1
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH v3 2/5] git-p4: add gitConfigInt reader
2015-09-07 12:21 [PATCH v3 0/5] git-p4: add support for large file systems larsxschneider
2015-09-07 12:21 ` [PATCH v3 1/5] git-p4: add optional type specifier to gitConfig reader larsxschneider
@ 2015-09-07 12:21 ` larsxschneider
2015-09-07 12:21 ` [PATCH v3 3/5] git-p4: return an empty list if a list config has no values larsxschneider
` (3 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: larsxschneider @ 2015-09-07 12:21 UTC (permalink / raw)
To: git; +Cc: luke, Lars Schneider
From: Lars Schneider <larsxschneider@gmail.com>
Add a git config reader for integer variables. Please note that the git config implementation automatically supports k, m, and g suffixes.
Signed-off-by: Lars Schneider <larsxschneider@gmail.com>
---
git-p4.py | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/git-p4.py b/git-p4.py
index c139cab..40ad4ae 100755
--- a/git-p4.py
+++ b/git-p4.py
@@ -623,6 +623,17 @@ def gitConfigBool(key):
_gitConfig[key] = gitConfig(key, '--bool') == "true"
return _gitConfig[key]
+def gitConfigInt(key):
+ if not _gitConfig.has_key(key):
+ cmd = [ "git", "config", "--int", key ]
+ s = read_pipe(cmd, ignore_error=True)
+ v = s.strip()
+ try:
+ _gitConfig[key] = int(gitConfig(key, '--int'))
+ except ValueError:
+ _gitConfig[key] = None
+ return _gitConfig[key]
+
def gitConfigList(key):
if not _gitConfig.has_key(key):
s = read_pipe(["git", "config", "--get-all", key], ignore_error=True)
--
2.5.1
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH v3 3/5] git-p4: return an empty list if a list config has no values
2015-09-07 12:21 [PATCH v3 0/5] git-p4: add support for large file systems larsxschneider
2015-09-07 12:21 ` [PATCH v3 1/5] git-p4: add optional type specifier to gitConfig reader larsxschneider
2015-09-07 12:21 ` [PATCH v3 2/5] git-p4: add gitConfigInt reader larsxschneider
@ 2015-09-07 12:21 ` larsxschneider
2015-09-07 12:21 ` [PATCH v3 4/5] git-p4: add support for large file systems larsxschneider
` (2 subsequent siblings)
5 siblings, 0 replies; 7+ messages in thread
From: larsxschneider @ 2015-09-07 12:21 UTC (permalink / raw)
To: git; +Cc: luke, Lars Schneider
From: Lars Schneider <larsxschneider@gmail.com>
Signed-off-by: Lars Schneider <larsxschneider@gmail.com>
---
git-p4.py | 2 ++
1 file changed, 2 insertions(+)
diff --git a/git-p4.py b/git-p4.py
index 40ad4ae..90d3b90 100755
--- a/git-p4.py
+++ b/git-p4.py
@@ -638,6 +638,8 @@ def gitConfigList(key):
if not _gitConfig.has_key(key):
s = read_pipe(["git", "config", "--get-all", key], ignore_error=True)
_gitConfig[key] = s.strip().split(os.linesep)
+ if _gitConfig[key] == ['']:
+ _gitConfig[key] = []
return _gitConfig[key]
def p4BranchesInGit(branchesAreInRemotes=True):
--
2.5.1
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH v3 4/5] git-p4: add support for large file systems
2015-09-07 12:21 [PATCH v3 0/5] git-p4: add support for large file systems larsxschneider
` (2 preceding siblings ...)
2015-09-07 12:21 ` [PATCH v3 3/5] git-p4: return an empty list if a list config has no values larsxschneider
@ 2015-09-07 12:21 ` larsxschneider
2015-09-07 12:21 ` [PATCH v3 5/5] git-p4: add Git LFS backend for large file system larsxschneider
2015-09-08 4:25 ` [PATCH v3 0/5] git-p4: add support for large file systems Luke Diamand
5 siblings, 0 replies; 7+ messages in thread
From: larsxschneider @ 2015-09-07 12:21 UTC (permalink / raw)
To: git; +Cc: luke, Lars Schneider
From: Lars Schneider <larsxschneider@gmail.com>
Perforce repositories can contain large (binary) files. Migrating these
repositories to Git generates very large local clones. External storage
systems such as Git LFS [1], Git Fat [2], or Git Media [2] try to
address this problem.
Add a generic mechanism to detect large files based on extension,
uncompressed size, and/or compressed size.
[1] https://git-lfs.github.com/
[2] https://github.com/jedbrown/git-fat
[3] https://github.com/alebedev/git-media
Signed-off-by: Lars Schneider <larsxschneider@gmail.com>
---
Documentation/git-p4.txt | 26 +++++++++++
git-p4.py | 114 +++++++++++++++++++++++++++++++++++++++++++----
2 files changed, 131 insertions(+), 9 deletions(-)
diff --git a/Documentation/git-p4.txt b/Documentation/git-p4.txt
index 82aa5d6..e0d0239 100644
--- a/Documentation/git-p4.txt
+++ b/Documentation/git-p4.txt
@@ -510,6 +510,32 @@ git-p4.useClientSpec::
option '--use-client-spec'. See the "CLIENT SPEC" section above.
This variable is a boolean, not the name of a p4 client.
+git-p4.largeFileSystem::
+ Specify the system that is used used for large (binary) files.
+ Please note that most of these large file systems depend on the
+ Git clean/smudge filters. These filters are not applied through
+ git-p4. You need to create a fresh clone of the repository after
+ running git-p4.
+
+git-p4.largeFileExtensions::
+ All files matching a file extension in the list will be processed
+ by the large file system. Do not prefix the extensions with '.'.
+
+git-p4.largeFileThreshold::
+ All files with an uncompressed size exceeding the threshold will be
+ processed by the large file system. By default the threshold is
+ defined in bytes. Add the suffix k, m, or g to change the unit.
+
+git-p4.largeFileCompressedThreshold::
+ All files with a compressed size exceeding the threshold will be
+ processed by the large file system. This option might significantly
+ slow down your clone/sync process. By default the threshold is
+ defined in bytes. Add the suffix k, m, or g to change the unit.
+
+git-p4.pushLargeFiles::
+ Boolean variable which defines if large files are automatically
+ pushed to a server.
+
Submit variables
~~~~~~~~~~~~~~~~
git-p4.detectRenames::
diff --git a/git-p4.py b/git-p4.py
index 90d3b90..06651a8 100755
--- a/git-p4.py
+++ b/git-p4.py
@@ -22,6 +22,8 @@ import platform
import re
import shutil
import stat
+import zipfile
+import zlib
try:
from subprocess import CalledProcessError
@@ -922,6 +924,17 @@ def wildcard_present(path):
m = re.search("[*#@%]", path)
return m is not None
+def largeFileSystem():
+ try:
+ largeFileSystem = getattr(sys.modules[__name__], gitConfig('git-p4.largeFileSystem'))
+ assert(hasattr(largeFileSystem, "attributeDescription"))
+ assert(hasattr(largeFileSystem, "attributeFilter"))
+ assert(hasattr(largeFileSystem, "generatePointer"))
+ assert(hasattr(largeFileSystem, "pushFile"))
+ return largeFileSystem
+ except AttributeError as e:
+ die('Large file system not supported: %s' % gitConfig('git-p4.largeFileSystem'))
+
class Command:
def __init__(self):
self.usage = "usage: %prog [options]"
@@ -2038,6 +2051,7 @@ class P4Sync(Command, P4UserMap):
self.clientSpecDirs = None
self.tempBranches = []
self.tempBranchLocation = "git-p4-tmp"
+ self.largeFiles = set()
if gitConfig("git-p4.syncFromOrigin") == "false":
self.syncWithOrigin = False
@@ -2158,6 +2172,85 @@ class P4Sync(Command, P4UserMap):
return branches
+ def writeToGitStream(self, gitMode, relPath, contents):
+ self.gitStream.write('M %s inline %s\n' % (gitMode, relPath))
+ 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')
+
+ def writeGitAttributesToStream(self):
+ self.writeToGitStream(
+ '100644',
+ '.gitattributes',
+ [
+ '\n',
+ '#\n',
+ '# %s\n' % largeFileSystem().attributeDescription(),
+ '#\n',
+ ] +
+ ['*.' + f.replace(' ', '[:space:]') + ' filter=%s -text\n'
+ % largeFileSystem().attributeFilter()
+ for f in sorted(gitConfigList("git-p4.largeFileExtensions"))
+ ] +
+ ['/' + f.replace(' ', '[:space:]') + ' filter=%s -text\n'
+ % largeFileSystem().attributeFilter()
+ for f in sorted(self.largeFiles) if not self.hasLargeFileExtension(f)
+ ]
+ )
+
+ def hasLargeFileExtension(self, relPath):
+ return reduce(
+ lambda a, b: a or b,
+ [relPath.endswith('.' + e) for e in gitConfigList('git-p4.largeFileExtensions')],
+ False
+ )
+
+ 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'):
+ contentFile = tempfile.NamedTemporaryFile(prefix='git-p4-large-file', delete=False)
+ for d in contents:
+ contentFile.write(d)
+ contentFile.flush()
+ compressedContentFile = tempfile.NamedTemporaryFile(prefix='git-p4-large-file', delete=False)
+ zf = zipfile.ZipFile(compressedContentFile.name, mode='w')
+ zf.write(contentFile.name, compress_type=zipfile.ZIP_DEFLATED)
+ zf.close()
+ compressedContentsSize = zf.infolist()[0].compress_size
+ os.remove(contentFile.name)
+ os.remove(compressedContentFile.name)
+ if compressedContentsSize > gitConfigInt('git-p4.largeFileCompressedThreshold'):
+ return True
+ return False
+
+ def moveToLargeFileSystem(self, relPath, contents):
+ # Write P4 content to temp file
+ contentFile = tempfile.NamedTemporaryFile(prefix='git-p4-large-file', delete=False)
+ for d in contents:
+ contentFile.write(d)
+ contentFile.flush()
+ contentFile.close()
+ (git_mode, contents, largeFileTarget) = \
+ largeFileSystem().generatePointer(self.cloneDestination, contentFile.name)
+ # Move temp file to final location in large file system
+ largeFileDir = os.path.dirname(largeFileTarget)
+ if not os.path.isdir(largeFileDir):
+ os.makedirs(largeFileDir)
+ shutil.move(contentFile.name, largeFileTarget)
+ if verbose:
+ sys.stderr.write("%s moved to large file system (%s)\n" % (relPath, largeFileTarget))
+
+ if gitConfigBool('git-p4.pushLargeFiles'):
+ largeFileSystem().pushFile(largeFileTarget)
+
+ self.largeFiles.add(relPath)
+ self.writeGitAttributesToStream()
+ return (git_mode, contents)
+
# output one file from the P4 stream
# - helper for streamP4Files
@@ -2226,17 +2319,16 @@ class P4Sync(Command, P4UserMap):
text = regexp.sub(r'$\1$', text)
contents = [ text ]
- self.gitStream.write("M %s inline %s\n" % (git_mode, relPath))
+ if relPath == '.gitattributes':
+ die('.gitattributes already exists in P4.')
- # total length...
- length = 0
- for d in contents:
- length = length + len(d)
+ if (gitConfig('git-p4.largeFileSystem') and
+ ( self.exceedsLargeFileThreshold(relPath, contents) or
+ self.hasLargeFileExtension(relPath)
+ )):
+ (git_mode, contents) = self.moveToLargeFileSystem(relPath, contents)
- self.gitStream.write("data %d\n" % length)
- for d in contents:
- self.gitStream.write(d)
- self.gitStream.write("\n")
+ self.writeToGitStream(git_mode, relPath, contents)
def streamOneP4Deletion(self, file):
relPath = self.stripRepoPath(file['path'], self.branchPrefixes)
@@ -2244,6 +2336,10 @@ class P4Sync(Command, P4UserMap):
sys.stderr.write("delete %s\n" % relPath)
self.gitStream.write("D %s\n" % relPath)
+ if relPath in self.largeFiles:
+ self.largeFiles.remove(relPath)
+ self.writeGitAttributesToStream()
+
# handle another chunk of streaming data
def streamP4FilesCb(self, marshalled):
--
2.5.1
^ permalink raw reply related [flat|nested] 7+ messages in thread* [PATCH v3 5/5] git-p4: add Git LFS backend for large file system
2015-09-07 12:21 [PATCH v3 0/5] git-p4: add support for large file systems larsxschneider
` (3 preceding siblings ...)
2015-09-07 12:21 ` [PATCH v3 4/5] git-p4: add support for large file systems larsxschneider
@ 2015-09-07 12:21 ` larsxschneider
2015-09-08 4:25 ` [PATCH v3 0/5] git-p4: add support for large file systems Luke Diamand
5 siblings, 0 replies; 7+ messages in thread
From: larsxschneider @ 2015-09-07 12:21 UTC (permalink / raw)
To: git; +Cc: luke, Lars Schneider
From: Lars Schneider <larsxschneider@gmail.com>
Add example implementation including test cases for the large file
system using Git LFS.
Pushing files to the Git LFS server is not tested.
Signed-off-by: Lars Schneider <larsxschneider@gmail.com>
---
Documentation/git-p4.txt | 4 +-
git-p4.py | 52 ++++++++++
t/t9823-git-p4-lfs.sh | 263 +++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 318 insertions(+), 1 deletion(-)
create mode 100755 t/t9823-git-p4-lfs.sh
diff --git a/Documentation/git-p4.txt b/Documentation/git-p4.txt
index e0d0239..3168a64 100644
--- a/Documentation/git-p4.txt
+++ b/Documentation/git-p4.txt
@@ -515,7 +515,9 @@ git-p4.largeFileSystem::
Please note that most of these large file systems depend on the
Git clean/smudge filters. These filters are not applied through
git-p4. You need to create a fresh clone of the repository after
- running git-p4.
+ running git-p4. Only Git LFS [1] is supported right now. Download
+ and install the Git LFS command line extension to use this option.
+ [1] https://git-lfs.github.com/
git-p4.largeFileExtensions::
All files matching a file extension in the list will be processed
diff --git a/git-p4.py b/git-p4.py
index 06651a8..d24d84f 100755
--- a/git-p4.py
+++ b/git-p4.py
@@ -935,6 +935,58 @@ def largeFileSystem():
except AttributeError as e:
die('Large file system not supported: %s' % gitConfig('git-p4.largeFileSystem'))
+class GitLFS:
+ """Git LFS as backend for the git-p4 large file system.
+ See https://git-lfs.github.com/ for details."""
+
+ @staticmethod
+ def attributeDescription():
+ """Return a description which is used to mark LFS entries in the
+ .gitattributes file."""
+ return 'Git LFS (see https://git-lfs.github.com/)'
+
+ @staticmethod
+ def attributeFilter():
+ """Return the name of the filter which is used for LFS entries in the
+ .gitattributes file."""
+ return 'lfs'
+
+ @staticmethod
+ def generatePointer(cloneDestination, 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.
+ """
+ pointerProcess = subprocess.Popen(
+ ['git', 'lfs', 'pointer', '--file=' + contentFile],
+ stdout=subprocess.PIPE
+ )
+ pointerFile = pointerProcess.stdout.read()
+ if pointerProcess.wait():
+ os.remove(contentFile)
+ die('git-lfs pointer command failed. Did you install the extension?')
+ pointerContents = [i+'\n' for i in pointerFile.split('\n')[2:][:-1]]
+ oid = pointerContents[1].split(' ')[1].split(':')[1][:-1]
+ oidPath = os.path.join(
+ cloneDestination,
+ '.git', 'lfs', 'objects', oid[:2], oid[2:4],
+ oid,
+ )
+ # LFS Spec states that pointer files should not have the executable bit set.
+ gitMode = '100644'
+ return (gitMode, pointerContents, oidPath)
+
+ @staticmethod
+ def pushFile(contentFile):
+ """Push the actual content which is not stored in the Git repository to
+ a server."""
+ uploadProcess = subprocess.Popen(
+ ['git', 'lfs', 'push', '--object-id', 'origin', os.path.basename(contentFile)]
+ )
+ if uploadProcess.wait():
+ die('git-lfs push command failed. Did you define a remote?')
+
class Command:
def __init__(self):
self.usage = "usage: %prog [options]"
diff --git a/t/t9823-git-p4-lfs.sh b/t/t9823-git-p4-lfs.sh
new file mode 100755
index 0000000..4d58cac
--- /dev/null
+++ b/t/t9823-git-p4-lfs.sh
@@ -0,0 +1,263 @@
+#!/bin/sh
+
+test_description='Clone repositories and store files in Git LFS'
+
+. ./lib-git-p4.sh
+
+git lfs help >/dev/null 2>&1 || {
+ skip_all='skipping git p4 Git LFS tests; Git LFS not found'
+ test_done
+}
+
+test_file_in_lfs() {
+ FILE=$1
+ SIZE=$2
+ EXPECTED_CONTENT=$3
+ test_path_is_file $FILE &&
+ test_line_count = 3 $FILE &&
+ cat $FILE | grep "size $SIZE" &&
+ HASH=$(cat $FILE | grep "oid sha256:" | sed -e 's/oid sha256://g') &&
+ LFS_FILE=".git/lfs/objects/${HASH:0:2}/${HASH:2:2}/$HASH"
+ test_path_is_file $LFS_FILE &&
+ echo $EXPECTED_CONTENT >expect
+ test_cmp expect $LFS_FILE
+}
+
+test_expect_success 'start p4d' '
+ start_p4d
+'
+
+test_expect_success 'Create repo with binary files' '
+ client_view "//depot/... //client/..." &&
+ (
+ cd "$cli" &&
+
+ echo "txt 7b" >file1.txt &&
+ p4 add file1.txt &&
+ echo "bin 13 bytes" >file2.dat &&
+ p4 add file2.dat &&
+ p4 submit -d "Add text and binary file" &&
+
+ mkdir "path with spaces" &&
+ echo "bin 13 bytes" >"path with spaces/file3.bin" &&
+ p4 add "path with spaces/file3.bin" &&
+ p4 submit -d "Add another binary file with same content and spaces in path" &&
+
+ echo "bin 14 bytesx" >file4.bin &&
+ p4 add file4.bin &&
+ p4 submit -d "Add another binary file with different content"
+ )
+'
+
+test_expect_success 'Store files in LFS based on size (>12 bytes)' '
+ client_view "//depot/... //client/..." &&
+ test_when_finished cleanup_git &&
+ (
+ cd "$git" &&
+ git init . &&
+ git config git-p4.largeFileSystem GitLFS &&
+ git config git-p4.largeFileThreshold 12 &&
+ git p4 clone --use-client-spec --destination="$git" //depot@all &&
+
+ test_file_in_lfs file2.dat 13 "bin 13 bytes" &&
+ test_file_in_lfs "path with spaces/file3.bin" 13 "bin 13 bytes" &&
+ test_file_in_lfs file4.bin 14 "bin 14 bytesx" &&
+
+ find ".git/lfs/objects" -type f >actual &&
+ test_line_count = 2 actual &&
+
+ cat >expect <<-\EOF &&
+
+ #
+ # Git LFS (see https://git-lfs.github.com/)
+ #
+ /file2.dat filter=lfs -text
+ /path[:space:]with[:space:]spaces/file3.bin filter=lfs -text
+ /file4.bin filter=lfs -text
+ EOF
+ test_path_is_file .gitattributes &&
+ test_cmp expect .gitattributes
+ )
+'
+
+test_expect_success 'Store files in LFS based on size (>13 bytes)' '
+ client_view "//depot/... //client/..." &&
+ test_when_finished cleanup_git &&
+ (
+ cd "$git" &&
+ git init . &&
+ git config git-p4.largeFileSystem GitLFS &&
+ git config git-p4.largeFileThreshold 13 &&
+ git p4 clone --use-client-spec --destination="$git" //depot@all &&
+
+ test_file_in_lfs file4.bin 14 "bin 14 bytesx" &&
+
+ find ".git/lfs/objects" -type f >actual &&
+ test_line_count = 1 actual &&
+
+ cat >expect <<-\EOF &&
+
+ #
+ # Git LFS (see https://git-lfs.github.com/)
+ #
+ /file4.bin filter=lfs -text
+ EOF
+ test_path_is_file .gitattributes &&
+ test_cmp expect .gitattributes
+ )
+'
+
+test_expect_success 'Store files in LFS based on extension (dat)' '
+ client_view "//depot/... //client/..." &&
+ test_when_finished cleanup_git &&
+ (
+ cd "$git" &&
+ git init . &&
+ git config git-p4.largeFileSystem GitLFS &&
+ git config git-p4.largeFileExtensions dat &&
+ git p4 clone --use-client-spec --destination="$git" //depot@all &&
+
+ test_file_in_lfs file2.dat 13 "bin 13 bytes" &&
+
+ find ".git/lfs/objects" -type f >actual &&
+ test_line_count = 1 actual &&
+
+ cat >expect <<-\EOF &&
+
+ #
+ # Git LFS (see https://git-lfs.github.com/)
+ #
+ *.dat filter=lfs -text
+ EOF
+ test_path_is_file .gitattributes &&
+ test_cmp expect .gitattributes
+ )
+'
+
+test_expect_success 'Store files in LFS based on size (>13 bytes) and extension (dat)' '
+ client_view "//depot/... //client/..." &&
+ test_when_finished cleanup_git &&
+ (
+ cd "$git" &&
+ git init . &&
+ git config git-p4.largeFileSystem GitLFS &&
+ git config git-p4.largeFileExtensions dat &&
+ git config git-p4.largeFileThreshold 13 &&
+ git p4 clone --use-client-spec --destination="$git" //depot@all &&
+
+ test_file_in_lfs file2.dat 13 "bin 13 bytes" &&
+ test_file_in_lfs file4.bin 14 "bin 14 bytesx" &&
+
+ find ".git/lfs/objects" -type f >actual &&
+ test_line_count = 2 actual &&
+
+ cat >expect <<-\EOF &&
+
+ #
+ # Git LFS (see https://git-lfs.github.com/)
+ #
+ *.dat filter=lfs -text
+ /file4.bin filter=lfs -text
+ EOF
+ test_path_is_file .gitattributes &&
+ test_cmp expect .gitattributes
+ )
+'
+
+test_expect_success 'Remove file from repo and store files in LFS based on size (>12 bytes)' '
+ client_view "//depot/... //client/..." &&
+ (
+ cd "$cli" &&
+ p4 delete file4.bin &&
+ p4 submit -d "Remove file"
+ ) &&
+
+ client_view "//depot/... //client/..." &&
+ test_when_finished cleanup_git &&
+ (
+ cd "$git" &&
+ git init . &&
+ git config git-p4.largeFileSystem GitLFS &&
+ git config git-p4.largeFileThreshold 12 &&
+ git p4 clone --use-client-spec --destination="$git" //depot@all &&
+
+ test_file_in_lfs file2.dat 13 "bin 13 bytes" &&
+ test_file_in_lfs "path with spaces/file3.bin" 13 "bin 13 bytes" &&
+ ! test_path_is_file file4.bin &&
+
+ find ".git/lfs/objects" -type f >actual &&
+ # 3 is correct here as some commits in the tree still reference the deleted file
+ test_line_count = 3 actual
+
+ cat >expect <<-\EOF &&
+
+ #
+ # Git LFS (see https://git-lfs.github.com/)
+ #
+ /file2.dat filter=lfs -text
+ /path[:space:]with[:space:]spaces/file3.bin filter=lfs -text
+ EOF
+ test_path_is_file .gitattributes &&
+ test_cmp expect .gitattributes
+ )
+'
+
+test_expect_success 'Add big files to repo and store files in LFS based on compressed size (>19 bytes)' '
+ client_view "//depot/... //client/..." &&
+ (
+ cd "$cli" &&
+ echo "bin 24 bytesxxxxxxxxxxx" >file5.bin &&
+ p4 add file5.bin &&
+ p4 submit -d "Add another binary file with different content" &&
+
+ echo "bin 34 bytesxxxxxxxxxxxzzzzzzzzzz" >file6.bin &&
+ p4 add file6.bin &&
+ p4 submit -d "Add another binary file with different content"
+ ) &&
+
+ client_view "//depot/... //client/..." &&
+ test_when_finished cleanup_git &&
+ (
+ cd "$git" &&
+ git init . &&
+ git config git-p4.largeFileSystem GitLFS &&
+ git config git-p4.largeFileCompressedThreshold 19 &&
+ # We only import HEAD here ("@all" is missing!)
+ git p4 clone --use-client-spec --destination="$git" //depot &&
+
+ test_file_in_lfs file6.bin 13 "bin 34 bytesxxxxxxxxxxxzzzzzzzzzz" &&
+
+ find ".git/lfs/objects" -type f >actual &&
+ test_line_count = 1 actual
+
+ cat >expect <<-\EOF &&
+
+ #
+ # Git LFS (see https://git-lfs.github.com/)
+ #
+ /file6.bin filter=lfs -text
+ EOF
+ test_path_is_file .gitattributes &&
+ test_cmp expect .gitattributes
+ )
+'
+
+test_expect_success 'Clone repo with existing .gitattributes file' '
+ client_view "//depot/... //client/..." &&
+ (
+ cd "$cli" &&
+
+ echo "*.txt text" >.gitattributes &&
+ p4 add .gitattributes &&
+ p4 submit -d "Add .gitattributes"
+ ) &&
+
+ test_must_fail git p4 clone --use-client-spec --destination="$git" //depot 2>errs &&
+ grep ".gitattributes already exists in P4." errs
+'
+
+test_expect_success 'kill p4d' '
+ kill_p4d
+'
+
+test_done
--
2.5.1
^ permalink raw reply related [flat|nested] 7+ messages in thread* Re: [PATCH v3 0/5] git-p4: add support for large file systems
2015-09-07 12:21 [PATCH v3 0/5] git-p4: add support for large file systems larsxschneider
` (4 preceding siblings ...)
2015-09-07 12:21 ` [PATCH v3 5/5] git-p4: add Git LFS backend for large file system larsxschneider
@ 2015-09-08 4:25 ` Luke Diamand
5 siblings, 0 replies; 7+ messages in thread
From: Luke Diamand @ 2015-09-08 4:25 UTC (permalink / raw)
To: Lars Schneider; +Cc: Git Users
On 7 September 2015 at 13:21, <larsxschneider@gmail.com> wrote:
> From: Lars Schneider <larsxschneider@gmail.com>
>
> One thing I don't like about the current implementation is that I don't see a
> way to test the "git-p4.pushLargeFiles" config. I could start a git lfs server
> locally but that seems a bit too much, no?
Perhaps add a trivial large-file derived class that just does enough
to show that it's all working. Then the final bit of pushing the large
files to LFS would remain forever untested, but it would be small
enough and simple enough not to be a real problem. If it ever broke,
it would indicate that either the trivial test class was a bit too
trivial, or that the abstraction was not abstract enough and there's
too much common-code in the derived classes.
Luke
^ permalink raw reply [flat|nested] 7+ messages in thread