[PATCH v3 0/2] allow git-svn fetching to work using serf

[PATCH v3 0/2] allow git-svn fetching to work using serf

[Kyle J. McKay]

From: "Kyle J. McKay" <mackyle@gmail.com>

This patch allows git-svn to fetch successfully using the
serf library when given an https?: url to fetch from.

Unfortunately some svn servers do not seem to be configured
well for use with the serf library.  This can cause fetching
to take longer compared to the neon library or actually
cause timeouts during the fetch.  When timeouts occur
git-svn can be safely restarted to fetch more revisions.

A new temp_is_locked function has been added to Git.pm
to facilitate using the minimal number of temp files
possible when using serf.

The problem that occurs when running git-svn fetch using
the serf library is that the previously used temp file
is not always unlocked before the next temp file needs
to be used.

To work around this problem, a new temp name is used
if the temp name that would otherwise be chosen is
currently locked.

Version v2 of the patch introduced a bug when changing the _temp_cache
function to use the new temp_is_locked function at the suggestion of a
reviewer.  That has now been resolved.

Kyle J. McKay (2):
  Git.pm: add new temp_is_locked function
  git-svn: allow git-svn fetching to work using serf

 perl/Git.pm             | 33 +++++++++++++++++++++++++++++++--
 perl/Git/SVN/Fetcher.pm |  6 ++++--
 2 files changed, 35 insertions(+), 4 deletions(-)

-- 
1.8.3

[PATCH v3 1/2] Git.pm: add new temp_is_locked function

[Kyle J. McKay]

From: "Kyle J. McKay" <mackyle@gmail.com>

The temp_is_locked function can be used to determine whether
or not a given name previously passed to temp_acquire is
currently locked.

Signed-off-by: Kyle J. McKay <mackyle@gmail.com>
---
 perl/Git.pm | 33 +++++++++++++++++++++++++++++++--
 1 file changed, 31 insertions(+), 2 deletions(-)

diff --git a/perl/Git.pm b/perl/Git.pm
index 7a252ef..0ba15b9 100644
--- a/perl/Git.pm
+++ b/perl/Git.pm
@@ -61,7 +61,7 @@ require Exporter;
                 remote_refs prompt
                 get_tz_offset
                 credential credential_read credential_write
-                temp_acquire temp_release temp_reset temp_path);
+                temp_acquire temp_is_locked temp_release temp_reset temp_path);
 
 
 =head1 DESCRIPTION
@@ -1206,6 +1206,35 @@ sub temp_acquire {
 	$temp_fd;
 }
 
+=item temp_is_locked ( NAME )
+
+Returns true if the internal lock created by a previous C<temp_acquire()>
+call with C<NAME> is still in effect.
+
+When temp_acquire is called on a C<NAME>, it internally locks the temporary
+file mapped to C<NAME>.  That lock will not be released until C<temp_release()>
+is called with either the original C<NAME> or the L<File::Handle> that was
+returned from the original call to temp_acquire.
+
+Subsequent attempts to call C<temp_acquire()> with the same C<NAME> will fail
+unless there has been an intervening C<temp_release()> call for that C<NAME>
+(or its corresponding L<File::Handle> that was returned by the original
+C<temp_acquire()> call).
+
+If true is returned by C<temp_is_locked()> for a C<NAME>, an attempt to
+C<temp_acquire()> the same C<NAME> will cause an error unless
+C<temp_release> is first called on that C<NAME> (or its corresponding
+L<File::Handle> that was returned by the original C<temp_acquire()> call).
+
+=cut
+
+sub temp_is_locked {
+	my ($self, $name) = _maybe_self(@_);
+	my $temp_fd = \$TEMP_FILEMAP{$name};
+
+	defined $$temp_fd && $$temp_fd->opened && $TEMP_FILES{$$temp_fd}{locked};
+}
+
 =item temp_release ( NAME )
 
 =item temp_release ( FILEHANDLE )
@@ -1248,7 +1277,7 @@ sub _temp_cache {
 
 	my $temp_fd = \$TEMP_FILEMAP{$name};
 	if (defined $$temp_fd and $$temp_fd->opened) {
-		if ($TEMP_FILES{$$temp_fd}{locked}) {
+		if (temp_is_locked($name)) {
 			throw Error::Simple("Temp file with moniker '" .
 				$name . "' already in use");
 		}
-- 
1.8.3

Re: [PATCH v3 1/2] Git.pm: add new temp_is_locked function

[David Rothenberger]

Kyle J. McKay <mackyle <at> gmail.com> writes:

> +sub temp_is_locked {
> +	my ($self, $name) = _maybe_self( <at> _);
> +	my $temp_fd = \$TEMP_FILEMAP{$name};
> +
> +	defined $$temp_fd && $$temp_fd->opened && $TEMP_FILES{$$temp_fd}{locked};
> +}
> +
>  =item temp_release ( NAME )
> 
>  =item temp_release ( FILEHANDLE )
>  <at>  <at>  -1248,7 +1277,7  <at>  <at>  sub _temp_cache {
> 
>  	my $temp_fd = \$TEMP_FILEMAP{$name};
>  	if (defined $$temp_fd and $$temp_fd->opened) {
> -		if ($TEMP_FILES{$$temp_fd}{locked}) {
> +		if (temp_is_locked($name)) {
>  			throw Error::Simple("Temp file with moniker '" .
>  				$name . "' already in use");
>  		}

There's a problem with this use of temp_is_locked. There is an else
clause right after this:

	} else {
		if (defined $$temp_fd) {
			# then we're here because of a closed handle.

Prior to the patch, the comment is correct, but after the patch, the
if block may also be entered if the file is open but locked. This is
because temp_is_locked checks that the temp file is defined, open,
and locked.

This issue leads to lots of 

  Temp file 'svn_delta_3360_0' was closed. Opening replacement. 

messages for me.

Reverting the change in _temp_cache solves the problem for me.
Adding an " && !$$temp_fd->opened" clause to the if statement also
works, but this is less efficient.

Re: [PATCH v3 1/2] Git.pm: add new temp_is_locked function

[Kyle J. McKay]

On Jul 18, 2013, at 11:34, David Rothenberger wrote:
> Kyle J. McKay <mackyle <at> gmail.com> writes:
>
>> +sub temp_is_locked {
>> +	my ($self, $name) = _maybe_self( <at> _);
>> +	my $temp_fd = \$TEMP_FILEMAP{$name};
>> +
>> +	defined $$temp_fd && $$temp_fd->opened && $TEMP_FILES{$$temp_fd} 
>> {locked};
>> +}
>> +
>> =item temp_release ( NAME )
>>
>> =item temp_release ( FILEHANDLE )
>> <at>  <at>  -1248,7 +1277,7  <at>  <at>  sub _temp_cache {
>>
>> 	my $temp_fd = \$TEMP_FILEMAP{$name};
>> 	if (defined $$temp_fd and $$temp_fd->opened) {
>> -		if ($TEMP_FILES{$$temp_fd}{locked}) {
>> +		if (temp_is_locked($name)) {
>> 			throw Error::Simple("Temp file with moniker '" .
>> 				$name . "' already in use");
>> 		}
>
> There's a problem with this use of temp_is_locked. There is an else
> clause right after this:
>
> 	} else {
> 		if (defined $$temp_fd) {
> 			# then we're here because of a closed handle.
>
> Prior to the patch, the comment is correct, but after the patch, the
> if block may also be entered if the file is open but locked. This is
> because temp_is_locked checks that the temp file is defined, open,
> and locked.
>
> This issue leads to lots of
>
>  Temp file 'svn_delta_3360_0' was closed. Opening replacement.
>
> messages for me.
>
> Reverting the change in _temp_cache solves the problem for me.
> Adding an " && !$$temp_fd->opened" clause to the if statement also
> works, but this is less efficient.

That change was made as a result of this feedback:

On Jul 6, 2013, at 17:11, Jonathan Nieder wrote:
> Hi,
>
> Kyle McKay wrote:
>
>> The temp_is_locked function can be used to determine whether
>> or not a given name previously passed to temp_acquire is
>> currently locked.
> [...]
>> +=item temp_is_locked ( NAME )
>> +
>> +Returns true if the file mapped to C<NAME> is currently locked.
>> +
>> +If true is returned, an attempt to C<temp_acquire()> the same
>
[snip]
>
> Looking more closely, it looks like this is factoring out the idiom
> for checking if a name is already in use from the _temp_cache
> function.  Would it make sense for _temp_cache to call this helper?

So I think the answer is it does not make sense for _temp_cache to  
call this helper.

Will release a v4 in just a moment with that single change reverted.

Re: [PATCH v3 1/2] Git.pm: add new temp_is_locked function

[Jonathan Nieder]

Kyle J. McKay wrote:

> That change was made as a result of this feedback:
>
> On Jul 6, 2013, at 17:11, Jonathan Nieder wrote:
>> Kyle McKay wrote:
>>
>>> The temp_is_locked function can be used to determine whether
>>> or not a given name previously passed to temp_acquire is
>>> currently locked.
>> [...]
>>> +=item temp_is_locked ( NAME )
>>> +
>>> +Returns true if the file mapped to C<NAME> is currently locked.
>>> +
>>> +If true is returned, an attempt to C<temp_acquire()> the same
>>
> [snip]
>
>> Looking more closely, it looks like this is factoring out the idiom
>> for checking if a name is already in use from the _temp_cache
>> function.  Would it make sense for _temp_cache to call this helper?
>
> So I think the answer is it does not make sense for _temp_cache to
> call this helper.

Thanks for looking into it.

Sorry for the confusion.  The point of my question was an example of a
way to make sure the internal API stays easy to understand.  But it
seems to have backfired, and this is a small enough isolated change
that I think it's okay to say "let's clean it up later".

> Will release a v4 in just a moment with that single change reverted.

Thanks.

[PATCH v3 2/2] git-svn: allow git-svn fetching to work using serf

[Kyle J. McKay]

From: "Kyle J. McKay" <mackyle@gmail.com>

When attempting to git-svn fetch files from an svn https?: url using
the serf library (the only choice starting with svn 1.8) the following
errors can occur:

Temp file with moniker 'svn_delta' already in use at Git.pm line 1250
Temp file with moniker 'git_blob' already in use at Git.pm line 1250

David Rothenberger <daveroth@acm.org> has determined the cause to
be that ra_serf does not drive the delta editor in a depth-first
manner [...]. Instead, the calls come in this order:

1. open_root
2. open_directory
3. add_file
4. apply_textdelta
5. add_file
6. apply_textdelta

When using the ra_serf access method, git-svn can end up needing
to create several temp files before the first one is closed.

This change causes a new temp file moniker to be generated if the
one that would otherwise have been used is currently locked.

Signed-off-by: Kyle J. McKay <mackyle@gmail.com>
---
 perl/Git/SVN/Fetcher.pm | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/perl/Git/SVN/Fetcher.pm b/perl/Git/SVN/Fetcher.pm
index bd17418..10edb27 100644
--- a/perl/Git/SVN/Fetcher.pm
+++ b/perl/Git/SVN/Fetcher.pm
@@ -315,11 +315,13 @@ sub change_file_prop {
 sub apply_textdelta {
 	my ($self, $fb, $exp) = @_;
 	return undef if $self->is_path_ignored($fb->{path});
-	my $fh = $::_repository->temp_acquire('svn_delta');
+	my $suffix = 0;
+	++$suffix while $::_repository->temp_is_locked("svn_delta_${$}_$suffix");
+	my $fh = $::_repository->temp_acquire("svn_delta_${$}_$suffix");
 	# $fh gets auto-closed() by SVN::TxDelta::apply(),
 	# (but $base does not,) so dup() it for reading in close_file
 	open my $dup, '<&', $fh or croak $!;
-	my $base = $::_repository->temp_acquire('git_blob');
+	my $base = $::_repository->temp_acquire("git_blob_${$}_$suffix");
 
 	if ($fb->{blob}) {
 		my ($base_is_link, $size);
-- 
1.8.3

Re: [PATCH v3 0/2] allow git-svn fetching to work using serf

[Junio C Hamano]

"Kyle J. McKay" <mackyle@gmail.com> writes:

> From: "Kyle J. McKay" <mackyle@gmail.com>
>
> This patch allows git-svn to fetch successfully using the
> serf library when given an https?: url to fetch from.
>
> Unfortunately some svn servers do not seem to be configured
> well for use with the serf library.  This can cause fetching
> to take longer compared to the neon library or actually
> cause timeouts during the fetch.  When timeouts occur
> git-svn can be safely restarted to fetch more revisions.
>
> A new temp_is_locked function has been added to Git.pm
> to facilitate using the minimal number of temp files
> possible when using serf.
>
> The problem that occurs when running git-svn fetch using
> the serf library is that the previously used temp file
> is not always unlocked before the next temp file needs
> to be used.
>
> To work around this problem, a new temp name is used
> if the temp name that would otherwise be chosen is
> currently locked.
>
> Version v2 of the patch introduced a bug when changing the _temp_cache
> function to use the new temp_is_locked function at the suggestion of a
> reviewer.  That has now been resolved.

Thanks; I've queued this version to 'pu' at least tentatively.

Is everybody who discussed the issue happy with the direction of
this patch?