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: list of tuple(name, sha)
32         """
33         raise NotImplementedError
34
35     def has_revision(self, sha):
36         """
37         Is a given sha in this repository?
38
39         :return: True or False
40         """
41         raise NotImplementedError
42
43     def apply_pack(self, refs, read):
44         """ Import a set of changes into a repository and update the refs
45
46         :param refs: list of tuple(name, sha)
47         :param read: callback to read from the incoming pack
48         """
49         raise NotImplementedError
50
51     def generate_pack(self, want, have, write, progress):
52         """
53         Generate a pack containing all commits a client is missing
54
55         :param want: is a list of sha's the client desires
56         :param have: is a list of sha's the client has (allowing us to send the minimal pack)
57         :param write: is a callback to write pack data to the client
58         :param progress: is a callback to send progress messages to the client
59         """
60         raise NotImplementedError
61
62
63 class GitBackend(Backend):
64
65     def __init__(self, gitdir=None):
66         self.gitdir = gitdir
67
68         if not self.gitdir:
69             self.gitdir = tempfile.mkdtemp()
70             Repo.create(self.gitdir)
71
72         self.repo = Repo(self.gitdir)
73
74     def get_refs(self):
75         refs = []
76         if self.repo.head():
77             refs.append(('HEAD', self.repo.head()))
78         for ref, sha in self.repo.heads().items():
79             refs.append(('refs/heads/'+ref,sha))
80         return refs
81
82     def has_revision(self, sha):
83         return self.repo.get_object(sha) != None
84
85     def apply_pack(self, refs, read):
86         # store the incoming pack in the repository
87         fd, name = tempfile.mkstemp(suffix='.pack', prefix='pack-', dir=self.repo.pack_dir())
88         os.write(fd, read())
89         os.close(fd)
90
91         # strip '.pack' off our filename
92         basename = name[:-5]
93
94         # generate an index for it
95         pd = PackData(name)
96         pd.create_index_v2(basename+".idx")
97
98         for oldsha, sha, ref in refs:
99             if ref == "0" * 40:
100                 self.repo.remove_ref(ref)
101             else:
102                 self.repo.set_ref(ref, sha)
103
104         print "pack applied"
105
106     def generate_pack(self, want, have, write, progress):
107         progress("dul-daemon says what\n")
108         sha_queue = generate_pack_contents(want, have, self.repo.get_object) 
109         write_pack_data(ProtocolFile(None, write), (self.repo.get_object(sha) for sha in sha_queue), len(sha_queue))
110         progress("how was that, then?\n")
111
112
113 class Handler(object):
114
115     def __init__(self, backend, read, write):
116         self.backend = backend
117         self.proto = Protocol(read, write)
118
119     def capabilities(self):
120         return " ".join(self.default_capabilities())
121
122
123 class UploadPackHandler(Handler):
124
125     def default_capabilities(self):
126         return ("multi_ack", "side-band-64k", "thin-pack", "ofs-delta")
127
128     def handle(self):
129         refs = self.backend.get_refs()
130
131         if refs:
132             self.proto.write_pkt_line("%s %s\x00%s\n" % (refs[0][1], refs[0][0], self.capabilities()))
133             for i in range(1, len(refs)):
134                 ref = refs[i]
135                 self.proto.write_pkt_line("%s %s\n" % (ref[1], ref[0]))
136
137         # i'm done..
138         self.proto.write("0000")
139
140         # Now client will either send "0000", meaning that it doesnt want to pull.
141         # or it will start sending want want want commands
142         want = self.proto.read_pkt_line()
143         if want == None:
144             return
145
146         want, client_capabilities = extract_capabilities(want)
147
148         # Keep reading the list of demands until we hit another "0000" 
149         want_revs = []
150         while want and want[:4] == 'want':
151             want_rev = want[5:45]
152             # FIXME: This check probably isnt needed?
153             if self.backend.has_revision(want_rev):
154                want_revs.append(want_rev)
155             want = self.proto.read_pkt_line()
156         
157         # Client will now tell us which commits it already has - if we have them we ACK them
158         # this allows client to stop looking at that commits parents (main reason why git pull is fast)
159         last_sha = None
160         have_revs = []
161         have = self.proto.read_pkt_line()
162         while have and have[:4] == 'have':
163             have_ref = have[5:45]
164             if self.backend.has_revision(have_ref):
165                 self.proto.write_pkt_line("ACK %s continue\n" % have_ref)
166                 last_sha = have_ref
167                 have_revs.append(have_ref)
168             have = self.proto.read_pkt_line()
169
170         # At some point client will stop sending commits and will tell us it is done
171         assert(have[:4] == "done")
172
173         # Oddness: Git seems to resend the last ACK, without the "continue" statement
174         if last_sha:
175             self.proto.write_pkt_line("ACK %s\n" % last_sha)
176
177         # The exchange finishes with a NAK
178         self.proto.write_pkt_line("NAK\n")
179       
180         self.backend.generate_pack(want_revs, have_revs, lambda x: self.proto.write_sideband(1, x), lambda x: self.proto.write_sideband(2, x))
181
182         # we are done
183         self.proto.write("0000")
184
185
186 class ReceivePackHandler(Handler):
187
188     def default_capabilities(self):
189         return ("report-status", "delete-refs")
190
191     def handle(self):
192         refs = self.backend.get_refs()
193
194         if refs:
195             self.proto.write_pkt_line("%s %s\x00%s\n" % (refs[0][1], refs[0][0], self.capabilities()))
196             for i in range(1, len(refs)):
197                 ref = refs[i]
198                 self.proto.write_pkt_line("%s %s\n" % (ref[1], ref[0]))
199         else:
200             self.proto.write_pkt_line("0000000000000000000000000000000000000000 capabilities^{} %s" % self.capabilities())
201
202         self.proto.write("0000")
203
204         client_refs = []
205         ref = self.proto.read_pkt_line()
206
207         # if ref is none then client doesnt want to send us anything..
208         if ref is None:
209             return
210
211         ref, client_capabilities = extract_capabilities(ref)
212
213         # client will now send us a list of (oldsha, newsha, ref)
214         while ref:
215             client_refs.append(ref.split())
216             ref = self.proto.read_pkt_line()
217
218         # backend can now deal with this refs and read a pack using self.read
219         self.backend.apply_pack(client_refs, self.proto.read)
220
221         # when we have read all the pack from the client, it assumes everything worked OK
222         # there is NO ack from the server before it reports victory.
223
224
225 class TCPGitRequestHandler(SocketServer.StreamRequestHandler):
226
227     def handle(self):
228         proto = Protocol(self.rfile.read, self.wfile.write)
229         command, args = proto.read_cmd()
230
231         # switch case to handle the specific git command
232         if command == 'git-upload-pack':
233             cls = UploadPackHandler
234         elif command == 'git-receive-pack':
235             cls = ReceivePackHandler
236         else:
237             return
238
239         h = cls(self.server.backend, self.rfile.read, self.wfile.write)
240         h.handle()
241
242
243 class TCPGitServer(SocketServer.TCPServer):
244
245     allow_reuse_address = True
246     serve = SocketServer.TCPServer.serve_forever
247
248     def __init__(self, backend, listen_addr, port=TCP_GIT_PORT):
249         self.backend = backend
250         SocketServer.TCPServer.__init__(self, (listen_addr, port), TCPGitRequestHandler)
251
252