~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/transport/http.py

  • Committer: Robert Collins
  • Date: 2005-10-09 23:42:12 UTC
  • Revision ID: robertc@robertcollins.net-20051009234212-7973344d900afb0b
merge in niemeyers prefixed-store patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
 
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
 
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
"""Implementation of Transport over http.
 
17
"""
 
18
 
 
19
from bzrlib.transport import Transport, register_transport
 
20
from bzrlib.errors import (TransportNotPossible, NoSuchFile, 
 
21
                           NonRelativePath, TransportError)
 
22
import os, errno
 
23
from cStringIO import StringIO
 
24
import urllib2
 
25
import urlparse
 
26
 
 
27
from bzrlib.errors import BzrError, BzrCheckError
 
28
from bzrlib.branch import Branch
 
29
from bzrlib.trace import mutter
 
30
 
 
31
# velocitynet.com.au transparently proxies connections and thereby
 
32
# breaks keep-alive -- sucks!
 
33
 
 
34
 
 
35
def get_url(url):
 
36
    import urllib2
 
37
    mutter("get_url %s" % url)
 
38
    url_f = urllib2.urlopen(url)
 
39
    return url_f
 
40
 
 
41
class HttpTransportError(TransportError):
 
42
    pass
 
43
 
 
44
class HttpTransport(Transport):
 
45
    """This is the transport agent for http:// access.
 
46
    
 
47
    TODO: Implement pipelined versions of all of the *_multi() functions.
 
48
    """
 
49
 
 
50
    def __init__(self, base):
 
51
        """Set the base path where files will be stored."""
 
52
        assert base.startswith('http://') or base.startswith('https://')
 
53
        super(HttpTransport, self).__init__(base)
 
54
        # In the future we might actually connect to the remote host
 
55
        # rather than using get_url
 
56
        # self._connection = None
 
57
        (self._proto, self._host,
 
58
            self._path, self._parameters,
 
59
            self._query, self._fragment) = urlparse.urlparse(self.base)
 
60
 
 
61
    def should_cache(self):
 
62
        """Return True if the data pulled across should be cached locally.
 
63
        """
 
64
        return True
 
65
 
 
66
    def clone(self, offset=None):
 
67
        """Return a new HttpTransport with root at self.base + offset
 
68
        For now HttpTransport does not actually connect, so just return
 
69
        a new HttpTransport object.
 
70
        """
 
71
        if offset is None:
 
72
            return HttpTransport(self.base)
 
73
        else:
 
74
            return HttpTransport(self.abspath(offset))
 
75
 
 
76
    def abspath(self, relpath):
 
77
        """Return the full url to the given relative path.
 
78
        This can be supplied with a string or a list
 
79
        """
 
80
        if isinstance(relpath, basestring):
 
81
            relpath = [relpath]
 
82
        basepath = self._path.split('/')
 
83
        if len(basepath) > 0 and basepath[-1] == '':
 
84
            basepath = basepath[:-1]
 
85
 
 
86
        for p in relpath:
 
87
            if p == '..':
 
88
                if len(basepath) < 0:
 
89
                    # In most filesystems, a request for the parent
 
90
                    # of root, just returns root.
 
91
                    continue
 
92
                if len(basepath) > 0:
 
93
                    basepath.pop()
 
94
            elif p == '.':
 
95
                continue # No-op
 
96
            else:
 
97
                basepath.append(p)
 
98
 
 
99
        # Possibly, we could use urlparse.urljoin() here, but
 
100
        # I'm concerned about when it chooses to strip the last
 
101
        # portion of the path, and when it doesn't.
 
102
        path = '/'.join(basepath)
 
103
        return urlparse.urlunparse((self._proto,
 
104
                self._host, path, '', '', ''))
 
105
 
 
106
    def relpath(self, abspath):
 
107
        if not abspath.startswith(self.base):
 
108
            raise NonRelativePath('path %r is not under base URL %r'
 
109
                           % (abspath, self.base))
 
110
        pl = len(self.base)
 
111
        return abspath[pl:].lstrip('/')
 
112
 
 
113
    def has(self, relpath):
 
114
        """Does the target location exist?
 
115
 
 
116
        TODO: HttpTransport.has() should use a HEAD request,
 
117
        not a full GET request.
 
118
 
 
119
        TODO: This should be changed so that we don't use
 
120
        urllib2 and get an exception, the code path would be
 
121
        cleaner if we just do an http HEAD request, and parse
 
122
        the return code.
 
123
        """
 
124
        try:
 
125
            f = get_url(self.abspath(relpath))
 
126
            # Without the read and then close()
 
127
            # we tend to have busy sockets.
 
128
            f.read()
 
129
            f.close()
 
130
            return True
 
131
        except BzrError:
 
132
            return False
 
133
        except urllib2.URLError:
 
134
            return False
 
135
        except IOError, e:
 
136
            if e.errno == errno.ENOENT:
 
137
                return False
 
138
            raise HttpTransportError(orig_error=e)
 
139
 
 
140
    def get(self, relpath, decode=False):
 
141
        """Get the file at the given relative path.
 
142
 
 
143
        :param relpath: The relative path to the file
 
144
        """
 
145
        try:
 
146
            return get_url(self.abspath(relpath))
 
147
        except (BzrError, urllib2.URLError, IOError), e:
 
148
            raise NoSuchFile(msg = "Error retrieving %s" 
 
149
                             % self.abspath(relpath),
 
150
                             orig_error=e)
 
151
        except Exception,e:
 
152
            raise HttpTransportError(orig_error=e)
 
153
 
 
154
    def get_partial(self, relpath, start, length=None):
 
155
        """Get just part of a file.
 
156
 
 
157
        :param relpath: Path to the file, relative to base
 
158
        :param start: The starting position to read from
 
159
        :param length: The length to read. A length of None indicates
 
160
                       read to the end of the file.
 
161
        :return: A file-like object containing at least the specified bytes.
 
162
                 Some implementations may return objects which can be read
 
163
                 past this length, but this is not guaranteed.
 
164
        """
 
165
        # TODO: You can make specialized http requests for just
 
166
        # a portion of the file. Figure out how to do that.
 
167
        # For now, urllib2 returns files that cannot seek() so
 
168
        # we just read bytes off the beginning, until we
 
169
        # get to the point that we care about.
 
170
        f = self.get(relpath)
 
171
        # TODO: read in smaller chunks, in case things are
 
172
        # buffered internally.
 
173
        f.read(start)
 
174
        return f
 
175
 
 
176
    def put(self, relpath, f):
 
177
        """Copy the file-like or string object into the location.
 
178
 
 
179
        :param relpath: Location to put the contents, relative to base.
 
180
        :param f:       File-like or string object.
 
181
        """
 
182
        raise TransportNotPossible('http PUT not supported')
 
183
 
 
184
    def mkdir(self, relpath):
 
185
        """Create a directory at the given path."""
 
186
        raise TransportNotPossible('http does not support mkdir()')
 
187
 
 
188
    def append(self, relpath, f):
 
189
        """Append the text in the file-like object into the final
 
190
        location.
 
191
        """
 
192
        raise TransportNotPossible('http does not support append()')
 
193
 
 
194
    def copy(self, rel_from, rel_to):
 
195
        """Copy the item at rel_from to the location at rel_to"""
 
196
        raise TransportNotPossible('http does not support copy()')
 
197
 
 
198
    def copy_to(self, relpaths, other, pb=None):
 
199
        """Copy a set of entries from self into another Transport.
 
200
 
 
201
        :param relpaths: A list/generator of entries to be copied.
 
202
 
 
203
        TODO: if other is LocalTransport, is it possible to
 
204
              do better than put(get())?
 
205
        """
 
206
        # At this point HttpTransport might be able to check and see if
 
207
        # the remote location is the same, and rather than download, and
 
208
        # then upload, it could just issue a remote copy_this command.
 
209
        if isinstance(other, HttpTransport):
 
210
            raise TransportNotPossible('http cannot be the target of copy_to()')
 
211
        else:
 
212
            return super(HttpTransport, self).copy_to(relpaths, other, pb=pb)
 
213
 
 
214
    def move(self, rel_from, rel_to):
 
215
        """Move the item at rel_from to the location at rel_to"""
 
216
        raise TransportNotPossible('http does not support move()')
 
217
 
 
218
    def delete(self, relpath):
 
219
        """Delete the item at relpath"""
 
220
        raise TransportNotPossible('http does not support delete()')
 
221
 
 
222
    def listable(self):
 
223
        """See Transport.listable."""
 
224
        return False
 
225
 
 
226
    def stat(self, relpath):
 
227
        """Return the stat information for a file.
 
228
        """
 
229
        raise TransportNotPossible('http does not support stat()')
 
230
 
 
231
    def lock_read(self, relpath):
 
232
        """Lock the given file for shared (read) access.
 
233
        :return: A lock object, which should be passed to Transport.unlock()
 
234
        """
 
235
        # The old RemoteBranch ignore lock for reading, so we will
 
236
        # continue that tradition and return a bogus lock object.
 
237
        class BogusLock(object):
 
238
            def __init__(self, path):
 
239
                self.path = path
 
240
            def unlock(self):
 
241
                pass
 
242
        return BogusLock(relpath)
 
243
 
 
244
    def lock_write(self, relpath):
 
245
        """Lock the given file for exclusive (write) access.
 
246
        WARNING: many transports do not support this, so trying avoid using it
 
247
 
 
248
        :return: A lock object, which should be passed to Transport.unlock()
 
249
        """
 
250
        raise TransportNotPossible('http does not support lock_write()')
 
251
 
 
252
register_transport('http://', HttpTransport)
 
253
register_transport('https://', HttpTransport)