~tdelaet/cimple/old-codebase

"""

Tracker discovery

"""

import dbus

import dbus.mainloop.glib

import avahi

import notify.all

import twisted.internet.reactor

import cimple.core.config

 

class ServiceResolver:

        """

        Service Resolver

        """

        

        def __init__(self, *args):

                self.interface = args[0]

                self.protocol = args[1]

                self.name = args[2]

                self.type = args[3]

                self.domain = args[4]

                self.host = args[5]

                self.aprotocol = args[6]

                self.address = args[7]

                self.port = args[8]

                self.txt = args[9]

                self.flags = args[10]

                

        def __eq__(self, other):

                return self.name == other.name

        

        def __ne__(self, other):

                return not self == other

        

        def __hash__(self):

                return hash(self.name)

 

class Discovery:

        """

        Generic Service Discovery object

        """

        

        def __init__(self, service_type):

                dbus.set_default_main_loop(dbus.mainloop.glib.DBusGMainLoop())

                self.service_added = notify.all.Signal()

                self.service_removed = notify.all.Signal()

                bus = dbus.SystemBus()

                self.server = dbus.Interface(bus.get_object(avahi.DBUS_NAME, '/'), 'org.freedesktop.Avahi.Server')

                service_browser = self.server.ServiceBrowserNew(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, service_type, 'local', dbus.UInt32(0))

                browser_object = bus.get_object(avahi.DBUS_NAME, service_browser)               

                self.browser = dbus.Interface(browser_object, avahi.DBUS_INTERFACE_SERVICE_BROWSER)

                self.browser.connect_to_signal("ItemNew", self.__item_new_handler)

                self.browser.connect_to_signal("ItemRemove", self.__item_remove_handler)

 

        def __item_new_handler(self, interface, protocol, name, stype, domain, flags):

                #pylint: disable-msg=C0111,C0301,W0613

                #print "Found service '%s' type '%s' domain '%s' " % (name, stype, domain)

                self.server.ResolveService(interface, protocol, name, stype, domain, avahi.PROTO_UNSPEC, dbus.UInt32(0), reply_handler=self.__service_resolved, error_handler=self.__print_error)       

 

        def __item_remove_handler(self, interface, protocol, name, stype, domain, flags):

                #pylint: disable-msg=C0111,C0301,W0613

                #print "Removed service '%s' type '%s' domain '%s' " % (name, stype, domain)

                self.__service_removed(interface, protocol, name, stype, domain, flags)

 

        def __print_error(self, *args):

                #pylint: disable-msg=C0111,W0613,R0201

                print "error handler"

                print args

 

        def __service_resolved(self, *args):

                """

                Callback when we have resolved a new service

                """

                self.service_added(ServiceResolver(*args))

                

        def __service_removed(self, interface, protocol, name, stype, domain, flags):

                """

                Callback when service is removed

                """

                self.service_removed(ServiceResolver(interface, protocol, name, stype, domain, None, None, None, None, None, flags))

 

class Manager:

        

        def __init__(self, discovery):

                self.discovery = discovery

                self.services = {}

                self.discovery.service_added.connect(self.__service_added)

                self.discovery.service_removed.connect(self.__service_removed)

        

        def __service_added(self, service_resolver):

                self.services[str(service_resolver.name)] = service_resolver

        

        def __service_removed(self, service_resolver):

                if self.services.has_key(str(service_resolver.name)):

                        del self.services[str(service_resolver.name)]

                                        

class Advertiser:

        

        def __init__(self, port):

                dbus.set_default_main_loop(dbus.mainloop.glib.DBusGMainLoop())

                self.bus = dbus.SystemBus()

                self.server = None

                self.group = None

                self.rename_count = 0

                self.port = port

                #pylint: disable-msg=E1101

                twisted.internet.reactor.callWhenRunning(self.__advertise_ourselves)

 

        def __advertise_ourselves(self):

                self.server = dbus.Interface(self.bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ), avahi.DBUS_INTERFACE_SERVER )

                self.server.connect_to_signal("StateChanged", self.__server_state_changed)

                self.__server_state_changed(self.server.GetState())

 

        def __server_state_changed(self, state):

                if state == avahi.SERVER_COLLISION:

                        print "WARNING: Server name collision"

                        self.__remove_service()

                elif state == avahi.SERVER_RUNNING:

                        self.__add_service()

        

        def __entry_group_state_changed(self, state, error):

                if state == avahi.ENTRY_GROUP_COLLISION:

                        self.rename_count = self.rename_count + 1

                        if self.rename_count < 4:

                                self.__remove_service()

                                self.__add_service()

                        else:

                                print "Service name collision"

                                print error

                                #pylint: disable-msg=E1101

                                twisted.internet.reactor.stop()

                elif state == avahi.ENTRY_GROUP_FAILURE:

                        print "Error in group state changed"

                        print error

                        #pylint: disable-msg=E1101

                        twisted.internet.reactor.stop()

 

        def __remove_service(self):

                if not self.group == None:

                        self.group.Reset()              

 

        def _service_type(self):

                raise NotImplementedError

        

        def _txt_dictionary(self):

                raise NotImplementedError

 

        def _name(self):

                raise NotImplementedError

 

        def __add_service(self):

                txt_records = self._txt_dictionary()

                txt = avahi.dict_to_txt_array(txt_records)

                if self.group == None:

                        object_path = self.bus.get_object(avahi.DBUS_NAME, self.server.EntryGroupNew())

                        self.group = dbus.Interface(object_path, avahi.DBUS_INTERFACE_ENTRY_GROUP)

                        self.group.connect_to_signal('StateChanged', self.__entry_group_state_changed)

                self.group.AddService(avahi.IF_UNSPEC, avahi.PROTO_INET, dbus.UInt32(0), self._name(), self._service_type(), "", "", dbus.UInt16(self.port), txt)               

                self.group.Commit()

 

class CimpleAdvertiser(Advertiser):

        KEY_SEGMENT_SIZE = 200

        

        SSH_KEY_LOCATION = None

        

        TYPE = None

        

        NAME = None

        

        def __init__(self, port):

                Advertiser.__init__(self, port)

                self.name = cimple.core.config.ssh_key_id(self.SSH_KEY_LOCATION)

        

        def _ssh_key(self):

                result = {}

                (key_type, key) = cimple.core.config.ssh_key(self.SSH_KEY_LOCATION)

                result['ssh-key-type'] = key_type

                remaining_length = len(key)

                seq = 0

                while remaining_length > 0:

                        data = key[0:self.KEY_SEGMENT_SIZE]

                        result['ssh-key-part-' + str(seq)] = data

                        key = key[self.KEY_SEGMENT_SIZE:]

                        remaining_length = remaining_length - self.KEY_SEGMENT_SIZE

                        seq = seq + 1

                return result

        

        def _name(self):

                return self.name