mpm: mpm reorganization

26 files changed, 569 insertions, 204 deletions

diff --git a/mpm/python/CMakeLists.txt b/mpm/python/CMakeLists.txt
index 7daa3bbf5..11adef92a 100644
--- a/mpm/python/CMakeLists.txt
+++ b/mpm/python/CMakeLists.txt
@@ -59,12 +59,8 @@ MESSAGE(STATUS "Boost library directories: ${Boost_LIBRARY_DIRS}")
 MESSAGE(STATUS "Boost libraries: ${Boost_LIBRARIES}")
 
 SET(UHD_HOST_ROOT ${CMAKE_SOURCE_DIR}/../host)
-LIST(APPEND
-  pyusrp_periphs_sources
-  pyusrp_periphs.cpp
-)
 
-ADD_LIBRARY(pyusrp_periphs SHARED ${pyusrp_periphs_sources})
+ADD_LIBRARY(pyusrp_periphs SHARED pyusrp_periphs.cpp)
 TARGET_INCLUDE_DIRECTORIES(pyusrp_periphs PUBLIC
     ${PYTHON_INCLUDE_DIRS}
     ${CMAKE_SOURCE_DIR}/lib/
diff --git a/mpm/python/lib_helper.cpp b/mpm/python/lib_helper.cpp
index 5948628f8..58d4a5336 100644
--- a/mpm/python/lib_helper.cpp
+++ b/mpm/python/lib_helper.cpp
@@ -32,7 +32,6 @@ void export_helper(){
     bp::class_<mpm::udev_helper>("udev_helper", bp::init<>())
         .def("get_eeprom", &mpm::udev_helper::get_eeprom)
         ;
-    bp::def("get_if_addrs", &mpm::network::get_if_addrs);
     bp::to_python_converter<std::vector< std::string >, iterable_to_python_list<std::vector< std::string > >, false>();
 }
 
diff --git a/mpm/python/pyusrp_periphs.cpp b/mpm/python/pyusrp_periphs.cpp
index b111e40ca..9f6378763 100644
--- a/mpm/python/pyusrp_periphs.cpp
+++ b/mpm/python/pyusrp_periphs.cpp
@@ -27,11 +27,10 @@
 
 //#include "types.hpp"
 #include "converters.hpp"
-#include "mpm/net_helper.hpp"
 #include "mpm/xbar_iface.hpp"
-#include "mpm/udev_helper.hpp"
 #include "mpm/ad937x/ad937x_ctrl.hpp"
 #include "mpm/lmk04828//lmk04828_spi_iface.hpp"
+#include "mpm/dboards/magnesium_manager.hpp"
 //#include "lib_periphs.hpp"
 //#include "dboards.hpp"
 #include <boost/noncopyable.hpp>
@@ -43,12 +42,10 @@ BOOST_PYTHON_MODULE(libpyusrp_periphs)
     bp::object package = bp::scope();
     package.attr("__path__") = "libpyusrp_periphs";
     export_converter();
-    export_net_iface();
     //export_types();
-    export_udev_helper();
     //export_spi();
     //export_lmk();
     export_mykonos();
     export_xbar();
-    //export_dboards();
+    export_dboards();
 }
diff --git a/mpm/python/setup.py.in b/mpm/python/setup.py.in
index 2a63d14aa..e09262d44 100755
--- a/mpm/python/setup.py.in
+++ b/mpm/python/setup.py.in
@@ -40,5 +40,9 @@ setup(name='usrp_mpm',
       zip_safe=False,
       packages=['usrp_mpm', 'usrp_mpm.periph_manager', 'usrp_mpm.dboard_manager'],
       install_requires=[
-          'numpy'
-      ])
+          'mprpc',
+          'systemd-python',
+          'pyroute2',
+          'pyudev'
+      ],
+      tests_require=['pytest', 'pylint'])
diff --git a/mpm/python/usrp_hwd.py b/mpm/python/usrp_hwd.py
index a0c66f62b..f0e52e7fb 100755
--- a/mpm/python/usrp_hwd.py
+++ b/mpm/python/usrp_hwd.py
@@ -21,12 +21,13 @@ Main executable for the USRP Hardware Daemon
 from __future__ import print_function
 from logging import getLogger
 from logging import StreamHandler
+from systemd.journal import JournalHandler
 from logging import DEBUG
 from logging import Formatter
-import signal
+from gevent import signal
 import sys
 import usrp_mpm as mpm
-from usrp_mpm.types import shared_state
+from usrp_mpm.types import SharedState
 from usrp_mpm.periph_manager import periph_manager
 
 log = getLogger("usrp_mpm")
@@ -55,17 +56,29 @@ def main():
     """
     # Setup logging
     log.setLevel(DEBUG)
-    ch = StreamHandler()
-    ch.setLevel(DEBUG)
-    formatter = Formatter('[%(asctime)s] [%(levelname)s] [%(name)s] [%(message)s]')
-    ch.setFormatter(formatter)
-    log.addHandler(ch)
+    handler = StreamHandler()
+    journal_handler = JournalHandler(SYSLOG_IDENTIFIER='usrp_hwd')
+    handler.setLevel(DEBUG)
+    formatter = Formatter('[%(asctime)s] [%(levelname)s] [%(module)s] %(message)s')
+    handler.setFormatter(formatter)
+    journal_formatter = Formatter('[%(levelname)s] [%(module)s] %(message)s')
+    journal_handler.setFormatter(journal_formatter)
+    log.addHandler(handler)
+    log.addHandler(journal_handler)
 
-
-    shared = shared_state()
+    shared = SharedState()
+    # Create the periph_manager for this device
+    # This call will be forwarded to the device specific implementation
+    # e.g. in periph_manager/test.py
+    # Which implementation is called will be determined during configuration
+    # with cmake (-DMPM_DEVICE)
     mgr = periph_manager()
+    discovery_info = {
+        "type": mgr._get_device_info()["type"],
+        "serial": mgr._get_device_info()["serial"]
+    }
     _PROCESSES.append(
-        mpm.spawn_discovery_process({'serial': mgr.get_serial()}, shared))
+        mpm.spawn_discovery_process(discovery_info, shared))
     _PROCESSES.append(
         mpm.spawn_rpc_process(mpm.types.MPM_RPC_PORT, shared, mgr))
     signal.signal(signal.SIGTERM, kill_time)
diff --git a/mpm/python/usrp_mpm/CMakeLists.txt b/mpm/python/usrp_mpm/CMakeLists.txt
index 12bcdac11..1ab48de0a 100644
--- a/mpm/python/usrp_mpm/CMakeLists.txt
+++ b/mpm/python/usrp_mpm/CMakeLists.txt
@@ -24,10 +24,8 @@ SET(USRP_MPM_TOP_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/types.py
     ${CMAKE_CURRENT_SOURCE_DIR}/discovery.py
     ${CMAKE_CURRENT_SOURCE_DIR}/rpc_server.py
-    ${CMAKE_CURRENT_SOURCE_DIR}/periphs.py
     )
 LIST(APPEND USRP_MPM_FILES ${USRP_MPM_TOP_FILES})
 ADD_SUBDIRECTORY(periph_manager)
 ADD_SUBDIRECTORY(dboard_manager)
-
 SET(USRP_MPM_FILES ${USRP_MPM_FILES} PARENT_SCOPE)
diff --git a/mpm/python/usrp_mpm/__init__.py b/mpm/python/usrp_mpm/__init__.py
index c7043c70c..7606f33ce 100644
--- a/mpm/python/usrp_mpm/__init__.py
+++ b/mpm/python/usrp_mpm/__init__.py
@@ -18,8 +18,8 @@
 MPM Module
 """
 
-from discovery import spawn_discovery_process
-from rpc_server import spawn_rpc_process
-import types
-import periph_manager
-import dboard_manager
+from .discovery import spawn_discovery_process
+from .rpc_server import spawn_rpc_process
+from . import types
+from . import periph_manager
+from . import dboard_manager
diff --git a/mpm/python/usrp_mpm/dboard_manager/CMakeLists.txt b/mpm/python/usrp_mpm/dboard_manager/CMakeLists.txt
index b642d506e..9cd65fa08 100644
--- a/mpm/python/usrp_mpm/dboard_manager/CMakeLists.txt
+++ b/mpm/python/usrp_mpm/dboard_manager/CMakeLists.txt
@@ -22,6 +22,7 @@ SET(USRP_MPM_FILES ${USRP_MPM_FILES})
 SET(USRP_MPM_DBMGR_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/__init__.py
     ${CMAKE_CURRENT_SOURCE_DIR}/base.py
+    ${CMAKE_CURRENT_SOURCE_DIR}/test.py
     ${CMAKE_CURRENT_SOURCE_DIR}/magnesium.py
     ${CMAKE_CURRENT_SOURCE_DIR}/eiscat.py
     ${CMAKE_CURRENT_SOURCE_DIR}/unknown.py
diff --git a/mpm/python/usrp_mpm/dboard_manager/__init__.py b/mpm/python/usrp_mpm/dboard_manager/__init__.py
index 02746e78f..f21e5258c 100644
--- a/mpm/python/usrp_mpm/dboard_manager/__init__.py
+++ b/mpm/python/usrp_mpm/dboard_manager/__init__.py
@@ -18,12 +18,12 @@
 dboards module __init__.py
 """
 from .. import libpyusrp_periphs as lib
-from magnesium import magnesium
-from eiscat import eiscat
-from test import test
-from unknown import unknown
+from .magnesium import magnesium
+from .eiscat import eiscat
+from .test import test
+from .unknown import unknown
 
-hw_pids = {
+HW_PIDS = {
     eiscat.hw_pid: eiscat,
     magnesium.hw_pid: magnesium,
 }
diff --git a/mpm/python/usrp_mpm/dboard_manager/base.py b/mpm/python/usrp_mpm/dboard_manager/base.py
index 257a2424d..37e7dd2b8 100644
--- a/mpm/python/usrp_mpm/dboard_manager/base.py
+++ b/mpm/python/usrp_mpm/dboard_manager/base.py
@@ -17,22 +17,22 @@
 """
 dboard base implementation module
 """
-from . import lib
 import logging
 import struct
 
-log = logging.Logger("usrp_mpm.dboards")
+LOG = logging.Logger(__name__)
 
 
-class dboard_manager(object):
+class DboardManagerBase(object):
     """
     Holds shared pointer to wrapped C++ implementation.
     Sanitizes arguments before calling C++ functions.
     Ties various constants to specific daughterboard class
     """
     _eeprom = {}
-    def __init__(self, eeprom={}):
-        self._eeprom = eeprom
+
+    def __init__(self, eeprom=None):
+        self._eeprom = eeprom or {}
 
     def get_serial(self):
         return self._eeprom.get("serial", "")
diff --git a/mpm/python/usrp_mpm/dboard_manager/eiscat.py b/mpm/python/usrp_mpm/dboard_manager/eiscat.py
index f536d307b..101290574 100644
--- a/mpm/python/usrp_mpm/dboard_manager/eiscat.py
+++ b/mpm/python/usrp_mpm/dboard_manager/eiscat.py
@@ -17,12 +17,12 @@
 """
 EISCAT rx board implementation module
 """
-from base import dboard_manager
-from base import lib
-from base import log
+from . import lib
+from .base import DboardManagerBase
+from .base import LOG
 
 
-class eiscat(dboard_manager):
+class eiscat(DboardManagerBase):
     hw_pid = 3
     special_eeprom_addrs = {"special0": "something"}
 
diff --git a/mpm/python/usrp_mpm/dboard_manager/magnesium.py b/mpm/python/usrp_mpm/dboard_manager/magnesium.py
index d48768208..f13f1de77 100644
--- a/mpm/python/usrp_mpm/dboard_manager/magnesium.py
+++ b/mpm/python/usrp_mpm/dboard_manager/magnesium.py
@@ -17,34 +17,52 @@
 """
 magnesium dboard implementation module
 """
-from base import dboard_manager
-from base import lib
-from base import log
+from . import lib
+from .base import DboardManagerBase
 import struct
+from logging import getLogger
 
-class magnesium(dboard_manager):
+LOG = getLogger(__name__)
+
+
+class magnesium(DboardManagerBase):
+    """
+    Holds all dboard specific information and methods of the magnesium dboard
+    """
     hw_pid = 2
     special_eeprom_addrs = {"special0": "something"}
     spi_chipselect = {"0": "lmk", "1": "mykonos", "2": "random"}
     spidevs = {}
+    lmk = ""
+    mykonos = ""
+    random = ""
 
     def __init__(self, spi_devices, eeprom_data, *args, **kwargs):
         # eeprom_data is a tuple (head_dict, raw_data)
         if len(spi_devices) != len(self.spi_chipselect):
-            log.error("Expected {0} spi devices, found {1} spi devices".format(len(spi_devices), len(self.spi_chipselect)))
+            LOG.error("Expected {0} spi devices, found {1} spi devices".format(len(spi_devices), len(self.spi_chipselect)))
             exit(1)
         for spi in spi_devices:
             device = self.spi_chipselect.get(spi[-1], None)
             if self.chipselect is None:
-                log.error("Unexpected chipselect {0}".format(spi[-1]))
+                LOG.error("Unexpected chipselect {0}".format(spi[-1]))
                 exit(1)
             setattr(self, device, spi)
         super(magnesium, self).__init__(*args, **kwargs)
 
     def init_device(self):
-        self._device = lib.db.magnesium(self.lmk, self.mykonos, self.random)
+        """
+        Execute necessary init dance to bring up dboard
+        """
+        LOG.debug("initialize hardware")
+
+        self._device = lib.dboards.magnesium(
+            self.lmk, self.mykonos, self.random)
 
     def read_eeprom_v1(self, data):
+        """
+        read eeprom data version 1
+        """
         # magnesium eeprom contains
         # nothing
         return struct.unpack_from("x", data)
diff --git a/mpm/python/usrp_mpm/dboard_manager/test.py b/mpm/python/usrp_mpm/dboard_manager/test.py
index b2e422bb4..80299ee41 100644
--- a/mpm/python/usrp_mpm/dboard_manager/test.py
+++ b/mpm/python/usrp_mpm/dboard_manager/test.py
@@ -17,8 +17,11 @@
 """
 magnesium dboard implementation module
 """
-from base import dboard_manager
-from base import log
+from . import lib
+from .base import DboardManagerBase
+from logging import getLogger
+
+LOG = getLogger(__name__)
 
 
 class fake_spi(object):
@@ -36,7 +39,7 @@ class test_device(object):
         return argument
 
 
-class test(dboard_manager):
+class test(DboardManagerBase):
     hw_pid = 234
     special_eeprom_addrs = {"special0": "something"}
     spi_chipselect = {"0": "dev1", "1": "dev2", "2": "dev3"}
@@ -51,6 +54,7 @@ class test(dboard_manager):
         self.dev3 = "2"
 
     def init_device(self):
+        LOG.debug("initialize hardware")
         self._device = test_device(self.dev1, self.dev2, self.dev3)
 
 
diff --git a/mpm/python/usrp_mpm/dboard_manager/unknown.py b/mpm/python/usrp_mpm/dboard_manager/unknown.py
index f33bacc46..de2354f3d 100644
--- a/mpm/python/usrp_mpm/dboard_manager/unknown.py
+++ b/mpm/python/usrp_mpm/dboard_manager/unknown.py
@@ -17,12 +17,13 @@
 """
 EISCAT rx board implementation module
 """
-from base import dboard_manager
-from base import lib
-from base import log
+from .base import DboardManagerBase
+from logging import getLogger
 
+LOG = getLogger(__name__)
 
-class unknown(dboard_manager):
+
+class unknown(DboardManagerBase):
     hw_pid = 0
     special_eeprom_addrs = {}
 
diff --git a/mpm/python/usrp_mpm/discovery.py b/mpm/python/usrp_mpm/discovery.py
index 174866498..595368c76 100644
--- a/mpm/python/usrp_mpm/discovery.py
+++ b/mpm/python/usrp_mpm/discovery.py
@@ -19,19 +19,19 @@ Code to run the discovery port
 """
 
 from __future__ import print_function
-import time
-import ctypes
-from multiprocessing import Process, Value
+from logging import getLogger
+from multiprocessing import Process
 from six import iteritems
 import socket
-from types import MPM_DISCOVERY_PORT, graceful_exit
+from usrp_mpm.types import MPM_DISCOVERY_PORT
+
+LOG = getLogger(__name__)
 
 RESPONSE_PREAMBLE = "USRP-MPM"
 RESPONSE_SEP = ";"
 RESPONSE_CLAIMED_KEY = "claimed"
 
 
-
 def spawn_discovery_process(device_info, shared_state):
     """
     Returns a process that contains the device discovery.
@@ -41,9 +41,9 @@ def spawn_discovery_process(device_info, shared_state):
                    will be included in the response string.
     """
     # claim_status = Value(ctypes.c_bool, False)
-    p = Process(target=_discovery_process, args=(device_info, shared_state))
-    p.start()
-    return p
+    proc = Process(target=_discovery_process, args=(device_info, shared_state))
+    proc.start()
+    return proc
 
 
 def _discovery_process(device_info, state):
@@ -65,12 +65,22 @@ def _discovery_process(device_info, state):
 
     send_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 
-    try:
-        while True:
-            data, sender = sock.recvfrom(4096)
-            if data.strip("\0") == "MPM-DISC":
-                send_data = create_response_string()
-                send_sock.sendto(send_data, sender)
-    except:
-        sock.close()
-        send_sock.close()
+    # try:
+    while True:
+        data, sender = sock.recvfrom(8000)
+        LOG.info("Got poked by: %s", sender[0])
+        if data.strip("\0") == "MPM-DISC":
+            LOG.info("Sending discovery response to %s port: %d",
+                     sender[0], sender[1])
+            send_data = create_response_string()
+            send_sock.sendto(send_data, sender)
+        elif data.strip("\0").startswith("MPM-ECHO"):
+            LOG.info("Received echo request")
+            send_data = data
+            send_sock.sendto(send_data, sender)
+
+    # except Exception as err:
+    #     LOG.info("Error: %s", err)
+    #     LOG.info("Error type: %s", type(err))
+    #     sock.close()
+    #     send_sock.close()
diff --git a/mpm/python/usrp_mpm/helper.py b/mpm/python/usrp_mpm/helper.py
deleted file mode 100644
index 29864124a..000000000
--- a/mpm/python/usrp_mpm/helper.py
+++ /dev/null
@@ -1,3 +0,0 @@
-
-
-class eeprom_helper:
diff --git a/mpm/python/usrp_mpm/periph_manager/CMakeLists.txt b/mpm/python/usrp_mpm/periph_manager/CMakeLists.txt
index 879ac20c1..f4bc1d1d2 100644
--- a/mpm/python/usrp_mpm/periph_manager/CMakeLists.txt
+++ b/mpm/python/usrp_mpm/periph_manager/CMakeLists.txt
@@ -23,6 +23,9 @@ SET(USRP_MPM_PERIPHMGR_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/__init__.py.in
     ${CMAKE_CURRENT_SOURCE_DIR}/base.py
     ${CMAKE_CURRENT_SOURCE_DIR}/n310.py
+    ${CMAKE_CURRENT_SOURCE_DIR}/test.py
+    ${CMAKE_CURRENT_SOURCE_DIR}/net.py
+    ${CMAKE_CURRENT_SOURCE_DIR}/udev.py
     )
-LIST(APPEND USRP_MPM_FILES ${USRP_MPM_TOP_FILES})
+LIST(APPEND USRP_MPM_FILES ${USRP_MPM_PERIPHMGR_FILES})
 SET(USRP_MPM_FILES ${USRP_MPM_FILES} PARENT_SCOPE)
diff --git a/mpm/python/usrp_mpm/periph_manager/__init__.py.in b/mpm/python/usrp_mpm/periph_manager/__init__.py.in
index 0956b849e..d8733ba17 100644
--- a/mpm/python/usrp_mpm/periph_manager/__init__.py.in
+++ b/mpm/python/usrp_mpm/periph_manager/__init__.py.in
@@ -24,6 +24,6 @@ from .. import dboard_manager
 from .. import types
 
 try:
-    from ${MPM_DEVICE} import ${MPM_DEVICE} as periph_manager
+    from .${MPM_DEVICE} import ${MPM_DEVICE} as periph_manager
 except ImportError:
     raise Exception("Could not import ${MPM_DEVICE}")
diff --git a/mpm/python/usrp_mpm/periph_manager/base.py b/mpm/python/usrp_mpm/periph_manager/base.py
index f19265a05..c84205a76 100644
--- a/mpm/python/usrp_mpm/periph_manager/base.py
+++ b/mpm/python/usrp_mpm/periph_manager/base.py
@@ -18,16 +18,24 @@
 Mboard implementation base class
 """
 
-import re
 import os
-from . import lib
-from . import types
-from . import dboard_manager
+from ..types import EEPROM
+from .. import dboard_manager
+from .udev import get_eeprom
+from .udev import get_spidev_nodes
+from six import iteritems
 
 
-class periph_manager(object):
+class PeriphManagerBase(object):
+    """"
+    Base class for all motherboards. Common function and API calls should
+    be implemented here. Motherboard specific information can be stored in
+    separate motherboard classes derived from this class
+    """
     # stores discovered device information in dicts
+    claimed = False
     dboards = {}
+    mboard_info = {"type": "unknown"}
     mboard_if_addrs = {}
     mboard_overlays = {}
     # this information has to be provided by
@@ -35,41 +43,88 @@ class periph_manager(object):
     mboard_eeprom_addr = ""
     dboard_eeprom_addrs = {}
     dboard_spimaster_addrs = {}
+    updateable_components = []
 
     def __init__(self):
         # I know my EEPROM address, lets use it
-        helper = lib.udev_helper.udev_helper()
-        (self._eeprom_head, self._eeprom_rawdata) = types.eeprom().read_eeprom(helper.get_eeprom(self.mboard_eeprom_addr))
+        self.overlays = ""
+        (self._eeprom_head, self._eeprom_rawdata) = EEPROM().read_eeprom(
+            get_eeprom(self.mboard_eeprom_addr))
         self._dboard_eeproms = {}
         for dboard_slot, eeprom_addr in self.dboard_eeprom_addrs.iteritems():
             spi_devices = []
             # I know EEPROM adresses for my dboard slots
-            eeprom_data = types.eeprom().read(helper.get_eeprom(eeprom_addr))
+            eeprom_data = EEPROM().read_eeprom(get_eeprom(eeprom_addr))
             # I know spidev masters on the dboard slots
-            hw_pid = eeprom_data.get("hw_pid", 0)
-            if hw_pid in dboards.hw_pids:
-                spi_devices = helper.get_spidev_nodes(self.dboard_spimaster_addrs.get(dboard_slot))
-            dboard = dboards.hw_pids.get(hw_pid, dboards.unknown)
+            hw_pid = eeprom_data[0].get("hw_pid", 0)
+            if hw_pid in dboard_manager.HW_PIDS:
+                spi_devices = get_spidev_nodes(self.dboard_spimaster_addrs.get(dboard_slot))
+            dboard = dboard_manager.HW_PIDS.get(hw_pid, dboard_manager.unknown)
             self.dboards.update({dboard_slot: dboard(spi_devices, eeprom_data)})
 
+    def safe_list_updateable_components(self):
+        """
+        return list of updateable components
+        This method does not require a claim_token in the RPC
+        """
+        return self.updateable_components
+
     def get_overlays(self):
+        """
+        get and store the list of available dt overlays
+        """
         self.mboard_overlays = []
-        for f in os.listdir("/lib/firmware/"):
-            if f.endswith(".dtbo"):
-                self.mboard_overlays.append(f.strip(".dtbo"))
+        for fw_files in os.listdir("/lib/firmware/"):
+            if fw_files.endswith(".dtbo"):
+                self.mboard_overlays.append(fw_files.strip(".dtbo"))
 
     def check_overlay(self):
-        for f in os.listdir("/sys/kernel/device-tree/overlays/"):
-            pass #do stuff
+        """
+        check which dt overlay is loaded currently
+        """
+        for overlay_file in os.listdir("/sys/kernel/device-tree/overlays/"):
+            self.overlays = overlay_file
+
+    def _get_device_info(self):
+        """
+        return the mboard_info dict and add a claimed field
+        """
+        result = {"claimed": str(self.claimed)}
+        result.update(self.mboard_info)
+        return result
 
-    def get_serial(self):
-        return self._serial
+    def get_dboards(self):
+        """
+        get a dict with slot: hw_pid for each dboard
+        """
+        result = {}
+        for slot, dboard in iteritems(self.dboards):
+            result.update({slot:dboard.hw_pid})
+        return result
 
     def load_fpga_image(self, target=None):
+        """
+        load a new fpga image
+        """
         pass
 
     def init_device(self, *args, **kwargs):
+        """
+        Do the real init on the mboard and all dboards
+        """
         # Load FPGA
         # Init dboards
         pass
 
+    def _probe_interface(self, sender_addr):
+        """
+        Overload this method in actual device implementation
+        """
+        return True
+
+    def get_interfaces(self):
+        """
+        Overload this method in actual device implementation
+        """
+        return []
+
diff --git a/mpm/python/usrp_mpm/periph_manager/n310.py b/mpm/python/usrp_mpm/periph_manager/n310.py
index d1c31540b..1b01ac066 100644
--- a/mpm/python/usrp_mpm/periph_manager/n310.py
+++ b/mpm/python/usrp_mpm/periph_manager/n310.py
@@ -17,24 +17,55 @@
 """
 N310 implementation module
 """
-from base import periph_manager
+from __future__ import print_function
 import struct
+from .base import PeriphManagerBase
+from .net import get_iface_addrs
+from .net import byte_to_mac
+from .net import get_mac_addr
+from logging import getLogger
 
+LOG = getLogger(__name__)
 
-class n310(periph_manager):
+
+class n310(PeriphManagerBase):
+    """
+    Holds N310 specific attributes and methods
+    """
     hw_pids = "1"
+    mboard_type = "n310"
     mboard_eeprom_addr = "e0007000.spi:ec@0:i2c-tunnel"
     dboard_eeprom_addrs = {"A": "something", "B": "else"}
     dboard_spimaster_addrs = {"A": "something", "B": "else"}
+    interfaces = {}
 
     def __init__(self, *args, **kwargs):
         # First initialize parent class - will populate self._eeprom_head and self._eeprom_rawdata
         super(n310, self).__init__(*args, **kwargs)
-        data = self.read_eeprom_v1(self._eeprom_rawdata)
+        data = self._read_eeprom_v1(self._eeprom_rawdata)
+        # mac 0: mgmt port, mac1: sfp0, mac2: sfp1
+        self.interfaces["mgmt"] = {
+            "mac_addr": byte_to_mac(data[0]),
+            "addrs": get_iface_addrs(byte_to_mac(data[0]))
+        }
+        self.interfaces["sfp0"] = {
+            "mac_addr": byte_to_mac(data[1]),
+            "addrs": get_iface_addrs(byte_to_mac(data[1]))
+        }
+        self.interfaces["sfp1"] = {
+            "mac_addr": byte_to_mac(data[2]),
+            "addrs": get_iface_addrs(byte_to_mac(data[2]))
+        }
+        self.mboard_info["serial"] = data[3]  # some format
+
         print(data)
         # if header.get("dataversion", 0) == 1:
 
-    def read_eeprom_v1(self, data):
+
+    def _read_eeprom_v1(self, data):
+        """
+        read eeprom with data version 1
+        """
         # data_version contains
         # 6 bytes mac_addr0
         # 2 bytes pad
@@ -44,3 +75,29 @@ class n310(periph_manager):
         # 2 bytes pad
         # 8 bytes serial
         return struct.unpack_from("6s 2x 6s 2x 6s 2x 8s", data)
+
+    def get_interfaces(self):
+        """
+        returns available transport interfaces
+        """
+        return [iface for iface in self.interfaces.keys()
+                if iface.startswith("sfp")]
+
+    def get_interface_addrs(self, interface):
+        """
+        returns discovered ipv4 addresses for a given interface
+        """
+        return self.interfaces.get(interface, {}).get("addrs", [])
+
+    def _probe_interface(self, sender_addr):
+        """
+        Get the MAC address of the sender and store it in the FPGA ARP table
+        """
+        mac_addr = get_mac_addr(sender_addr)
+        if mac_addr is not None:
+            # Do something with mac_address
+            return True
+        return False
+
+
+
diff --git a/mpm/python/usrp_mpm/periph_manager/net.py b/mpm/python/usrp_mpm/periph_manager/net.py
new file mode 100644
index 000000000..2df771549
--- /dev/null
+++ b/mpm/python/usrp_mpm/periph_manager/net.py
@@ -0,0 +1,63 @@
+
+# Copyright 2017 Ettus Research (National Instruments)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""
+N310 implementation module
+"""
+import itertools
+import socket
+from pyroute2 import IPRoute
+from logging import getLogger
+
+LOG = getLogger(__name__)
+
+
+def get_iface_addrs(mac_addr):
+    """
+    return ipv4 addresses for a given macaddress
+    input format: "aa:bb:cc:dd:ee:ff"
+    """
+    ip2 = IPRoute()
+    # returns index
+    [link] = ip2.link_lookup(address=mac_addr)
+    # Only get v4 addresses
+    addresses = [addr.get_attrs('IFA_ADDRESS')
+                 for addr in ip2.get_addr(family=socket.AF_INET)
+                 if addr.get('index', None) == link]
+    # flatten possibly nested list
+    addresses = list(itertools.chain.from_iterable(addresses))
+    return addresses
+
+
+def byte_to_mac(byte_str):
+    """
+    converts a bytestring into nice hex representation
+    """
+    return ':'.join(["%02x" % ord(x) for x in byte_str])
+
+
+def get_mac_addr(remote_addr):
+    """
+    return MAC address of a remote host already discovered
+    or None if no host entry was found
+    """
+    ip2 = IPRoute()
+    addrs = ip2.get_neighbours(dst=remote_addr)
+    if len(addrs) > 1:
+        LOG.warning("More than one device with the same IP address found. Picking entry at random")
+    if not addrs:
+        return None
+    return addrs[0].get_attr('NDA_LLADDR')
diff --git a/mpm/python/usrp_mpm/periph_manager/test.py b/mpm/python/usrp_mpm/periph_manager/test.py
index c9cbc1f3f..4daa876cb 100644
--- a/mpm/python/usrp_mpm/periph_manager/test.py
+++ b/mpm/python/usrp_mpm/periph_manager/test.py
@@ -17,15 +17,19 @@
 """
 test periph_manager implementation module
 """
-from base import periph_manager
+from __future__ import print_function
+from .base import PeriphManagerBase
 from . import dboard_manager
 import random
 import string
-import struct
 
 
-class test(periph_manager):
+class test(PeriphManagerBase):
+    """
+    Test periph manager class which fakes out all API calls
+    """
     hw_pids = "42"
+    mboard_info = {"type": "mpm_test"}
     mboard_eeprom_addr = None
     dboard_eeprom_addrs = {"A": "something", "B": "else"}
     dboard_spimaster_addrs = {"A": "something", "B": "else"}
@@ -34,27 +38,36 @@ class test(periph_manager):
         # First initialize parent class - will populate self._eeprom_head and self._eeprom_rawdata
         # super(n310, self).__init__(*args, **kwargs)
         # if header.get("dataversion", 0) == 1:
-        self._eeprom = self.read_eeprom_fake()
-        self._serial = "AABBCCDDEEFF"
+        self._eeprom = self._read_eeprom_fake()
+        print(self.mboard_info)
+        self.mboard_info["serial"] = "AABBCCDDEEFF"
+        self.mboard_info["name"] = self._eeprom["name"]
 
         # I'm the test periph_manager, I know I have test dboards attached
         self.dboards = {
-            "A": dboard_manager.test(self.read_db_eeprom_random()),
-            "B": dboard_manager.test(self.read_db_eeprom_random())
+            "A": dboard_manager.test(self._read_db_eeprom_random()),
+            "B": dboard_manager.test(self._read_db_eeprom_random())
         }
 
-    def read_eeprom_fake(self):
+    def _read_eeprom_fake(self):
+        """
+        fake eeprom readout function, returns dict with data
+        """
         fake_eeprom = {
             "magic": 42,
             "crc": 4242,
             "data_version": 42,
             "hw_pid": 42,
-            "hw_rev": 5
+            "hw_rev": 5,
+            "name": "foo"
         }
 
         return fake_eeprom
 
-    def read_db_eeprom_random(self):
+    def _read_db_eeprom_random(self):
+        """
+        fake db eeprom readout function, returns dict with fake dboard data
+        """
         fake_eeprom = {
             "serial": ''.join(
                 random.choice("ABCDEF" + string.digits)
diff --git a/mpm/python/usrp_mpm/periph_manager/udev.py b/mpm/python/usrp_mpm/periph_manager/udev.py
new file mode 100644
index 000000000..014e18ede
--- /dev/null
+++ b/mpm/python/usrp_mpm/periph_manager/udev.py
@@ -0,0 +1,42 @@
+#
+# Copyright 2017 Ettus Research (National Instruments)
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import pyudev
+
+
+def get_eeprom(address):
+    """
+    Return EEPROM device path for a given I2C address
+    """
+    context = pyudev.Context()
+    parent = pyudev.Device.from_name(context, "platform", address)
+    paths = [device.dev_node if device.dev_node is not None else device.sys_path
+             for device in context.list_devices(parent=parent, subsystem="nvmem")]
+    if len(paths) != 1:
+        raise Exception("{0} paths to EEPROM found!".format(len(paths)))
+    return paths[0]
+
+
+def get_spidev_nodes(spi_master):
+    """
+    Return found spidev device paths for a given SPI master
+    """
+    context = pyudev.Context()
+    parent = pyudev.Device.from_name(context, "platform", spi_master)
+    paths = [device.dev_node if device.dev_node is not None else device.sys_path
+             for device in context.list_devices(parent=parent, subsystem="spidev")]
+    return paths
diff --git a/mpm/python/usrp_mpm/periphs.py b/mpm/python/usrp_mpm/periphs.py
deleted file mode 100644
index 8c00d8f50..000000000
--- a/mpm/python/usrp_mpm/periphs.py
+++ /dev/null
@@ -1,38 +0,0 @@
-#
-# Copyright 2017 Ettus Research (National Instruments)
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-"""
- Module
-"""
-
-import libpyusrp_periphs as lib
-import logging
-import periph_manager
-import dboard_manager
-
-
-log = logging.Logger("usrp_mpm.periphs")
-
-def init_periph_manager(mb_type=None, db_types={}, fpga=None):
-    pass
-    # Moved to periph_manager/base.py __init__
-
-
-    # Next steps implemented in periph_manager/derived class
-    #
-    # 1. Load FPGA image
-    # 2. Use motherboard and daughterboard types to load the FPGA image
-    # 3. Create periph_manager object wth given mb_type + db_types information
diff --git a/mpm/python/usrp_mpm/rpc_server.py b/mpm/python/usrp_mpm/rpc_server.py
index ddb588aa6..f712c5c87 100644
--- a/mpm/python/usrp_mpm/rpc_server.py
+++ b/mpm/python/usrp_mpm/rpc_server.py
@@ -18,84 +18,204 @@
 Implemented RPC Servers
 """
 from __future__ import print_function
+from logging import getLogger
 from gevent.server import StreamServer
-from types import graceful_exit, MPM_RPC_PORT
+from gevent.pool import Pool
+from gevent import signal
+from gevent import spawn_later
+from gevent import Greenlet
+from gevent import monkey
+monkey.patch_all()
 from mprpc import RPCServer
+from random import choice
 from six import iteritems
-import time
-
+from string import ascii_letters, digits
+from threading import Timer
 from multiprocessing import Process
 
+
+LOG = getLogger(__name__)
+
+
 class MPMServer(RPCServer):
-    _db_methods = {}
-    def __init__(self, state, mgr):
+    """
+    Main MPM RPC class which holds the periph_manager object and translates
+    RPC calls to appropiate calls in the periph_manager and dboard_managers.
+
+    Claiming and unclaiming is implemented in python only
+    """
+    _db_methods = []
+    _mb_methods = []
+
+    def __init__(self, state, mgr, *args, **kwargs):
         self._state = state
-        # Instead do self.mboard = periphs.init_periph_manager(args...)
+        self._timer = Greenlet()
         self.periph_manager = mgr
-        for db_slot, db in iteritems(mgr.dboards):
-            methods = (m for m in dir(db) if not m.startswith('_') and callable(getattr(db, m)))
-            for method in methods:
-                command_name = 'db_'+ db_slot + '_' + method
-                self._add_command(getattr(db,method), command_name)
-                db_methods = self._db_methods.get(db_slot, [])
-                db_methods.append(command_name)
-                self._db_methods.update({db_slot: db_methods})
-
-        # When we do init we can just add dboard/periph_manager methods with setattr(self, method)
-        # Maybe using partial
-        # To remove methods again we also have to remove them from self._methods dict (they're cached)
-        super(MPMServer, self).__init__()
+        # add public mboard methods without namespace
+        self._update_component_commands(mgr, '', '_mb_methods')
+        # add public dboard methods in `db_<slot>_` namespace
+        for db_slot, dboard in iteritems(mgr.dboards):
+            self._update_component_commands(dboard, 'db_' + db_slot + '_', '_db_methods')
+        super(MPMServer, self).__init__(*args, **kwargs)
+
+    def _update_component_commands(self, component, namespace, storage):
+        """
+        Detect available methods for an object and add them to the RPC server
+        """
+        for method in (m for m in dir(component)
+                       if not m.startswith('_') and callable(getattr(component, m))):
+            if method.startswith('safe_'):
+                command_name = namespace + method.lstrip('safe_')
+                self._add_safe_command(getattr(component, method), command_name)
+            else:
+                command_name = namespace + method
+                self._add_command(getattr(component, method), command_name)
+            getattr(self, storage).append(command_name)
+
 
     def _add_command(self, function, command):
-        setattr(self, command, function)
+        """
+        Adds a method with the name command to the RPC server
+        This command will require an acquired claim on the device
+        """
+        LOG.debug("adding command %s pointing to %s", command, function)
 
+        def new_function(token, *args):
+            if token[:256] != self._state.claim_token.value:
+                return False
+            return function(*args)
+        new_function.__doc__ = function.__doc__
+        setattr(self, command, new_function)
+
+    def _add_safe_command(self, function, command):
+        """
+        Add a safe method which does not require a claim on the
+        device
+        """
+        LOG.debug("adding safe command %s pointing to %s", command, function)
+        setattr(self, command, function)
 
     def list_methods(self):
         """
-        Returns all public methods of this RPC server
+        Returns a tuple of public methods and
+        corresponding docs of this RPC server
         """
-        methods = filter(lambda entry: not entry.startswith('_'), dir(self)) # Return public methods
-        methods_with_docs = map(lambda m: (m, getattr(self, m).__doc__), methods)
-        return methods_with_docs
+        return [(met, getattr(self, met).__doc__)
+                for met in dir(self)
+                if not met.startswith('_') and callable(getattr(self, met))]
 
     def ping(self, data=None):
         """
         Take in data as argument and send it back
+        This is a safe method which can be called without a claim on the device
         """
+        LOG.debug("I was pinged from: %s:%s", self.client_host, self.client_port)
         return data
 
-    def claim(self, token):
+    def claim(self, sender_id):
+        """
+        claim `token` - tries to claim MPM device and provides a human readable sender_id
+        This is a safe method which can be called without a claim on the device
+        """
+        self._state.lock.acquire()
+        if self._state.claim_status.value:
+            return ""
+        LOG.debug("claiming from: %s", self.client_host)
+        self.periph_manager.claimed = True
+        self._state.claim_token.value = ''.join(choice(ascii_letters + digits) for _ in range(256))
+        self._state.claim_status.value = True
+        self._state.lock.release()
+        self.sender_id = sender_id
+        self._reset_timer()
+        LOG.debug("giving token: %s to host: %s", self._state.claim_token.value, self.client_host)
+        return self._state.claim_token.value
+
+    def reclaim(self, token):
         """
-        claim `token` - claims the MPM device with given token
+        reclaim a MPM device with a token. This operation will fail
+        if the device is claimed and the token doesn't match.
+        Or if the device is not claimed at all.
         """
+        self._state.lock.acquire()
         if self._state.claim_status.value:
-            if self._state.claim_token.value == token:
+            if self._state.claim_token.value == token[:256]:
+                self._state.lock.release()
+                LOG.debug("reclaimed from: %s", self.client_host)
+                self._reset_timer()
                 return True
+            self._state.lock.release()
+            LOG.debug("reclaim failed from: %s", self.client_host)
             return False
-        self._state.claim_status.value = True
-        self._state.claim_token.value = token
-        return True
+        LOG.debug("trying to reclaim unclaimed device from: %s", self.client_host)
+        return False
+
+
+
+
+    def _unclaim(self):
+        """
+        unconditional unclaim - for internal use
+        """
+        LOG.debug("releasing claim")
+        self._state.claim_status.value = False
+        self._state.claim_token.value = ""
+        self.sender_id = None
+        self.periph_manager.claimed = False
+        self._timer.kill()
+
+    def _reset_timer(self):
+        """
+        reset unclaim timer
+        """
+        self._timer.kill()
+        self._timer = spawn_later(2.0, self._unclaim)
 
     def unclaim(self, token):
         """
         unclaim `token` - unclaims the MPM device if it is claimed with this token
         """
         if self._state.claim_status.value and self._state.claim_token.value == token:
-            self._state.claim_status.value = False
-            self._state.claim_token.value = ""
+            self._unclaim()
             return True
         return False
 
+    def get_device_info(self):
+        """
+        get device information
+        This is as safe method which can be called without a claim on the device
+        """
+        info = self.periph_manager._get_device_info()
+        if self.host in ["127.0.0.1", "::1"]:
+            info["connection"] = "local"
+        else:
+            info["connection"] = "remote"
+        return info
+
+    def probe_interface(self, token):
+        """
+        Forwards the call to periph_manager._probe_interface with the client ip addresss
+        as argument. Should be used to probe the data interfaces on the device
+        """
+        if token[:256] != self._state.claim_token.value:
+            return False
+        return self.periph_manager._probe_interface(self.host)
+
+
+
 
 def _rpc_server_process(shared_state, port, mgr):
     """
     Start the RPC server
     """
-    server = StreamServer(('0.0.0.0', port), handle=MPMServer(shared_state, mgr))
-    try:
-        server.serve_forever()
-    except:
-        server.close()
+    connections = Pool(1000)
+    server = StreamServer(
+        ('0.0.0.0', port),
+        handle=MPMServer(shared_state, mgr),
+        spawn=connections)
+    # catch signals and stop the stream server
+    signal(signal.SIGTERM, lambda *args: server.stop())
+    signal(signal.SIGINT, lambda *args: server.stop())
+    server.serve_forever()
 
 
 def spawn_rpc_process(state, udp_port, mgr):
@@ -103,7 +223,7 @@ def spawn_rpc_process(state, udp_port, mgr):
     Returns a process that contains the RPC server
     """
 
-    p_args = [udp_port, state, mgr]
-    p = Process(target=_rpc_server_process, args=p_args)
-    p.start()
-    return p
+    proc_args = [udp_port, state, mgr]
+    proc = Process(target=_rpc_server_process, args=proc_args)
+    proc.start()
+    return proc
diff --git a/mpm/python/usrp_mpm/types.py b/mpm/python/usrp_mpm/types.py
index 31252e0b8..cc8fe8b8d 100644
--- a/mpm/python/usrp_mpm/types.py
+++ b/mpm/python/usrp_mpm/types.py
@@ -20,7 +20,7 @@ MPM types
 import ctypes
 from multiprocessing import Value
 from multiprocessing import Array
-from multiprocessing import Lock
+from multiprocessing import RLock
 import struct
 
 MPM_RPC_PORT = 49601
@@ -29,18 +29,26 @@ MPM_DISCOVERY_PORT = 49600
 MPM_DISCOVERY_MESSAGE = "MPM-DISC"
 
 
-class graceful_exit(Exception):
-    pass
+class SharedState(object):
+    """
+    Holds information which should be shared between processes
+    Usage should be kept to a minimum
+    """
 
-
-class shared_state:
     def __init__(self):
-        self.lock = Lock()
-        self.claim_status = Value(ctypes.c_bool, False, lock=self.lock) # lock
-        self.claim_token = Array(ctypes.c_char, 32, lock=self.lock) # String with max length of 32
+        self.lock = RLock()
+        self.claim_status = Value(
+            ctypes.c_bool,
+            False, lock=self.lock)  # lock
+        self.claim_token = Array(
+            ctypes.c_char, 256,
+            lock=self.lock)  # String with max length of 256
 
 
-class eeprom(object):
+class EEPROM(object):
+    """
+    Reads out common properties and rawdata out of a nvmem path
+    """
     # eeprom_header contains:
     # 4 bytes magic
     # 4 bytes CRC
@@ -53,9 +61,13 @@ class eeprom(object):
     eeprom_header = struct.Struct("I I H H H 2x")
 
     def read_eeprom(self, nvmem_path):
-        with open(nvmem_path, "rb") as f:
-            header = f.read(16)
-            data = f.read(240)
+        """
+        Read the EEPROM located at nvmem_path and return a tuple (header, body)
+        Header is already parsed in the common header fields
+        """
+        with open(nvmem_path, "rb") as nvmem_file:
+            header = nvmem_file.read(16)
+            data = nvmem_file.read(240)
         header = self.eeprom_header.unpack(header)
         header = {
             "magic": header[0],