Changeset 3607

Show
Ignore:
Timestamp:
10/10/08 20:58:56 (3 months ago)
Author:
dmeyer
Message:

move hwmon to the main beacon server process

Location:
trunk/beacon
Files:
1 removed
6 modified

Legend:

Unmodified
Added
Removed

  • trunk/beacon/bin/beacon-daemon

    r3195 r3607  
    188188    kaa.beacon.server.config.add_variable('plugins', plugin_config) 
    189189 
    190 # fork thumbnailer / hwmon 
     190# fork thumbnailer 
    191191pid = os.fork() 
    192192if not pid: 
    193     # hwmon part (import this first because of hal/gtk) 
    194     hwmon = kaa.beacon.server.HardwareMonitorServer(os.path.join(database, "config")) 
    195  
    196     # thumbnailer part 
    197193    thumb = kaa.beacon.server.Thumbnailer() 
    198194 
    … …  
    206202    # loop 
    207203    kaa.main.run() 
    208     log.info('stop thumbnail/hwmon') 
     204    log.info('stop thumbnail') 
    209205    sys.exit(0) 
    210206 
    … …  
    229225    kaa.beacon.thumbnail.connect() 
    230226    log.info('connection to thumbnailer established') 
    231  
    232     # connect hwmon 
    233     log.info('connect to hwmon ...') 
    234     kaa.beacon.server.HardwareMonitorClient().connect() 
    235     log.info('connection to hwmon established') 
    236227 
    237228    server = kaa.beacon.server.BeaconServer(database) 

  • trunk/beacon/src/server/__init__.py

    r2854 r3607  
    77# ----------------------------------------------------------------------------- 
    88# kaa.beacon.server - A virtual filesystem with metadata 
    9 # Copyright (C) 2006 Dirk Meyer 
     9# Copyright (C) 2006-2008 Dirk Meyer 
    1010# 
    1111# First Edition: Dirk Meyer <dischi@freevo.org> 
    … …  
    3737 
    3838 
    39 def HardwareMonitorServer(config): 
    40     import hwmon.server 
    41     return hwmon.server.Server(config) 
    42  
    43  
    44 def HardwareMonitorClient(): 
    45     import hwmon 
    46     return hwmon 
    47  
    48  
    4939def Thumbnailer(): 
    5040    import thumbnailer 

  • trunk/beacon/src/server/controller.py

    r3071 r3607  
    4848        self._db = db 
    4949        self._changed = [] 
    50         hwmon.connect() 
    5150        db.medialist.connect(self) 
    52         hwmon.set_database(handler, db, rootfs) 
     51        hwmon.create(handler, db, rootfs) 
    5352 
    5453    # Item callbacks 

  • trunk/beacon/src/server/hwmon/__init__.py

    r2974 r3607  
    3939_client = None 
    4040 
    41 def connect(): 
     41def create(handler, db, rootfs): 
    4242    """ 
    4343    Connect to hardware monitor process. This function will block 
    … …  
    4545    """ 
    4646    global _client 
    47     if _client: 
    48         return _client 
    49     start = time.time() 
    50     while True: 
    51         try: 
    52             _client = _Client() 
    53             return _client 
    54         except socket.error, e: 
    55             if start + 3 < time.time(): 
    56                 # start time is up, something is wrong here 
    57                 raise RuntimeError('unable to connect to hardware monitor') 
    58             time.sleep(0.01) 
    59  
    60  
    61 def set_database(handler, db, rootfs=None): 
    62     _client.set_database(handler, db, rootfs) 
    63  
     47    if not _client: 
     48        _client = _Client(handler, db, rootfs) 
     49    return _client 
    6450 
    6551def get_client(): 

  • trunk/beacon/src/server/hwmon/client.py

    r3470 r3607  
    1010# ----------------------------------------------------------------------------- 
    1111# kaa.beacon.server - A virtual filesystem with metadata 
    12 # Copyright (C) 2006-2007 Dirk Meyer 
     12# Copyright (C) 2006-2008 Dirk Meyer 
    1313# 
    1414# First Edition: Dirk Meyer <dischi@freevo.org> 
    … …  
    4040# kaa imports 
    4141import kaa 
    42 import kaa.rpc 
     42import kaa.metadata 
    4343 
    4444# kaa.beacon imports 
    … …  
    4848log = logging.getLogger('beacon.hwmon') 
    4949 
     50# import the different hardware monitor modules 
     51try: 
     52    import hal 
     53except ImportError: 
     54    log.error('hal support disabled') 
     55    hal = None 
     56    try: 
     57        import cdrom 
     58    except ImportError: 
     59        log.error('cdrom support disabled') 
     60        cdrom = None 
    5061 
    5162class Client(object): 
    5263 
    53     def __init__(self): 
    54         server = kaa.rpc.Client('hwmon') 
    55         server.connect(self) 
    56         self.rpc = server.rpc 
    57  
    58  
    59     def set_database(self, handler, db, rootfs): 
     64    def __init__(self, handler, db, rootfs): 
     65        log.info('start hardware monitor') 
    6066        self._db = db 
    61         # handler == beacon.Server 
     67        # handler == beacon.server.Controller 
    6268        self.handler = handler 
    63         self.rpc('connect') 
    64         self._device_add(rootfs) 
    65  
    66  
    67     def mount(self, dev): 
     69        self.devices = {} 
     70        self._update_device(rootfs) 
     71        if hal: 
     72            hal.signals['failed'].connect(self.__backend_hal_failure) 
     73            self.__backend_start(hal) 
     74        elif cdrom: 
     75            self.__backend_start(cdrom) 
     76 
     77    def __backend_start(self, service): 
     78        service.signals['add'].connect(self.__backend_device_new) 
     79        service.signals['remove'].connect(self.__backend_device_remove) 
     80        service.signals['changed'].connect(self.__backend_device_changed) 
     81        service.start() 
     82 
     83    def __backend_hal_failure(self, reason): 
     84        log.error(reason) 
     85        if cdrom: 
     86            self.__backend_start(cdrom) 
     87 
     88    def __backend_device_new(self, dev): 
     89        if dev.prop.get('volume.uuid'): 
     90            dev.prop['beacon.id'] = str(dev.prop.get('volume.uuid')) 
     91        else: 
     92            error = 'impossible to find unique string for beacon.id' 
     93            if dev.prop.get('block.device'): 
     94                error = 'unable to mount %s' % dev.prop.get('block.device') 
     95            log.error(error) 
     96            return True 
     97        self.devices[dev.get('beacon.id')] = dev 
     98        self._update_device(dev.prop) 
     99 
     100    def __backend_device_remove(self, dev): 
     101        try: 
     102            del self.devices[dev.get('beacon.id')] 
     103        except KeyError: 
     104            log.error('unable to find %s', dev.get('beacon.id')) 
     105        beacon_id = dev.prop.get('beacon.id') 
     106        log.info('remove device %s' % beacon_id) 
     107        self.handler.media_removed(self._db.medialist.get_by_media_id(beacon_id)) 
     108        self._db.medialist.remove(beacon_id) 
     109 
     110    def __backend_device_changed(self, dev, prop): 
     111        prop['beacon.id'] = dev.prop.get('beacon.id') 
     112        beacon_id = dev.prop.get('beacon.id') 
     113        log.info('change device %s', beacon_id) 
     114        self._update_device(prop) 
     115 
     116    def get_backend_device(self, dev): 
    68117        if hasattr(dev, 'prop'): 
    69118            # media object 
    70             id = dev.prop.get('beacon.id') 
    71         else: 
    72             # raw device dict 
    73             id = dev.get('beacon.id') 
    74         return self.rpc('device.mount', id) 
    75  
     119            return self.devices.get(dev.prop.get('beacon.id')) 
     120        # raw device dict 
     121        return self.devices.get(dev.get('beacon.id')) 
     122 
     123    def mount(self, dev): 
     124        backend = self.get_backend_device(dev) 
     125        if backend: 
     126            return backend.mount() 
    76127 
    77128    def eject(self, dev): 
    78         return self.rpc('device.eject', dev.prop.get('beacon.id')) 
    79  
    80  
    81     # rpc callbacks 
    82  
    83     @kaa.rpc.expose('device.add') 
     129        backend = self.get_backend_device(dev) 
     130        if backend: 
     131            backend.eject() 
     132 
    84133    @kaa.coroutine() 
    85     def _device_add(self, dev): 
    86         # FIXME: check if the device is still valid 
    87  
     134    def _update_device(self, dev): 
    88135        id = dev.get('beacon.id') 
    89136        if self._db.medialist.get_by_media_id(id): 
    … …  
    93140            self.handler.media_changed(media) 
    94141            return 
    95  
    96142        media = self._db.query_media(id) 
    97143        if not media: 
    98144            if not dev.get('volume.is_disc') == True: 
    99145                # fake scanning for other media than rom drives 
    100                 yield self._device_scanned(None, dev) 
    101             # scan the disc in background 
    102             self.rpc('device.scan', id).connect(self._device_scanned, dev) 
    103             return 
    104  
     146                metadata = None 
     147            else: 
     148                backend = self.get_backend_device(dev) 
     149                parse = kaa.ThreadCallback(kaa.metadata.parse) 
     150                metadata = yield parse(dev.get('block.device')) 
     151            yield self._add_device_to_db(metadata, dev) 
     152        media = self._db.query_media(id) 
    105153        if media['content'] == 'file' and not dev.get('volume.mount_point'): 
    106154            # FIXME: mount only on request 
    … …  
    108156            self.mount(dev) 
    109157            return 
    110  
    111158        m = yield self._db.medialist.add(id, dev) 
    112  
    113159        # create overlay directory structure 
    114160        if not os.path.isdir(m.overlay): 
    … …  
    118164            if not os.path.isdir(dirname): 
    119165                os.makedirs(dirname, 0700) 
    120  
    121166        # FIXME: Yes, a disc is read only, but other media may also 
    122167        # be read only and the flag is not set. 
    … …  
    126171        return 
    127172 
    128  
    129     @kaa.rpc.expose('device.remove') 
    130     def _device_remove(self, id): 
    131         log.info('remove device %s' % id) 
    132         self.handler.media_removed(self._db.medialist.get_by_media_id(id)) 
    133         self._db.medialist.remove(id) 
    134  
    135  
    136     @kaa.rpc.expose('device.changed') 
    137     def _device_change(self, id, dev): 
    138         log.info('change device %s', id) 
    139         self._device_add(dev) 
    140  
    141  
    142173    @kaa.coroutine(policy=kaa.POLICY_SYNCHRONIZED) 
    143     def _device_scanned(self, metadata, dev): 
    144  
    145         # FIXME: ACTIVE WAITING: 
     174    def _add_device_to_db(self, metadata, dev): 
    146175        while self._db.read_lock.is_locked(): 
    147176            yield self._db.read_lock.yield_unlock() 
    148  
    149177        # FIXME: check if the device is still valid 
    150178        # FIXME: handle failed dvd detection 
    … …  
    159187            vid = self._db.add_object( 
    160188                "video", name="", parent=('media', mid), 
    161                 title=unicode(get_title(metadata['label'])), 
    162                                      media = mid)['id'] 
     189                title=unicode(get_title(metadata['label'])), media = mid)['id'] 
    163190            for track in metadata.tracks: 
    164191                self._db.add_object( 
    … …  
    191218            dir = self._db.add_object( 
    192219                "dir", name="", parent=('media', mid), media=mid, mtime=mtime) 
    193         yield self._device_add(dev) 

  • trunk/beacon/test/cdrom.py

    r2974 r3607  
    22import kaa.beacon 
    33 
     4def new_device(media): 
     5    print 'new', media 
     6    kaa.OneShotTimer(media.eject).start(5) 
     7     
     8def lost_device(media): 
     9    print 'lost', media 
     10 
    411kaa.beacon.connect() 
    5 kaa.beacon.add_mountpoint('cdrom', '/dev/dvd', '/mnt/dvd') 
    6 kaa.beacon.add_mountpoint('cdrom', '/dev/cdrom', '/mnt/cdrom') 
    7  
     12kaa.beacon.signals['media.add'].connect(new_device) 
     13kaa.beacon.signals['media.remove'].connect(lost_device) 
    814kaa.main.run()