/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/transport/gio_transport.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
26
26
 
27
27
from __future__ import absolute_import
28
28
 
29
 
from cStringIO import StringIO
30
29
import os
31
30
import random
32
31
import stat
33
32
import time
34
33
import urlparse
35
34
 
36
 
from bzrlib import (
 
35
from .. import (
37
36
    config,
38
37
    errors,
39
38
    osutils,
41
40
    debug,
42
41
    ui,
43
42
    )
44
 
from bzrlib.symbol_versioning import (
 
43
from ..sixish import (
 
44
    BytesIO,
 
45
    )
 
46
from ..symbol_versioning import (
45
47
    DEPRECATED_PARAMETER,
46
48
    deprecated_in,
47
49
    deprecated_passed,
48
50
    warn,
49
51
    )
50
 
from bzrlib.trace import mutter
51
 
from bzrlib.transport import (
 
52
from ..trace import mutter
 
53
from . import (
52
54
    FileStream,
53
55
    ConnectedTransport,
54
56
    _file_streams,
55
57
    )
56
58
 
57
 
from bzrlib.tests.test_server import TestServer
 
59
from ..tests.test_server import TestServer
58
60
 
59
61
try:
60
62
    import glib
61
 
except ImportError, e:
 
63
except ImportError as e:
62
64
    raise errors.DependencyNotPresent('glib', e)
63
65
try:
64
66
    import gio
65
 
except ImportError, e:
 
67
except ImportError as e:
66
68
    raise errors.DependencyNotPresent('gio', e)
67
69
 
68
70
 
98
100
    def write(self, bytes):
99
101
        try:
100
102
            #Using pump_string_file seems to make things crash
101
 
            osutils.pumpfile(StringIO(bytes), self.stream)
102
 
        except gio.Error, e:
 
103
            osutils.pumpfile(BytesIO(bytes), self.stream)
 
104
        except gio.Error as e:
103
105
            #self.transport._translate_gio_error(e,self.relpath)
104
106
            raise errors.BzrError(str(e))
105
107
 
165
167
        return file
166
168
 
167
169
    def _auth_cb(self, op, message, default_user, default_domain, flags):
168
 
        #really use bzrlib.auth get_password for this
 
170
        #really use breezy.auth get_password for this
169
171
        #or possibly better gnome-keyring?
170
172
        auth = config.AuthenticationConfig()
171
173
        parsed_url = urlutils.URL.from_string(self.url)
206
208
        try:
207
209
            obj.mount_enclosing_volume_finish(res)
208
210
            self.loop.quit()
209
 
        except gio.Error, e:
 
211
        except gio.Error as e:
210
212
            self.loop.quit()
211
213
            raise errors.BzrError("Failed to mount the given location: " + str(e));
212
214
 
221
223
            mount = None
222
224
            try:
223
225
                mount = connection.find_enclosing_mount()
224
 
            except gio.Error, e:
 
226
            except gio.Error as e:
225
227
                if (e.code == gio.ERROR_NOT_MOUNTED):
226
228
                    self.loop = glib.MainLoop()
227
229
                    ui.ui_factory.show_message('Mounting %s using GIO' % \
235
237
                    m = connection.mount_enclosing_volume(op,
236
238
                            self._mount_done_cb)
237
239
                    self.loop.run()
238
 
        except gio.Error, e:
 
240
        except gio.Error as e:
239
241
            raise errors.TransportError(msg="Error setting up connection:"
240
242
                                        " %s" % str(e), orig_error=e)
241
243
        return connection, (user, password)
265
267
            if stat.S_ISREG(st.st_mode) or stat.S_ISDIR(st.st_mode):
266
268
                return True
267
269
            return False
268
 
        except gio.Error, e:
 
270
        except gio.Error as e:
269
271
            if e.code == gio.ERROR_NOT_FOUND:
270
272
                return False
271
273
            else:
279
281
                        for this operation.
280
282
 
281
283
        We're meant to return a file-like object which bzr will
282
 
        then read from. For now we do this via the magic of StringIO
 
284
        then read from. For now we do this via the magic of BytesIO
283
285
        """
284
286
        try:
285
287
            if 'gio' in debug.debug_flags:
288
290
            fin = f.read()
289
291
            buf = fin.read()
290
292
            fin.close()
291
 
            ret = StringIO(buf)
 
293
            ret = BytesIO(buf)
292
294
            return ret
293
 
        except gio.Error, e:
 
295
        except gio.Error as e:
294
296
            #If we get a not mounted here it might mean
295
297
            #that a bad path has been entered (or that mount failed)
296
298
            if (e.code == gio.ERROR_NOT_MOUNTED):
328
330
                if mode is not None:
329
331
                    self._setmode(relpath, mode)
330
332
                return length
331
 
            except gio.Error, e:
 
333
            except gio.Error as e:
332
334
                self._translate_gio_error(e, relpath)
333
335
        finally:
334
336
            if not closed and fout is not None:
344
346
            f = self._get_GIO(relpath)
345
347
            f.make_directory()
346
348
            self._setmode(relpath, mode)
347
 
        except gio.Error, e:
 
349
        except gio.Error as e:
348
350
            self._translate_gio_error(e, relpath)
349
351
 
350
352
    def open_write_stream(self, relpath, mode=None):
378
380
                f.delete()
379
381
            else:
380
382
                raise errors.NotADirectory(relpath)
381
 
        except gio.Error, e:
 
383
        except gio.Error as e:
382
384
            self._translate_gio_error(e, relpath)
383
 
        except errors.NotADirectory, e:
 
385
        except errors.NotADirectory as e:
384
386
            #just pass it forward
385
387
            raise e
386
 
        except Exception, e:
 
388
        except Exception as e:
387
389
            mutter('failed to rmdir %s: %s' % (relpath, e))
388
390
            raise errors.PathError(relpath)
389
391
 
412
414
            #gio.ERROR_NOT_FOUND for the already existing file.
413
415
            #It is valid to open a non-existing file for append.
414
416
            #This is caused by the broken gio append_to...
415
 
            except gio.Error, e:
 
417
            except gio.Error as e:
416
418
                if e.code != gio.ERROR_NOT_FOUND:
417
419
                    self._translate_gio_error(e, relpath)
418
420
            length = self._pump(file, fout)
424
426
                      (info.st_size, result, length, result + length))
425
427
            fo.move(fi, flags=gio.FILE_COPY_OVERWRITE)
426
428
            return result
427
 
        except gio.Error, e:
 
429
        except gio.Error as e:
428
430
            self._translate_gio_error(e, relpath)
429
431
 
430
432
    def _setmode(self, relpath, mode):
438
440
            try:
439
441
                f = self._get_GIO(relpath)
440
442
                f.set_attribute_uint32(gio.FILE_ATTRIBUTE_UNIX_MODE, mode)
441
 
            except gio.Error, e:
 
443
            except gio.Error as e:
442
444
                if e.code == gio.ERROR_NOT_SUPPORTED:
443
445
                    # Command probably not available on this server
444
446
                    mutter("GIO Could not set permissions to %s on %s. %s",
454
456
            f = self._get_GIO(rel_from)
455
457
            t = self._get_GIO(rel_to)
456
458
            f.move(t)
457
 
        except gio.Error, e:
 
459
        except gio.Error as e:
458
460
            self._translate_gio_error(e, rel_from)
459
461
 
460
462
    def move(self, rel_from, rel_to):
465
467
            f = self._get_GIO(rel_from)
466
468
            t = self._get_GIO(rel_to)
467
469
            f.move(t, flags=gio.FILE_COPY_OVERWRITE)
468
 
        except gio.Error, e:
 
470
        except gio.Error as e:
469
471
            self._translate_gio_error(e, relfrom)
470
472
 
471
473
    def delete(self, relpath):
475
477
                mutter("GIO delete: %s", relpath)
476
478
            f = self._get_GIO(relpath)
477
479
            f.delete()
478
 
        except gio.Error, e:
 
480
        except gio.Error as e:
479
481
            self._translate_gio_error(e, relpath)
480
482
 
481
483
    def external_url(self):
482
 
        """See bzrlib.transport.Transport.external_url."""
 
484
        """See breezy.transport.Transport.external_url."""
483
485
        if 'gio' in debug.debug_flags:
484
486
            mutter("GIO external_url", self.base)
485
487
        # GIO external url
502
504
            for child in children:
503
505
                entries.append(urlutils.escape(child.get_name()))
504
506
            return entries
505
 
        except gio.Error, e:
 
507
        except gio.Error as e:
506
508
            self._translate_gio_error(e, relpath)
507
509
 
508
510
    def iter_files_recursive(self):
528
530
                mutter("GIO stat: %s", relpath)
529
531
            f = self._get_GIO(relpath)
530
532
            return GioStatResult(f)
531
 
        except gio.Error, e:
 
533
        except gio.Error as e:
532
534
            self._translate_gio_error(e, relpath, extra='error w/ stat')
533
535
 
534
536
    def lock_read(self, relpath):
589
591
 
590
592
def get_test_permutations():
591
593
    """Return the permutations to be used in testing."""
592
 
    from bzrlib.tests import test_server
 
594
    from breezy.tests import test_server
593
595
    return [(GioTransport, GioLocalURLServer)]