← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/ubuntuone-client/oneiric

« back to all changes in this revision

Viewing changes to ubuntuone/syncdaemon/dbus_interface.py

  • Committer: Bazaar Package Importer
  • Author(s): Rodney Dawes
  • Date: 2010-06-08 17:31:18 UTC
  • mto: This revision was merged to the branch mainline in revision 31.
  • Revision ID: james.westby@ubuntu.com-20100608173118-o8s897ll11rtne99
Tags: upstream-1.3.0
Import upstream version 1.3.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
ubuntuone/syncdaemon/dbus_interface.py
32
32
from ubuntuone.syncdaemon.event_queue import EVENTS
33
33
from ubuntuone.syncdaemon.interfaces import IMarker
34
34
from ubuntuone.syncdaemon import config
35
 
from ubuntuone.syncdaemon.volume_manager import Share, UDF
 
35
from ubuntuone.syncdaemon.volume_manager import Share, UDF, VolumeDoesNotExist
36
36
 
37
37
 
38
38
# Disable the "Invalid Name" check here, as we have lots of DBus style names
276
276
 
277
277
    @dbus.service.signal(DBUS_IFACE_STATUS_NAME,
278
278
                         signature='sa{ss}')
 
279
    def DownloadFileProgress(self, path, info):
 
280
        """Fire a D-BUS signal, notifying about a download progress."""
 
281
        pass
 
282
 
 
283
    @dbus.service.signal(DBUS_IFACE_STATUS_NAME,
 
284
                         signature='sa{ss}')
279
285
    def DownloadFinished(self, path, info):
280
286
        """ Fire a D-BUS signal, notifying a download has finished.  """
281
287
        pass
287
293
 
288
294
    @dbus.service.signal(DBUS_IFACE_STATUS_NAME,
289
295
                         signature='sa{ss}')
 
296
    def UploadFileProgress(self, path, info):
 
297
        """Fire a D-BUS signal, notifying about an upload progress."""
 
298
        pass
 
299
 
 
300
    @dbus.service.signal(DBUS_IFACE_STATUS_NAME,
 
301
                         signature='sa{ss}')
290
302
    def UploadFinished(self, path, info):
291
303
        """ Fire a D-BUS signal, notifying an upload has finished.  """
292
304
        pass
356
368
        """ Emits the signal """
357
369
        self.DownloadStarted(download)
358
370
 
 
371
    def emit_download_file_progress(self, download, **info):
 
372
        """Emits the signal."""
 
373
        for k, v in info.copy().items():
 
374
            info[str(k)] = str(v)
 
375
        self.DownloadFileProgress(download, info)
 
376
 
359
377
    def emit_download_finished(self, download, **info):
360
 
        """ Emits the signal """
 
378
        """Emits the signal."""
361
379
        for k, v in info.copy().items():
362
380
            info[str(k)] = str(v)
363
381
        self.DownloadFinished(download, info)
366
384
        """ Emits the signal """
367
385
        self.UploadStarted(upload)
368
386
 
 
387
    def emit_upload_file_progress(self, upload, **info):
 
388
        """Emits the signal."""
 
389
        for k, v in info.copy().items():
 
390
            info[str(k)] = str(v)
 
391
        self.UploadFileProgress(upload, info)
 
392
 
369
393
    def emit_upload_finished(self, upload, **info):
370
394
        """ Emits the signal """
371
395
        for k, v in info.copy().items():
457
481
                        node_id=str(node_id))
458
482
            self.dbus_iface.status.emit_signal_error('DownloadStarted', args)
459
483
 
 
484
    def handle_AQ_DOWNLOAD_FILE_PROGRESS(self, share_id, node_id,
 
485
                                         n_bytes_read, deflated_size):
 
486
        """Handle AQ_DOWNLOAD_FILE_PROGRESS."""
 
487
        self.handle_default('AQ_DOWNLOAD_FILE_PROGRESS', share_id, node_id,
 
488
                            n_bytes_read, deflated_size)
 
489
        try:
 
490
            mdobj = self.dbus_iface.fs_manager.get_by_node_id(share_id, node_id)
 
491
        except KeyError, e:
 
492
            args = dict(message='The md is gone before sending '
 
493
                        'DownloadFileProgress signal',
 
494
                        error=str(e),
 
495
                        share_id=str(share_id),
 
496
                        node_id=str(node_id))
 
497
            self.dbus_iface.status.emit_signal_error('DownloadFileProgress',
 
498
                                                     args)
 
499
        else:
 
500
            path = self.dbus_iface.fs_manager.get_abspath(share_id, mdobj.path)
 
501
            self.dbus_iface.status.emit_download_file_progress(path,
 
502
                                                 n_bytes_read=n_bytes_read,
 
503
                                                 deflated_size=deflated_size
 
504
                                                               )
 
505
 
460
506
    def handle_AQ_DOWNLOAD_FINISHED(self, share_id, node_id, server_hash):
461
507
        """ handle AQ_DOWNLOAD_FINISHED """
462
508
        self.handle_default('AQ_DOWNLOAD_FINISHED', share_id,
519
565
                        node_id=str(node_id))
520
566
            self.dbus_iface.status.emit_signal_error('UploadStarted', args)
521
567
 
 
568
    def handle_AQ_UPLOAD_FILE_PROGRESS(self, share_id, node_id,
 
569
                                         n_bytes_written, deflated_size):
 
570
        """Handle AQ_UPLOAD_FILE_PROGRESS."""
 
571
        self.handle_default('AQ_UPLOAD_FILE_PROGRESS', share_id, node_id,
 
572
                            n_bytes_written, deflated_size)
 
573
        try:
 
574
            mdobj = self.dbus_iface.fs_manager.get_by_node_id(share_id, node_id)
 
575
        except KeyError, e:
 
576
            args = dict(message='The md is gone before sending '
 
577
                        'UploadFileProgress signal',
 
578
                        error=str(e),
 
579
                        share_id=str(share_id),
 
580
                        node_id=str(node_id))
 
581
            self.dbus_iface.status.emit_signal_error('UploadFileProgress',
 
582
                                                     args)
 
583
        else:
 
584
            path = self.dbus_iface.fs_manager.get_abspath(share_id, mdobj.path)
 
585
            self.dbus_iface.status.emit_upload_file_progress(path,
 
586
                                                n_bytes_written=n_bytes_written,
 
587
                                                deflated_size=deflated_size
 
588
                                                             )
 
589
 
522
590
    def handle_AQ_UPLOAD_FINISHED(self, share_id, node_id, hash):
523
591
        """ handle AQ_UPLOAD_FINISHED """
524
592
        self.handle_default('AQ_UPLOAD_FINISHED', share_id, node_id, hash)
669
737
        self.handle_default('VM_VOLUME_DELETE_ERROR', volume_id, error)
670
738
        try:
671
739
            volume = self.dbus_iface.volume_manager.get_volume(volume_id)
672
 
        except KeyError:
 
740
        except VolumeDoesNotExist:
673
741
            logger.error("Unable to handle VM_VOLUME_DELETE_ERROR for "
674
 
                         "volume_id=%r", volume_id)
 
742
                         "volume_id=%r, no such volume.", volume_id)
675
743
        else:
676
744
            if isinstance(volume, Share):
677
745
                self.dbus_iface.shares.emit_share_delete_error(volume, error)
886
954
        try:
887
955
            self.vm.delete_volume(str(share_id))
888
956
            reply_handler()
889
 
        except KeyError:
890
 
            error_handler(ValueError("The volume with id: %s don't exists" % \
891
 
                                     str(share_id)))
 
957
        except VolumeDoesNotExist, e:
 
958
            self.ShareDeleteError({'volume_id':share_id}, str(e))
 
959
        except Exception, e:
 
960
            error_handler(e)
 
961
            logger.exception('Error while deleting share: %r', share_id)
 
962
            self.ShareDeleteError({'volume_id':share_id}, str(e))
892
963
 
893
964
 
894
965
    @dbus.service.signal(DBUS_IFACE_SHARES_NAME,
1214
1285
        """Enable UDF autosubscribe."""
1215
1286
        logger.debug('called set_files_sync_enabled %d', enabled)
1216
1287
        user_config = config.get_user_config()
1217
 
        user_config.set_files_sync_enabled(enabled)
 
1288
        user_config.set_files_sync_enabled(bool(int(enabled)))
1218
1289
        user_config.save()
1219
1290
 
1220
1291
    @dbus.service.method(DBUS_IFACE_CONFIG_NAME,
1246
1317
                udf_dict[unicode(k)] = self.bool_str(v)
1247
1318
            elif k == 'path':
1248
1319
                udf_dict[unicode(k)] = v.decode('utf-8')
 
1320
            elif k == 'suggested_path' and isinstance(v, str):
 
1321
                udf_dict[unicode(k)] = v.decode('utf-8')
1249
1322
            else:
1250
1323
                udf_dict[unicode(k)] = unicode(v)
1251
1324
        return udf_dict
1267
1340
        logger.debug('Folders.delete: %r', folder_id)
1268
1341
        try:
1269
1342
            self.vm.delete_volume(folder_id)
 
1343
        except VolumeDoesNotExist, e:
 
1344
            self.FolderDeleteError({'volume_id':folder_id}, str(e))
1270
1345
        except Exception, e:
1271
1346
            logger.exception('Error while deleting volume: %r', folder_id)
1272
 
            self.emit_folder_delete_error({'id':folder_id}, str(e))
 
1347
            self.FolderDeleteError({'volume_id':folder_id}, str(e))
1273
1348
 
1274
1349
    @dbus.service.method(DBUS_IFACE_FOLDERS_NAME, out_signature='aa{ss}')
1275
1350
    def get_folders(self):