Merge pull request #112 from ARMmbed/devel_lockfile_timeout_fix

Bug-fixes around file lock for $HOME mock data

Author: PrzemekWirkus

mbed_lstools/lstools_base.py

@@ -35,12 +35,6 @@ def __init__(self):
         self.ERRORLEVEL_FLAG = 0    # Used to return success code to environment
         self.retarget_data = {}          # Used to retarget mbed-enabled platform properties
 
-        # If there is a local mocking data use it and add / override manufacture_ids
-        mock_ids = self.mock_read()
-        if mock_ids:
-            for mid in mock_ids:
-                self.manufacture_ids[mid] = mock_ids[mid]
-
         # Create in HOME directory place for mbed-ls to store information
         self.mbedls_home_dir_init()
 
@@ -211,17 +205,35 @@ def __init__(self):
     MBED_HTM_NAME = 'mbed.htm'
 
     def mbedls_home_dir_init(self):
-        """ Initialize data in home directory for locking features
+        """! Initialize data in home directory for locking features
+        @details Create '.mbed-ls' sub-directory in current user $HOME directory
         """
         if not os.path.isdir(os.path.join(self.HOME_DIR, self.MBEDLS_HOME_DIR)):
             os.mkdir(os.path.join(self.HOME_DIR, self.MBEDLS_HOME_DIR))
 
+    def mbedls_get_mocks(self):
+        """! Load existing mocking configuration from current user $HOME directory
+        @details If there is a local mocking data use it and add / override manufacture_ids
+        """
+        mock_ids = self.mock_read()
+        if mock_ids:
+            self.debug(self.mbedls_get_mocks.__name__, "mock data found, %d entries"% len(mock_ids))
+            for mid in mock_ids:
+                self.manufacture_ids[mid] = mock_ids[mid]
+
     def mbedls_get_global_lock(self):
+        """! Create lock (file lock) object used to guard operations on
+             mock configuration file in current user $HOME directory
+        @return Global lock object instance
+        """
         file_path = os.path.join(self.HOME_DIR, self.MBEDLS_HOME_DIR, self.MBEDLS_GLOBAL_LOCK)
         lock = lockfile.LockFile(file_path)
         return lock
 
     def list_manufacture_ids(self):
+        """! Creates list of all available mappings for target_id -> Platform
+        @return String with table formatted output
+        """
         from prettytable import PrettyTable
 
         columns = ['target_id_prefix', 'platform_name']
@@ -237,11 +249,12 @@ def list_manufacture_ids(self):
 
     def mock_read(self):
         """! Load mocking data from local file
+        @details Uses file locking for operation on Mock
+                 configuration file in current user $HOME directory
         @return Curent mocking configuration (dictionary)
         """
 
         def read_mock_file(filename):
-            self.debug(self.mock_read.__name__, "reading mock file '%s'"% filename)
             try:
                 with open(filename, "r") as f:
                     return json.load(f)
@@ -253,31 +266,38 @@ def read_mock_file(filename):
                     str(e)))
             return {}
 
-        try:
-            lock = self.mbedls_get_global_lock()
-            if lock.acquire(timeout=0.5):
-                # This read is for backward compatibility
-                # When user already have on its system local mock-up it will work
-                # overwriting global one
-                if isfile(self.MOCK_FILE_NAME):
-                    ret = read_mock_file(self.MOCK_FILE_NAME)
-                    lock.release()
-                    return ret
-
-                if isfile(self.MOCK_HOME_FILE_NAME):
-                    ret = read_mock_file(self.MOCK_HOME_FILE_NAME)
-                    lock.release()
-                    return ret
-        except (LockFailed, LockTimeout) as e:
-            self.err(str(e))
-        return {}
+        lock = self.mbedls_get_global_lock()
+        while not lock.i_am_locking():
+            try:
+                lock.acquire(timeout=1)
+            except LockTimeout as e:
+                lock.break_lock()
+                lock.acquire()
+                self.debug(self.mock_read.__name__, str(e))
+        self.debug(self.mock_read.__name__, "locked '%s'"% lock.path)
+
+        result = {}
+
+        # This read is for backward compatibility
+        # When user already have on its system local mock-up it will work
+        # overwriting global one
+        if isfile(self.MOCK_FILE_NAME):
+            result = read_mock_file(self.MOCK_FILE_NAME)
+        elif isfile(self.MOCK_HOME_FILE_NAME):
+            result = read_mock_file(self.MOCK_HOME_FILE_NAME)
+
+        lock.release()
+        self.debug(self.mock_read.__name__, "released '%s'"% lock.path)
+        return result
 
     def mock_write(self, mock_ids):
         """! Write current mocking structure
         @param mock_ids JSON mock data to dump to file
+        @details Uses file locking for operation on Mock
+                 configuration file in current user $HOME directory
+        @return True if configuration operation was success, else False
         """
         def write_mock_file(filename, mock_ids):
-            self.debug(self.mock_write.__name__, "writing mock file '%s'"% filename)
             try:
                 with open(filename, "w") as f:
                     f.write(json.dumps(mock_ids, indent=4))
@@ -290,15 +310,21 @@ def write_mock_file(filename, mock_ids):
                     str(e)))
             return False
 
-        try:
-            lock = self.mbedls_get_global_lock()
-            if lock.acquire(timeout=0.5):
-                ret = write_mock_file(self.MOCK_HOME_FILE_NAME, mock_ids)
-                lock.release()
-                return ret
-        except (LockFailed, LockTimeout) as e:
-            self.err(str(e))
-        return False
+        lock = self.mbedls_get_global_lock()
+        while not lock.i_am_locking():
+            try:
+                lock.acquire(timeout=1)
+            except LockTimeout as e:
+                lock.break_lock()
+                lock.acquire()
+                self.debug(self.mock_read.__name__, str(e))
+        self.debug(self.mock_write.__name__, "locked '%s'"% lock.path)
+
+        result = write_mock_file(self.MOCK_HOME_FILE_NAME, mock_ids)
+
+        lock.release()
+        self.debug(self.mock_read.__name__, "released '%s'"% lock.path)
+        return result
 
     def retarget_read(self):
         """! Load retarget data from local file
@@ -319,6 +345,8 @@ def retarget_read(self):
 
     def retarget(self):
         """! Enable retargeting
+        @details Read data from local retarget configuration file
+        @return Retarget data structure read from configuration file
         """
         self.retarget_data = self.retarget_read()
         return self.retarget_data

mbed_lstools/main.py

@@ -169,6 +169,9 @@ def get_mbedls_version():
     mbeds.DEBUG_FLAG = opts.debug
     mbeds.debug(__name__, "mbed-ls ver. " + get_mbedls_version())
 
+    # Load extra mock configuration
+    mbeds.mbedls_get_mocks()
+
     if not opts.skip_retarget:
         mbeds.retarget()