idea

remove unused imports

remove uuid from annex+http urls

Not needed it turns out.

set remote's annexUrl automatically

When the remote repository's git config file
has annex.url set to an annex+http url.

todo

documentation for p2phttp

avoid repeatedly parsing the proxy log

update

todo

fix hang in PUT of large file to a special remote node of a cluster over http

use closedv rather than separate endv

Doesn't fix any known problem, but this way if the connection does get
closed, it will notice.

remove temp file after upload to special remote

Merge remote-tracking branch 'origin/master' into httpproto

update

clean shut down of cluster connection when PUT is interrupted

An interrupted `git-annex copy --to` a cluster via the http server,
when repeated, failed. The http server output "transfer already in
progress, or unable to take transfer lock". Apparently a second
connection was opened to the cluster, because the first connection
never got shut down.

Turned out the problem was that when proxying to a cluster, it would read a
short ByteString from the client, and send that to the nodes. But that left the
nodes warning more. Meanwhile, the proxy was expecting a SUCCESS/FAILURE
message from the nodes. So it didn't return, and so the cluster connection
stayed open.

fix http proxying for a local git remote with a relative path

git-annex-shell expects an absolute path

found some bugs with clusters

clusters need enableInteractiveBranchAccess

As seen in commit 770aac97a75f64b86d73240055acffe1a5ed9f1a, a cluster
relies accurate location logs. If long-running processes are serving a
cluster, and one process puts a file, the other process needs to see
what nodes it was stored on when checking if the file is present.

smarter BranchState cache invalidation

Only invalidate a just-written file in the cache, not the whole cache.

This will avoid the possibly performance impact of cache invalidation
mentioned in commit 770aac97a75f64b86d73240055acffe1a5ed9f1a

share single BranchState amoung all threads

This fixes a problem when git-annex testremote is run against a cluster
accessed via the http server. Annex.Cluster uses the location log
to find nodes that contain a key when checking if the key is present or getting
it. Just after a key was stored to a cluster node, reading the location log
was not getting the UUID of that node.

Apparently the Annex action that wrote to the location log, and the one
that read from it were run with two different Annex states. The http server
does use several different Annex threads.

BranchState was part of the AnnexState, and so two threads could have
different BranchStates.

Moved BranchState to the AnnexRead, so all threads will see the common state.

This might possibly impact performance. If one thread is writing changes to the
branch, and another thread is reading from the branch, the writing thread will
now invalidate the BranchState's cache, which will cause the reading thread to
need to do extra work. But correctness is surely more important. If did is
found to have impacted performance, it could probably be dealt with by doing
smarter BranchState cache invalidation.

Another way this might impact performance is that the BranchState has a small
cache. If several threads were reading from the branch and relying on the value
they just read still being in the case, now a cache miss will be more likely.
Increasing the BranchState cache to the number of jobs might be a good
idea to amelorate that. But the cache is currently an innefficient list,
so making it large would need changes to the data types.

(Commit 4304f1b6aea19a5c402dc4f9d69aa4ff1c104c9b dealt with a follow-on
effect of the bug fixed here.)

better handling of content not available from cluster

Sending ERROR caused the client to get confused and protocol to freeze.
Better to send empty DATA and indicate it's not valid.

This fixes a hang in git-annex testremote of a cluster accessed via the
http server. That testremote is still failing, for some reason after
storing a test key, the cluster reports it as not present.

add --clusterjobs option and default to 1

The default of 1 is not ideal at all, but it avoids an accidental M*N
causing so much concurrency it becomes unusable.

cluster support in http API server

Wired it up and it seems to basically work, although the test suite is
not fully passing.

Note that --jobs currently gets multiplied by the number of nodes in the
cluster, which is probably not good.

remove duplicate code

tested shutdown of connection to http proxied special remote

I had worried it might not work properly, but it does, the endv works.

fix PUT to http proxied special remote

It was hanging because it never sent FAILURE in the INVALID case.
And putoffset always triggers the INVALID case.

thoughts on exporttree

update

UNLOCKCONTENT is not a top-level request

proxyRequest was treating UNLOCKCONTENT as a separate request.
That made it possible for there to be two different connections to the
proxied remote, with LOCKCONTENT being sent to one, and UNLOCKCONTENT
to the other one. A protocol error.

git-annex testremote now passes against a http proxied remote.

fix hang at end of PUT to proxied p2p http remote

sendExactly will now be sure to evaluate the whole lazy ByteString.

In this case, the lazy ByteString was exactly the right lenth.
But, it seems that L.take caused it to not actually be fully evaluated.

In servePut, this manifested as gather never being fully evaluated,
which caused the hang.

Very, very subtle, and horrible bug. Clearly the use of lazy ByteString
(or really just laziness) is at fault, and it would be very worth moving
to conduit or whatever to avoid this.

update

implement proxy connection pool

removeOldestProxyConnectionPool will be innefficient the larger the pool
is. A better data structure could be more efficient. Eg, make each value
in the pool include the timestamp of its oldest element, then the oldest
value can be found and modified, rather than rebuilding the whole Map.

But, for pools of a few hundred items, this should be fine. It's O(n*n log n)
or so.

Also, when more than 1 connection with the same pool key exists,
it's efficient even for larger pools, since removeOldestProxyConnectionPool
is not needed.

The default of 1 idle connection could perhaps be larger.. like the
number of jobs? Otoh, it seems good to ramp up and down the number of
connections, which does happen. With 1, there is at most one stale
connection, which might cause a request to fail.

initial report on keeping association with the remote

closeP2PConnection on interrupted GET

clean up after http p2p proxy GET is interrupted

There was an annex worker thread that did not get stopped.

It was stuck in ReceiveMessage from the P2PHandleTMVar.

Fixed by making P2PHandleTMVar closeable.

In serveGet, releaseP2PConnection has to come first, else the
annexworker may not shut down, if it's waiting to read from it.

In proxyConnection, call closeRemoteSide in order to wait for the ssh
process (for example).

close proxy remote side when done with it

oops

oops

clean up protocol version for proxying

The proxy always checks the protocol version of a remote before talking
to it in a version-specific way, so the protocol version in the ProxyParams
is the client's protocol version. The remote will always be at the same or
an older protocol version than the client.

Note that in relayDATAFinish, when the client is at protocol version 0,
the remote must thus be as well, and that's why its version is not
checked in the case for that.

With that clarified, it's evident that, in P2P.Http.State, there's no
need to look at the proxied remote's protocol version at all.

fix setting protocol version for v0 server

Before it was leaving the protocol version at the default, when it
was actually v0.

v0 has only ever been used over tor, which is probably why this bug was
never noticed.

fix hang in GET from http p2p proxy

serverP2PConnection = proxyfromclientconn causes serveGet to
signalFullyConsumedByteString to it, which is what it's waiting for

improve comment

update

http p2p proxy is now largely working

Added a comment

remove some debugging

wip

use a record to reduce the huge number of parameters

factored out proxyRequest

This will allow the HTTP server to keep a connection to a proxied
remote open, and only enter the Annex monad when handling a client
request.

http server support for proxies, incomplete

Refactored git-annex-shell code so this can use checkCanProxy'.

At this point all that remains is opening a proxy connection,
and using a proxy connection.

use annex+http for accessing proxies

Doesn't work yet on the http server side, which is throwing 502 bad
gateway.

less indent

p2phttp drop supports checking proof timestamps

At this point the p2phttp implementation is fully complete!

add common parameters to generic get API

Honestly this was just done to make the documentation correct. There's
no point in using these parameters. And they're optional.

fix build without servant

testremote passes on p2phttp remote

expire lock after 10 minutes initially

Once keeplocked is called, the lock will expire at the end
of that call. But if keeplocked never gets called, this avoids
the lock persisting forever.

Remote.Git lockContent works with annex+http urls

Remote.Git removeKey works with annex+http urls

Does not yet handle drop proof lock timestamp checking.

update

update

progress meter for p2phttp storeKey

Remote.Git storeKey works with annex+http urls

Does not yet update progress meter.

update

more generic clientGet

fix slowloris timeout in hashing resume of download of large file

Hash the data that is already present in the file before connecting to
the http server.

fix meter display on resume

It still needs to be offset, otherwise on resume from 80% it will
display 1%..20%.

Seems that this bug must have affected P2P.Annex as well where it runs
this code, but apparently it didn't affect it in a very user-visible
way. Maybe the transfer log file was updated incorrectly?

Remote.Git retrieveKeyFile works with annex+http urls

This includes a bugfix to serveGet, it hung at the end.

factor out resumeVerifyFromOffset

avoid needing ifdefs when using P2P.Http.Client

Merge branch 'master' into httpproto

Propagate --force to git-annex transferrer

And other child processes.

bug

cache credentials for p2phttp in memory

remove uuid from url when calling git credential

The user doesn't want to see a uuid in the prompt.

Also, when a http server is proxying, multiple remotes will have the
same base url, and the same password will work for them all.

use git credential when p2phttp needs auth

p2phttp support https

add --bind option and listen to both ipv4 and ipv6 by default

protocol version fallback on 404

and prettified errors

Remote.Git checkpresent works with annex+http urls.

factor out http server and client into own modules

To avoid a cycle when Remote.Git uses the client.

started wiring p2phttp into Remote.Git

but we have a cycle, ugh

require a valid uuid at the end of an annex+http url

add remoteAnnexP2PHttpUrl to RemoveGitConfig

This is always parsed, when building without servant, a Baseurl is not
generated, and users of it will need to fail.

starting support for remote.name.annexUrl set to annex+http

In this case, Remote.Git should not use that url for all access to
the repository. It will only be used for annex operations, which isn't
done yet.

update servant build flag

make it work when building w/o assistant

update

annex+http urls

refactor

fix build

update

change default port to 9417

Port 80 would need root, not a good idea, so pick something that might
work by default.

9418 is git protocol's port. 9419 is used by something, but nothing
known uses 9417, so it's as good a default as any.

exit cleanly on eg, failure to bind socket

P2P protocol is finalized

make keeplocked client UUID optional

It's not used, but it makes the protocol simpler if this parameter can
always be sent.

locking over http basically working

make serveKeepLocked check auth just to be safe

implement clientLockContent

implemented serveLockContent (untested)

improve clientKeepLocked