phosphor-mapper

#!/usr/bin/env python

# Contributors Listed Below - COPYRIGHT 2016
# [+] International Business Machines Corp.
#
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied. See the License for the specific language governing
# permissions and limitations under the License.

import dbus
import dbus.service
import dbus.exceptions
import dbus.mainloop.glib
import gobject
from obmc.dbuslib.introspection import IntrospectionParser
import obmc.utils.pathtree
import obmc.utils.misc
import obmc.mapper


class MapperNotFoundException(dbus.exceptions.DBusException):
    _dbus_error_name = obmc.mapper.MAPPER_NOT_FOUND

    def __init__(self, path):
        super(MapperNotFoundException, self).__init__(
            "path or object not found: %s" % (path))


class ObjectMapper(dbus.service.Object):
    def __init__(self, bus, path,
                 name_match=obmc.utils.misc.org_dot_openbmc_match,
                 intf_match=obmc.utils.misc.org_dot_openbmc_match):
        super(ObjectMapper, self).__init__(bus.dbus, path)
        self.cache = obmc.utils.pathtree.PathTree()
        self.bus = bus
        self.name_match = name_match
        self.intf_match = intf_match
        self.tag_match = obmc.utils.misc.ListMatch(['children', 'interface'])
        self.service = None

        gobject.idle_add(self.discover)
        self.bus.dbus.add_signal_receiver(
            self.bus_handler,
            dbus_interface=
            dbus.BUS_DAEMON_IFACE,
            signal_name='NameOwnerChanged')
        self.bus.dbus.add_signal_receiver(
            self.interfaces_added_handler,
            dbus_interface=
            dbus.BUS_DAEMON_IFACE + '.ObjectManager',
            signal_name='InterfacesAdded',
            sender_keyword='sender')
        self.bus.dbus.add_signal_receiver(
            self.interfaces_removed_handler,
            dbus_interface=dbus.BUS_DAEMON_IFACE + '.ObjectManager',
            signal_name='InterfacesRemoved',
            sender_keyword='sender')

    def bus_match(self, name):
        if name == obmc.mapper.MAPPER_NAME:
            return False
        return self.name_match(name)

    def discovery_pending(self):
        return not bool(self.service)

    def interfaces_added_handler(self, path, iprops, **kw):
        name = self.bus.get_owned_name(self.bus_match, kw['sender'])
        if self.discovery_pending() or \
                not self.bus_match(name):
            return

        matches = [x for x in iprops.iterkeys() if self.intf_match(x)]
        self.add_interfaces(path, kw['sender'], matches)

    def interfaces_removed_handler(self, path, interfaces, **kw):
        name = self.bus.get_owned_name(self.bus_match, kw['sender'])
        if self.discovery_pending() or \
                not self.bus_match(name):
            return
        item = self.cache[path]
        sender = kw['sender']
        for x in interfaces:
            if self.intf_match(x):
                try:
                    item[sender].remove(x)
                except ValueError:
                    pass

        # remove the owner if there aren't any interfaces left
        if not item[sender]:
            del item[sender]

        # update if interfaces remain
        if item:
            self.cache[path] = item
        # mark for removal if no interfaces remain
        elif self.cache.get_children(path):
            self.cache.demote(path)
        # delete the entire path if everything is gone
        else:
            del self.cache[path]

    def process_new_owner(self, name):
        # unique name
        return self.discover([IntrospectionParser(name,
                             self.bus.dbus,
                             self.tag_match,
                             self.intf_match)])

    def process_old_owner(self, name):
        for x, y in self.cache.dataitems():
            if name not in y:
                continue
            del y[name]
            if y:
                self.cache[x] = y
            elif self.cache.get_children(x):
                self.cache.demote(x)
            else:
                del self.cache[x]

    def bus_handler(self, service, old, new):
        if self.discovery_pending() or \
                not self.bus_match(service):
            return

        if new:
            self.process_new_owner(new)
        if old:
            self.process_old_owner(old)

    def add_interfaces(self, path, owner, interfaces):
        d = self.cache.setdefault(path, {})
        d = d.setdefault(owner, [])
        self.cache[path][owner] = list(set(d + interfaces))

    def add_items(self, owner, bus_items):
        for x, y in bus_items.iteritems():
            self.add_interfaces(x, owner, y['interfaces'])

    def discover(self, owners=None):
        if not owners:
            owners = [IntrospectionParser(x, self.bus.dbus,
                                          self.tag_match,
                                          self.intf_match)
                      for x in self.bus.get_owner_names(self.bus_match)]
        for o in owners:
            self.add_items(o.name, o.introspect())

        if self.discovery_pending():
            print "ObjectMapper discovery complete..."
            self.service = dbus.service.BusName(
                obmc.mapper.MAPPER_NAME, self.bus.dbus)

    @dbus.service.method(obmc.mapper.MAPPER_IFACE, 's', 'a{sas}')
    def GetObject(self, path):
        o = self.cache.get(path)
        if not o:
            raise MapperNotFoundException(path)
        return o

    @dbus.service.method(obmc.mapper.MAPPER_IFACE, 'si', 'as')
    def GetSubTreePaths(self, path, depth):
        try:
            return self.cache.iterkeys(path, depth)
        except KeyError:
            raise MapperNotFoundException(path)

    @dbus.service.method(obmc.mapper.MAPPER_IFACE, 'si', 'a{sa{sas}}')
    def GetSubTree(self, path, depth):
        try:
            return {x: y for x, y in self.cache.dataitems(path, depth)}
        except KeyError:
            raise MapperNotFoundException(path)


class BusWrapper:
    def __init__(self, bus):
        self.dbus = bus

    def get_owned_name(self, match, bus):
        for x in self.get_service_names(match):
            if self.dbus.get_name_owner(x) == bus:
                return x

    def get_service_names(self, match):
        # these are well known names
        return [x for x in self.dbus.list_names()
                if match(x)]

    def get_owner_names(self, match):
        # these are unique connection names
        return list(set(
            [self.dbus.get_name_owner(x)
                for x in self.get_service_names(match)]))

if __name__ == '__main__':
    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
    bus = dbus.SystemBus()
    o = ObjectMapper(BusWrapper(bus), obmc.mapper.MAPPER_PATH)
    loop = gobject.MainLoop()

    loop.run()