--- config.py.orig	2019-01-23 15:55:57.907511700 -0800
+++ config.py	2019-01-27 21:11:46.740857400 -0800
@@ -32,7 +32,7 @@
 
 from mesh.access import Model, Opcode, AccessStatus
 import mesh.types as mt
-
+from time import sleep
 
 def log2b(value):
     """Binary log2"""
@@ -118,7 +118,7 @@
     _VENDOR_MODEL_APP_LIST                        = Opcode(0x804E)  # noqa: E501,E221
     _VENDOR_MODEL_SUBSCRIPTION_LIST               = Opcode(0x802C)  # noqa: E501,E221
 
-    def __init__(self, prov_db):
+    def __init__(self, prov_db, blocking = False):
         self.opcodes = [
             (self._APPKEY_LIST                      , self.__appkey_list_handler),                        # noqa: E501,E203
             (self._APPKEY_STATUS                    , self.__appkey_status_handler),                      # noqa: E501,E203
@@ -148,7 +148,8 @@
         self.prov_db = prov_db
         self.previous_command = None
         # FIXME: Hack to retain the virtual label UUID until we get an ack.
-        self._tmp_address = None
+        self._tmp_address = None 
+        self.blocking = blocking
         super(ConfigurationClient, self).__init__(self.opcodes)
 
     @staticmethod
@@ -160,9 +161,20 @@
             if single_cnt > 0:
                 keys.append(mt.KeyIndex.unpack(packed_keys[3 * pairs_cnt:])[0])
         return keys
-
+    
+    def _timeout_if_enabled(self, timeout = 10):
+        self.timeout = timeout
+        self.blocked = self.blocking
+        while ((self.timeout != 0) and (self.blocked == True)):
+            self.logger.info("Sleeping %d", self.timeout)
+            sleep(1)
+            self.timeout = self.timeout - 1
+        self.logger.info("blocked = %d, timeout = %d", self.blocked, self.timeout)
+        
     def composition_data_get(self, page_number=0x00):
         self.send(self._COMPOSITION_DATA_GET, bytearray([page_number]))
+        self._timeout_if_enabled()   
+        
 
     def appkey_add(self, appkey_index=0):
         key = self.prov_db.find_appkey(appkey_index)
@@ -175,6 +187,7 @@
         message += key.key
         self.previous_command = "add"
         self.send(self._APPKEY_ADD, message)
+        self._timeout_if_enabled()
 
     def appkey_update(self, appkey_index=0):
         key = self.prov_db.find_appkey(appkey_index)
@@ -187,6 +200,7 @@
         message += key.key
         self.previous_command = "update"
         self.send(self._APPKEY_UPDATE, message)
+        self._timeout_if_enabled()
 
     def appkey_delete(self, appkey_index=0):
         key = self.prov_db.find_appkey(appkey_index)
@@ -197,11 +211,13 @@
         key24 = mt.KeyIndex.pack(netkey_index, appkey_index)
         self.previous_command = "delete"
         self.send(self._APPKEY_DELETE, key24)
+        self._timeout_if_enabled()
 
     def appkey_get(self, netkey_index=0):
         message = bytearray()
         message += mt.KeyIndex.pack(netkey_index)
         self.send(self._APPKEY_GET, message)
+        self._timeout_if_enabled()
 
     def netkey_add(self, netkey_index=0):
         key = self.prov_db.find_netkey(netkey_index)
@@ -213,6 +229,7 @@
         message += key.key
         self.previous_command = "add"
         self.send(self._NETKEY_ADD, message)
+        self._timeout_if_enabled()
 
     def netkey_update(self, netkey_index=0):
         key = self.prov_db.find_netkey(netkey_index)
@@ -224,14 +241,17 @@
         message += key.key
         self.previous_command = "update"
         self.send(self._NETKEY_UPDATE, message)
+        self._timeout_if_enabled()
 
     def netkey_delete(self, netkey_index=0):
         message = mt.KeyIndex.pack(netkey_index)
         self.previous_command = "delete"
         self.send(self._NETKEY_DELETE, message)
+        self._timeout_if_enabled()
 
     def netkey_get(self):
         self.send(self._NETKEY_GET)
+        self._timeout_if_enabled()
 
     def model_app_bind(self, element_address, appkey_index, model_id):
         message = bytearray()
@@ -240,6 +260,7 @@
         message += model_id.pack()
         self.previous_command = "bind"
         self.send(self._MODEL_APP_BIND, message)
+        self._timeout_if_enabled()
 
     def model_app_unbind(self, element_address, appkey_index, model_id):
         message = bytearray()
@@ -248,6 +269,7 @@
         message += model_id.pack()
         self.previous_command = "unbind"
         self.send(self._MODEL_APP_UNBIND, message)
+        self._timeout_if_enabled()
 
     def model_app_get(self, element_address, model_id):
         message = bytearray()
@@ -257,6 +279,7 @@
             self.send(self._VENDOR_MODEL_APP_GET, message)
         else:
             self.send(self._SIG_MODEL_APP_GET, message)
+        self._timeout_if_enabled()
 
     def model_publication_set(self, element_address, model_id, publish):
 
@@ -273,12 +296,14 @@
             self.send(self._MODEL_PUBLICATION_VIRTUAL_ADDRESS_SET, message)
         else:
             self.send(self._MODEL_PUBLICATION_SET, message)
-
+        self._timeout_if_enabled()
+        
     def model_publication_get(self, element_address, model_id):
         message = bytearray()
         message += struct.pack("<H", element_address)
         message += model_id.pack()
         self.send(self._MODEL_PUBLICATION_GET, message)
+        self._timeout_if_enabled()
 
     def subscription_message_get(self, element_address, address, model_id):
         message = bytearray()
@@ -303,7 +328,8 @@
             self.send(self._MODEL_SUBSCRIPTION_VIRTUAL_ADDRESS_ADD, message)
         else:
             self.send(self._MODEL_SUBSCRIPTION_ADD, message)
-
+        self._timeout_if_enabled()
+            
     def model_subscription_delete(self, element_address, address, model_id):
         message = self.subscription_message_get(
             element_address, address, model_id)
@@ -313,7 +339,8 @@
             self.send(self._MODEL_SUBSCRIPTION_VIRTUAL_ADDRESS_DELETE, message)
         else:
             self.send(self._MODEL_SUBSCRIPTION_DELETE, message)
-
+        self._timeout_if_enabled()
+            
     def model_subscription_overwrite(self, element_address, address, model_id):
         message = self.subscription_message_get(
             element_address, address, model_id)
@@ -323,6 +350,7 @@
             self.send(self._MODEL_SUBSCRIPTION_VIRTUAL_ADDRESS_OVERWRITE, message)
         else:
             self.send(self._MODEL_SUBSCRIPTION_OVERWRITE, message)
+        self._timeout_if_enabled()
 
     def model_subscription_delete_all(self, element_address, model_id):
         message = bytearray()
@@ -330,6 +358,7 @@
         message += model_id.pack()
         self.previous_command = "delete_all"
         self.send(self._MODEL_SUBSCRIPTION_DELETE_ALL, message)
+        self._timeout_if_enabled()
 
     def model_subscription_get(self, element_address, model_id):
         message = bytearray()
@@ -339,60 +368,75 @@
             self.send(self._VENDOR_MODEL_SUBSCRIPTION_GET, message)
         else:
             self.send(self._SIG_MODEL_SUBSCRIPTION_GET, message)
+        self._timeout_if_enabled()
 
     def key_refresh_phase_get(self, netkey_index):
         message = bytearray()
         message += mt.KeyIndex.pack(netkey_index)
         self.send(self._KEY_REFRESH_PHASE_GET, message)
+        self._timeout_if_enabled()
 
     def key_refresh_phase_set(self, netkey_index):
         message = bytearray()
         message += mt.KeyIndex.pack(netkey_index)
         self.send(self._KEY_REFRESH_PHASE_GET, message)
+        self._timeout_if_enabled()
 
     def node_reset(self):
         self.send(self._NODE_RESET)
+        self._timeout_if_enabled()
 
     def beacon_get(self):
         self.send(self._BEACON_GET)
+        self._timeout_if_enabled()
 
     def beacon_set(self, state):
         message = bytearray(struct.pack("<B", int(state)))
         self.send(self._BEACON_SET, message)
+        self._timeout_if_enabled()
 
     def default_ttl_get(self):
         self.send(self._DEFAULT_TTL_GET)
+        self._timeout_if_enabled()
 
     def default_ttl_set(self, ttl):
         message = bytearray(struct.pack("<B", ttl))
         self.send(self._DEFAULT_TTL_SET, message)
+        self._timeout_if_enabled()
 
     def gatt_proxy_get(self):
         self.send(self._GATT_PROXY_GET)
+        self._timeout_if_enabled()
 
     def gatt_proxy_set(self, state):
         message = bytearray(struct.pack("<B", int(state)))
         self.send(self._GATT_PROXY_SET, message)
+        self._timeout_if_enabled()
 
     def relay_get(self):
         self.send(self._RELAY_GET)
+        self._timeout_if_enabled()
 
     def relay_set(self, state, retransmit_count=0, retransmit_interval_steps=0):
         retransmit = (retransmit_count & 0x07 |
                       (retransmit_interval_steps & 0x1f) << 3)
         message = bytearray(struct.pack("<BB", int(state), retransmit))
         self.send(self._RELAY_SET, message)
+        self._timeout_if_enabled()
 
     def friend_get(self):
         self.send(self._FRIEND_GET)
+        self._timeout_if_enabled()
 
     def friend_set(self, state):
         message = bytearray()
         message += struct.pack("<B", int(state))
         self.send(self._FRIEND_SET, message)
+        self._timeout_if_enabled()
 
     def heartbeat_publication_get(self):
         self.send(self._HEARTBEAT_PUBLICATION_GET)
+        self._timeout_if_enabled()
 
     def heartbeat_publication_set(self, dst, count, period, ttl=64,
                                   feature_bitfield=0, netkey_index=0):
@@ -400,38 +444,46 @@
         message += struct.pack(
             "<HBBBHH", dst, log2b(count), log2b(period), ttl, feature_bitfield, netkey_index)
         self.send(self._HEARTBEAT_PUBLICATION_SET, message)
+        self._timeout_if_enabled()
 
     def heartbeat_subscription_get(self):
         self.send(self._HEARTBEAT_SUBSCRIPTION_GET)
+        self._timeout_if_enabled()
 
     def heartbeat_subscription_set(self, src, dst, period):
         message = bytearray()
         message += struct.pack("<HHB", src, dst, log2b(period))
         self.send(self._HEARTBEAT_SUBSCRIPTION_SET, message)
+        self._timeout_if_enabled()
 
     def low_power_node_polltimeout_get(self, lpn_address):
         message = bytearray()
         message += struct.pack("<H", lpn_address)
         self.send(self._LOW_POWER_NODE_POLLTIMEOUT_GET, message)
+        self._timeout_if_enabled()
 
     def network_transmit_get(self):
         self.send(self._NETWORK_TRANSMIT_GET)
+        self._timeout_if_enabled()
 
     def network_transmit_set(self, count=0, interval_steps=1):
         message = bytearray()
         message += struct.pack("<B", mt.NetworkTransmit(count, interval_steps).pack())
         self.send(self._NETWORK_TRANSMIT_SET, message)
+        self._timeout_if_enabled()
 
     def node_identity_get(self, netkey_index):
         message = bytearray()
         message += mt.KeyIndex.pack(netkey_index)
         self.send(self._NODE_IDENTITY_GET, message)
+        self._timeout_if_enabled()
 
     def node_identity_set(self, netkey_index, state):
         message = bytearray()
         message += mt.KeyIndex.pack(netkey_index)
         message += struct.pack("<B", int(state))
         self.send(self._NODE_IDENTITY_SET, message)
+        self._timeout_if_enabled()
 
     def node_get(self, src):
         for node in self.prov_db.nodes:
@@ -456,8 +508,9 @@
 
     def db_save(self):
         self.prov_db.store()
-
+    
     def __composition_data_status_handler(self, opcode, message):
+        self.blocked = False
         page = message.data[0]
         data = message.data[1:]
         data = mt.CompositionData().unpack(data)
@@ -471,8 +524,9 @@
         self.db_save()
         self.logger.info("Received composition data (page 0x%02x): %s",
                          page, json.dumps(data, indent=2))
-
+    
     def __heartbeat_publication_status_handler(self, opcode, message):
+        self.blocked = False
         status, dst, count_log, period_log, ttl, features, netkey_index = struct.unpack(
             "<BHBBBHH", message.data)
         status = AccessStatus(status)
@@ -491,6 +545,7 @@
                              dst, count, period, features, netkey_index)
 
     def __appkey_status_handler(self, opcode, message):
+        self.blocked = False
         status = AccessStatus(message.data[0])
         netkey_index, appkey_index = mt.KeyIndex.unpack(message.data[1:4])
         self.logger.info("Appkey status: %s", status)
@@ -508,6 +563,7 @@
                              message.meta["src"])
 
     def __appkey_list_handler(self, opcode, message):
+        self.blocked = False
         status, netkey_index = struct.unpack("<BH", message.data[0:3])
         status = AccessStatus(status)
         self.logger.info("Appkey list status: %s", status)
@@ -532,6 +588,7 @@
                              message.meta["src"], appkeys)
 
     def __beacon_status_handler(self, opcode, message):
+        self.blocked = False
         state = struct.unpack("<B", message.data)[0]
         state = bool(state)
         node = self.node_get(message.meta["src"])
@@ -541,6 +598,7 @@
                          "on" if state else "off")
 
     def __default_ttl_status_handler(self, opcode, message):
+        self.blocked = False
         ttl = struct.unpack("<B", message.data)[0]
         node = self.node_get(message.meta["src"])
         node.default_TTL = mt.TTL(ttl)
@@ -548,6 +606,7 @@
         self.logger.info("Default TTL: %d", ttl)
 
     def __friend_status_handler(self, opcode, message):
+        self.blocked = False
         state = struct.unpack("<B", message.data)[0]
         node = self.node_get(message.meta["src"])
         node.features.friend = mt.FeatureState(state)
@@ -555,6 +614,7 @@
         self.logger.info("Friend state: %r", state)
 
     def __gatt_proxy_status_handler(self, opcode, message):
+        self.blocked = False
         state = struct.unpack("<B", message.data)[0]
         node = self.node_get(message.meta["src"])
         node.features.proxy = mt.FeatureState(state)
@@ -562,6 +622,7 @@
         self.logger.info("Proxy state: %r", state)
 
     def __key_refresh_phase_status_handler(self, opcode, message):
+        self.blocked = False
         status, netkey_index, phase = struct.unpack("<BHB", message.data)
         status = AccessStatus(status)
         self.logger.info("Key refresh status: %s", status)
@@ -575,6 +636,7 @@
                                      phase, netkey_index, node.unicastAddress)
 
     def __model_publication_status_handler(self, opcode, message):
+        self.blocked = False
         status, element_address = struct.unpack("<BH", message.data[0:3])
         status = AccessStatus(status)
         self.logger.info("Model publication status: %s", status)
@@ -590,6 +652,7 @@
                              model.model_id, element_address, publish)
 
     def __model_subscription_status_handler(self, opcode, message):
+        self.blocked = False
         status, element_address = struct.unpack("<BH", message.data[0:3])
         status = AccessStatus(status)
         self.logger.info("Model subscription status: %s", status)
@@ -607,12 +670,14 @@
                              address, model_id, element_address)
 
     def __network_transmit_status_handler(self, opcode, message):
+        self.blocked = False
         node = self.node_get(message.meta["src"])
         node.network_transmit = mt.NetworkTransmit.unpack(message.data[0])
         self.db_save()
         self.logger.info("Network transmit state: %r", node.network_transmit)
 
     def __relay_status_handler(self, opcode, message):
+        self.blocked = False
         state, retransmit = struct.unpack("<BB", message.data)
         node = self.node_get(message.meta["src"])
         node.relay_retransmit = mt.RelayRetransmit.unpack(retransmit)
@@ -623,6 +688,7 @@
             state, node.relay_retransmit.count, node.relay_retransmit.interval)
 
     def __heartbeat_subscription_status_handler(self, opcode, message):
+        self.blocked = False
         status, src, dst, period_log, count_log, min_hops, max_hops = struct.unpack(
             "<BHHBBBB", message.data)
         status = AccessStatus(status)
@@ -637,6 +703,7 @@
                              src, dst, period, count_log, min_hops, max_hops)
 
     def __model_app_status_handler(self, opcode, message):
+        self.blocked = False
         status, element_address, appkey_index = struct.unpack(
             "<BHH", message.data[:5])
         status = AccessStatus(status)
@@ -659,6 +726,7 @@
                              self.previous_command, appkey_index, model_id, element_address)
 
     def __netkey_status_handler(self, opcode, message):
+        self.blocked = False
         status, netkey_index = struct.unpack("<BH", message.data)
         netkey_index = mt.KeyIndex(netkey_index)
         status = AccessStatus(status)
@@ -672,6 +740,7 @@
                              netkey_index, message.meta["src"])
 
     def __netkey_list_handler(self, opcode, message):
+        self.blocked = False
         node = self.node_get(message.meta["src"])
         if len(message.data) > 0:
             node.net_keys = ConfigurationClient._unpack_key_ind(message.data)
@@ -680,6 +749,7 @@
                          message.meta["src"], node.net_keys)
 
     def __node_identity_status_handler(self, opcode, message):
+        self.blocked = False
         status, netkey_index, identity = struct.unpack("<BHB", message.data)
         status = AccessStatus(status)
         self.logger.info("Node identity status: %s", status)
@@ -695,9 +765,11 @@
                 "Current node identity for subnet %d is %s", netkey_index, state)
 
     def __node_reset_status_handler(self, opcode, message):
+        self.blocked = False
         self.logger.info("Node %04x was reset", message.meta["src"])
 
     def __model_sig_app_list_handler(self, opcode, message):
+        self.blocked = False
         status, element_address, model_id = struct.unpack(
             "<BHH", message.data[0:5])
         status = AccessStatus(status)
@@ -711,6 +783,7 @@
                 "SIG model %04x has appkey(s) %r bound", model_id, appkeys)
 
     def __model_sig_subscription_list_handler(self, opcode, message):
+        self.blocked = False
         status, element_address, model_id = struct.unpack(
             "<BHH", message.data[0:5])
         status = AccessStatus(status)
@@ -730,6 +803,7 @@
                 "SIG model %04x has addresse(s) %r bound", model_id, addresses)
 
     def __vendor_model_app_list_handler(self, opcode, message):
+        self.blocked = False
         status, element_address, company_id, model_id = struct.unpack(
             "<BHHH", message.data[0:7])
         status = AccessStatus(status)
@@ -745,6 +819,7 @@
                              model_id, company_id, appkeys)
 
     def __vendor_model_subscription_list_handler(self, opcode, message):
+        self.blocked = False
         status, element_address, company_id, model_id = struct.unpack(
             "<BHHH", message.data[0:7])
         status = AccessStatus(status)
@@ -765,6 +840,7 @@
                              model_id, company_id, addresses)
 
     def __low_power_node_polltimeout_status_handler(self, opcode, message):
+        self.blocked = False
         # We append a 0x00 to the bytearray to unpack the PollTimeout as a uint32_t
         lpn_address, poll_timeout = struct.unpack("<HI", message.data + bytearray(1))
 
@@ -775,3 +851,6 @@
         else:
             self.logger.info("Node is not a Friend not or LPN address %04x not a known LPN address",
                              lpn_address)
+
+
+