Viewing file: mirabeau_tube_consumer.py (5.81 KB) -rw-r--r-- Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
# Licensed under the MIT license # http://opensource.org/licenses/mit-license.php
# Copyright 2009 Philippe Normand <phil@base-art.net>
from dbus import PROPERTIES_IFACE
from telepathy.interfaces import CHANNEL_TYPE_DBUS_TUBE, CONN_INTERFACE, \ CHANNEL_INTERFACE, CHANNEL_INTERFACE_TUBE
from coherence.extern.telepathy import client, tube from coherence.dbus_constants import BUS_NAME, OBJECT_PATH, DEVICE_IFACE, SERVICE_IFACE from coherence import dbus_service
class MirabeauTubeConsumerMixin(tube.TubeConsumerMixin):
def __init__(self, found_peer_callback=None, disapeared_peer_callback=None, got_devices_callback=None): tube.TubeConsumerMixin.__init__(self, found_peer_callback=found_peer_callback, disapeared_peer_callback=disapeared_peer_callback) self.got_devices_callback = got_devices_callback self.info("MirabeauTubeConsumer created") self._coherence_tubes = {}
def pre_accept_tube(self, tube): params = tube[PROPERTIES_IFACE].Get(CHANNEL_INTERFACE_TUBE, 'Parameters') initiator = params.get("initiator") can_accept = initiator and initiator in self.roster return can_accept
def post_tube_accept(self, tube, tube_conn, initiator_handle): service = tube.props[CHANNEL_TYPE_DBUS_TUBE + ".ServiceName"]
if service == BUS_NAME: tube.remote_object = dbus_service.DBusPontoon(None, tube_conn) elif service == DEVICE_IFACE: tube.remote_object = dbus_service.DBusDevice(None, tube_conn) elif service == SERVICE_IFACE: tube.remote_object = dbus_service.DBusService(None, None, tube_conn) else: self.info("tube %r is not coming from Coherence", service) return tube_conn
if initiator_handle not in self._coherence_tubes: self._coherence_tubes[initiator_handle] = {} self._coherence_tubes[initiator_handle][service] = tube
if len(self._coherence_tubes[initiator_handle]) == 3: self.announce(initiator_handle)
def tube_closed(self, tube): self.disapeared_peer_callback(tube) super(MirabeauTubeConsumerMixin, self).tube_closed(tube)
def announce(self, initiator_handle): service_name = BUS_NAME pontoon_tube = self._coherence_tubes[initiator_handle][service_name]
def cb(participants, removed): if participants and initiator_handle in participants: initiator_bus_name = participants[initiator_handle] self.info("bus name %r for service %r", initiator_bus_name, service_name) if initiator_bus_name is not None: self.found_devices(initiator_handle, initiator_bus_name) for handle in removed: try: tube_channels = self._coherence_tubes[handle] except KeyError: self.debug("tube with handle %d not registered", handle) else: for service_iface_name, channel in tube_channels.iteritems(): channel[CHANNEL_INTERFACE].Close() del self._coherence_tubes[handle]
pontoon_tube.remote_object.tube.watch_participants(cb)
def found_devices(self, initiator_handle, initiator_bus_name): devices = [] tubes = self._coherence_tubes[initiator_handle] pontoon_tube = tubes[BUS_NAME].remote_object.tube device_tube = tubes[DEVICE_IFACE].remote_object.tube service_tube = tubes[SERVICE_IFACE].remote_object.tube self.info("using pontoon tube at %r", tubes[BUS_NAME].object_path)
def got_devices(pontoon_devices): self.info("%r devices registered in remote pontoon", len(pontoon_devices)) for device_dict in pontoon_devices: device_path = device_dict["path"] self.info("getting object at %r from %r", device_path, initiator_bus_name) proxy = device_tube.get_object(initiator_bus_name, device_path) infos = proxy.get_info(dbus_interface=DEVICE_IFACE) service_proxies = [] for service_path in device_dict["services"]: service_proxy = service_tube.get_object(initiator_bus_name, service_path) service_proxies.append(service_proxy) proxy.services = service_proxies devices.append(proxy) self.got_devices_callback(devices)
def got_error(exception): print ">>>", exception
pontoon = pontoon_tube.get_object(initiator_bus_name, OBJECT_PATH) pontoon.get_devices_async(reply_handler=got_devices, error_handler=got_error)
class MirabeauTubeConsumer(MirabeauTubeConsumerMixin, client.Client): logCategory = "mirabeau_tube_consumer"
def __init__(self, manager, protocol, account, muc_id, found_peer_callback=None, disapeared_peer_callback=None, got_devices_callback=None): MirabeauTubeConsumerMixin.__init__(self, found_peer_callback=found_peer_callback, disapeared_peer_callback=disapeared_peer_callback, got_devices_callback=got_devices_callback) client.Client.__init__(self, manager, protocol, account, muc_id)
def got_tube(self, tube): client.Client.got_tube(self, tube) self.accept_tube(tube)
def tube_opened(self, tube): tube_conn = super(MirabeauTubePublisherConsumer, self).tube_opened(tube) self.post_tube_accept(tube, tube_conn) return tube_conn
|