Merge upstream
[jelmer/dulwich-libgit2.git] / dulwich / server.py
1 # server.py -- Implementation of the server side git protocols
2 # Copryight (C) 2008 John Carr <john.carr@unrouted.co.uk>
3 #
4 # This program is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU General Public License
6 # as published by the Free Software Foundation; version 2
7 # of the License.
8 #
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 # GNU General Public License for more details.
13 #
14 # You should have received a copy of the GNU General Public License
15 # along with this program; if not, write to the Free Software
16 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
17 # MA  02110-1301, USA.
18
19 import SocketServer
20 from dulwich.protocol import Protocol, ProtocolFile, TCP_GIT_PORT, extract_capabilities
21 from dulwich.repo import Repo
22 from dulwich.pack import PackData, Pack, write_pack_data, generate_pack_contents
23 import os, sha, tempfile
24
25 class Backend(object):
26
27     def get_refs(self):
28         """
29         Get all the refs in the repository
30
31         :return: dict of name -> sha
32         """
33         raise NotImplementedError
34
35     def apply_pack(self, refs, read):
36         """ Import a set of changes into a repository and update the refs
37
38         :param refs: list of tuple(name, sha)
39         :param read: callback to read from the incoming pack
40         """
41         raise NotImplementedError
42
43     def fetch_objects(self, determine_wants, graph_waker, progress):
44         """
45         Yield the objects required for a list of commits.
46
47         :param progress: is a callback to send progress messages to the client
48         """
49         raise NotImplementedError
50
51
52 class GitBackend(Backend):
53
54     def __init__(self, gitdir=None):
55         self.gitdir = gitdir
56
57         if not self.gitdir:
58             self.gitdir = tempfile.mkdtemp()
59             Repo.create(self.gitdir)
60
61         self.repo = Repo(self.gitdir)
62
63     def get_refs(self):
64         return self.repo.get_refs()
65
66     def apply_pack(self, refs, read):
67         # store the incoming pack in the repository
68         fd, name = tempfile.mkstemp(suffix='.pack', prefix='pack-', dir=self.repo.pack_dir())
69         os.write(fd, read())
70         os.close(fd)
71
72         # strip '.pack' off our filename
73         basename = name[:-5]
74
75         # generate an index for it
76         pd = PackData(name)
77         pd.create_index_v2(basename+".idx")
78
79         for oldsha, sha, ref in refs:
80             if ref == "0" * 40:
81                 self.repo.remove_ref(ref)
82             else:
83                 self.repo.set_ref(ref, sha)
84
85         print "pack applied"
86
87     def fetch_objects(self, determine_wants, graph_waker, progress):
88         for sha in generate_pack_contents(determine_wants(), have, self.repo.get_object):
89             yield self.repo.get_object(sha)
90
91
92 class Handler(object):
93
94     def __init__(self, backend, read, write):
95         self.backend = backend
96         self.proto = Protocol(read, write)
97
98     def capabilities(self):
99         return " ".join(self.default_capabilities())
100
101
102 class UploadPackHandler(Handler):
103
104     def default_capabilities(self):
105         return ("multi_ack", "side-band-64k", "thin-pack", "ofs-delta")
106
107     def handle(self):
108         def determine_wants(heads):
109             keys = heads.keys()
110             if keys:
111                 self.proto.write_pkt_line("%s %s\x00%s\n" % (keys[0], heads[keys[0]], self.capabilities()))
112                 for k in keys[1:]:
113                     self.proto.write_pkt_line("%s %s\n" % (k, heads[k]))
114
115             # i'm done..
116             self.proto.write("0000")
117
118             # Now client will either send "0000", meaning that it doesnt want to pull.
119             # or it will start sending want want want commands
120             want = self.proto.read_pkt_line()
121             if want == None:
122                 return []
123
124             want, self.client_capabilities = extract_capabilities(want)
125
126             want_revs = []
127             while want and want[:4] == 'want':
128                 want_rev = want[5:45]
129                 # FIXME: This check probably isnt needed?
130                 want_revs.append(want_rev)
131                 want = self.proto.read_pkt_line()
132             return want_revs
133
134         progress = lambda x: self.proto.write_sideband(2, x)
135
136         class ProtocolGraphWalker(object):
137
138             def __init__(self):
139                 self._last_sha = None
140
141             def ack(self, have_ref):
142                 self.proto.write_pkt_line("ACK %s continue\n" % have_ref)
143
144             def next(self):
145                 have = self.proto.read_pkt_line()
146                 if have[:4] == 'have':
147                     return have[5:45]
148
149                 if have[:4] == 'done':
150                     return None
151
152                 if self._last_sha:
153                     # Oddness: Git seems to resend the last ACK, without the "continue" statement
154                     self.proto.write_pkt_line("ACK %s\n" % self._last_sha)
155
156                 # The exchange finishes with a NAK
157                 self.proto.write_pkt_line("NAK\n")
158
159         objects = list(self.backend.fetch_objects(determine_wants, graph_walker, progress))
160         progress("dul-daemon says what\n")
161         progress("counting objects: %d, done.\n" % len(objects))
162         write_pack_data(ProtocolFile(None, write), objects, len(objects))
163         progress("how was that, then?\n")
164         # we are done
165         self.proto.write("0000")
166
167
168 class ReceivePackHandler(Handler):
169
170     def default_capabilities(self):
171         return ("report-status", "delete-refs")
172
173     def handle(self):
174         refs = self.backend.get_refs().items()
175
176         if refs:
177             self.proto.write_pkt_line("%s %s\x00%s\n" % (refs[0][1], refs[0][0], self.capabilities()))
178             for i in range(1, len(refs)):
179                 ref = refs[i]
180                 self.proto.write_pkt_line("%s %s\n" % (ref[1], ref[0]))
181         else:
182             self.proto.write_pkt_line("0000000000000000000000000000000000000000 capabilities^{} %s" % self.capabilities())
183
184         self.proto.write("0000")
185
186         client_refs = []
187         ref = self.proto.read_pkt_line()
188
189         # if ref is none then client doesnt want to send us anything..
190         if ref is None:
191             return
192
193         ref, client_capabilities = extract_capabilities(ref)
194
195         # client will now send us a list of (oldsha, newsha, ref)
196         while ref:
197             client_refs.append(ref.split())
198             ref = self.proto.read_pkt_line()
199
200         # backend can now deal with this refs and read a pack using self.read
201         self.backend.apply_pack(client_refs, self.proto.read)
202
203         # when we have read all the pack from the client, it assumes everything worked OK
204         # there is NO ack from the server before it reports victory.
205
206
207 class TCPGitRequestHandler(SocketServer.StreamRequestHandler):
208
209     def handle(self):
210         proto = Protocol(self.rfile.read, self.wfile.write)
211         command, args = proto.read_cmd()
212
213         # switch case to handle the specific git command
214         if command == 'git-upload-pack':
215             cls = UploadPackHandler
216         elif command == 'git-receive-pack':
217             cls = ReceivePackHandler
218         else:
219             return
220
221         h = cls(self.server.backend, self.rfile.read, self.wfile.write)
222         h.handle()
223
224
225 class TCPGitServer(SocketServer.TCPServer):
226
227     allow_reuse_address = True
228     serve = SocketServer.TCPServer.serve_forever
229
230     def __init__(self, backend, listen_addr, port=TCP_GIT_PORT):
231         self.backend = backend
232         SocketServer.TCPServer.__init__(self, (listen_addr, port), TCPGitRequestHandler)
233
234