Eliminated unnecessary reraising and some commented code.

Author: dsoprea

gdrivefs/cache/cache_registry.py

@@ -54,13 +54,13 @@ def remove(self, resource_name, key, cleanup_pretrigger=None):
                       (resource_name, key, type(cleanup_pretrigger)))
 
         with CacheRegistry.__rlock:
-            try:
-                old_tuple = self.__cache[resource_name][key]
-            except:
-                raise
+            old_tuple = self.__cache[resource_name][key]
 
-            self.__cleanup_entry(resource_name, key, True, 
-                                 cleanup_pretrigger=cleanup_pretrigger)
+            self.__cleanup_entry(
+                resource_name, 
+                key, 
+                True, 
+                cleanup_pretrigger=cleanup_pretrigger)
 
         return old_tuple[0]
 

gdrivefs/change.py

@@ -137,27 +137,15 @@ def __apply_change(self, change_id, change_tuple):
         _logger.debug("Removing all trace of entry with ID [%s] "
                       "(apply_change).", entry_id)
 
-        try:
-            PathRelations.get_instance().remove_entry_all(entry_id)
-        except:
-            _logger.exception("There was a problem remove entry with ID "
-                              "[%s] from the caches.", entry_id)
-            raise
+        PathRelations.get_instance().remove_entry_all(entry_id)
 
         # If it wasn't deleted, add it back.
 
         _logger.debug("Registering changed entry with ID [%s].", entry_id)
 
         if is_visible:
             path_relations = PathRelations.get_instance()
-
-            try:
-                path_relations.register_entry(entry)
-            except:
-                _logger.exception("Could not register changed entry with "
-                                  "ID [%s] with path-relations cache.",
-                                  entry_id)
-                raise
+            path_relations.register_entry(entry)
 
 _instance = None
 def get_change_manager():

gdrivefs/conf.py

@@ -50,12 +50,7 @@ class Conf(object):
 
     @staticmethod
     def get(key):
-        try:
-            return Conf.__dict__[key]
-        except:
-            _logger.exception("Could not retrieve config value with key [%s].", 
-                              key)
-            raise
+        return Conf.__dict__[key]
 
     @staticmethod
     def set(key, value):

gdrivefs/gdfs/displaced_file.py

@@ -35,26 +35,17 @@ def deposit_file(self, mime_type):
 
         gd = get_gdrive()
 
-        try:
-            result = gd.download_to_local(
-                        self.__filepath, 
-                        self.__normalized_entry,
-                        mime_type)
-            (length, cache_fault) = result
-        except:
-            _logger.exception("Could not localize displaced file with entry"
-                              "having ID [%s].", self.__normalized_entry.id)
-            raise
+        result = gd.download_to_local(
+                    self.__filepath, 
+                    self.__normalized_entry,
+                    mime_type)
+
+        (length, cache_fault) = result
 
         _logger.debug("Displaced entry [%s] deposited to [%s] with length "
                       "(%d).", self.__normalized_entry, self.__filepath, length)
 
-        try:
-            return self.get_stub(mime_type, length, self.__filepath)
-        except:
-            _logger.exception("Could not build stub for [%s].",
-                              self.__normalized_entry)
-            raise
+        return self.get_stub(mime_type, length, self.__filepath)
 
     def get_stub(self, mime_type, file_size=0, file_path=None):
         """Return the content for an info ("stub") file."""

gdrivefs/gdfs/fsutility.py

@@ -117,19 +117,9 @@ def split_path(filepath_original, pathresolver_cb):
     """
 
     # Remove any export-type that this file-path might've been tagged with.
-
-    try:
-        (filepath, mime_type) = strip_export_type(filepath_original)
-    except:
-        _logger.exception("Could not process path [%s] for export-type.",
-                          filepath_original)
-        raise
-
-#    log.debug("File-path [%s] split into filepath [%s] and mime_type "
-#              "[%s]." % (filepath_original, filepath, mime_type))
+    (filepath, mime_type) = strip_export_type(filepath_original)
 
     # Split the file-path into a path and a filename.
-
     (path, filename) = split(filepath)
 
     # Lookup the file, as it was listed, in our cache.
@@ -144,18 +134,12 @@ def split_path(filepath_original, pathresolver_cb):
         raise GdNotFoundError()
 
     if not path_resolution:
-#        log.debug("Path [%s] does not exist for split." % (path))
         raise GdNotFoundError()
 
     (parent_entry, parent_clause) = path_resolution
 
     is_hidden = (filename[0] == '.') if filename else False
 
-#    log.debug("File-path [%s] split into parent with ID [%s], path [%s], "
-#              "unverified filename [%s], mime-type [%s], and is_hidden [%s]." % 
-#              (filepath_original, parent_entry.id, path, filename, 
-#               mime_type, is_hidden))
-
     return (parent_clause, path, filename, mime_type, is_hidden)
 
 def split_path_nolookups(filepath_original):
@@ -164,16 +148,9 @@ def split_path_nolookups(filepath_original):
     """
 
     # Remove any export-type that this file-path might've been tagged with.
-
-    try:
-        (filepath, mime_type) = strip_export_type(filepath_original)
-    except:
-        _logger.exception("Could not process path [%s] for export-type.",
-                          filepath_original)
-        raise
+    (filepath, mime_type) = strip_export_type(filepath_original)
 
     # Split the file-path into a path and a filename.
-
     (path, filename) = split(filepath)
 
     # We don't remove the period, if we will mark it as hidden, as appropriate.

gdrivefs/gdfs/gdfuse.py

@@ -100,32 +100,19 @@ class _GdfsMixin(object):
     """The main filesystem class."""
 
     def __register_open_file(self, fh, path, entry_id):
-
         with self.fh_lock:
             self.open_files[fh] = (entry_id, path)
 
     def __deregister_open_file(self, fh):
-
         with self.fh_lock:
-            try:
-                file_info = self.open_files[fh]
-            except:
-                _logger.exception("Could not deregister invalid file-handle "
-                                  "(%d).", fh)
-                raise
+            file_info = self.open_files[fh]
 
             del self.open_files[fh]
             return file_info
 
     def __get_open_file(self, fh):
-
         with self.fh_lock:
-            try:
-                return self.open_files[fh]
-            except:
-                _logger.exception("Could not retrieve on invalid file-handle "
-                                  "(%d).", fh)
-                raise
+            return self.open_files[fh]
 
     def __build_stat_from_entry(self, entry):
         (uid, gid, pid) = fuse_get_context()
@@ -656,13 +643,7 @@ def truncate(self, filepath, length, fh=None):
 
             entry_id = opened_file.entry_id
             cache = EntryCache.get_instance().cache
-
-            try:
-                entry = cache.get(entry_id)
-            except:
-                _logger.exception("Could not fetch normalized entry with ID "
-                                  "[%s] for truncate with FH.", entry_id)
-                raise
+            entry = cache.get(entry_id)
 
             opened_file.truncate(length)
         else:
@@ -724,7 +705,7 @@ def unlink(self, file_path):
 
         try:
             gd.remove_entry(normalized_entry)
-        except (NameError):
+        except NameError:
             raise FuseOSError(ENOENT)
         except:
             _logger.exception("Could not remove file [%s] with ID [%s].",
@@ -733,13 +714,7 @@ def unlink(self, file_path):
             raise FuseOSError(EIO)
 
         # Remove from cache. Will no longer be able to be found, locally.
-
-        try:
-            PathRelations.get_instance().remove_entry_all(entry_id)
-        except:
-            _logger.exception("There was a problem removing entry [%s] "
-                              "from the caches.", normalized_entry)
-            raise
+        PathRelations.get_instance().remove_entry_all(entry_id)
 
         # Remove from among opened-files.
 
@@ -859,15 +834,11 @@ def mount(auth_storage_filepath, mountpoint, debug=None, nothreads=None,
 
             try:
                 Conf.set(k, v)
-            except (KeyError) as e:
+            except KeyError as e:
                 _logger.debug("Forwarding option [%s] with value [%s] to "
                               "FUSE.", k, v)
 
                 fuse_opts[k] = v
-            except:
-                _logger.exception("Could not set option [%s]. It is probably "
-                                  "invalid.", k)
-                raise
 
     if gdrivefs.config.IS_DEBUG is True:
         _logger.debug("FUSE options:\n%s", pprint.pformat(fuse_opts))

gdrivefs/gdtool/drive.py

@@ -272,10 +272,11 @@ def get_children_under_parent_id(self,
 
         client = self.__auth.get_client()
 
-        if query_contains_string and query_is_string:
-            _logger.exception("The query_contains_string and query_is_string "
-                              "parameters are mutually exclusive.")
-            raise
+        assert \
+            (query_contains_string is not None and 
+             query_is_string is not None) is False,
+            "The query_contains_string and query_is_string parameters are "\
+            "mutually exclusive."
 
         if query_is_string:
             query = ("title='%s'" % 
@@ -302,14 +303,7 @@ def get_children_under_parent_id(self,
     def get_entries(self, entry_ids):
         retrieved = { }
         for entry_id in entry_ids:
-            try:
-                entry = self.get_entry(entry_id)
-            except:
-                _logger.exception("Could not retrieve entry with ID [%s].",
-                                  entry_id)
-                raise
-
-            retrieved[entry_id] = entry
+            retrieved[entry_id] = self.get_entry(entry_id)
 
         _logger.debug("(%d) entries were retrieved.", len(retrieved))
 
@@ -381,15 +375,10 @@ def list_files(self, query_contains_string=None, query_is_string=None,
                           "(%d).", len(result[u'items']), page_num)
 
             for entry_raw in result[u'items']:
-                try:
-                    entry = \
-                        gdrivefs.gdtool.normal_entry.NormalEntry(
-                            'list_files', 
-                            entry_raw)
-                except:
-                    _logger.exception("Could not normalize raw-data for entry "
-                                      "with ID [%s].", entry_raw[u'id'])
-                    raise
+                entry = \
+                    gdrivefs.gdtool.normal_entry.NormalEntry(
+                        'list_files', 
+                        entry_raw)
 
                 entries.append(entry)
 
@@ -434,13 +423,7 @@ def download_to_local(self, output_file_path, normalized_entry, mime_type,
         use_cache = False
         if allow_cache and os.path.isfile(output_file_path):
             # Determine if a local copy already exists that we can use.
-            try:
-                stat_info = os.stat(output_file_path)
-            except:
-                _logger.exception("Could not retrieve stat() information "
-                                  "for temp download file [%s].",
-                                  output_file_path)
-                raise
+            stat_info = os.stat(output_file_path)
 
             if gd_mtime_epoch == stat_info.st_mtime:
                 use_cache = True
@@ -777,7 +760,7 @@ def remove_entry(self, normalized_entry):
 
         try:
             result = client.files().delete(**args).execute()
-        except (Exception) as e:
+        except Exception as e:
             if e.__class__.__name__ == 'HttpError' and \
                str(e).find('File not found') != -1:
                 raise NameError(normalized_entry.id)

gdrivefs/gdtool/normal_entry.py

@@ -48,43 +48,38 @@ def __init__(self, gd_resource_type, raw_data):
         # can get a file-size up-front, or we have to decide on a specific 
         # mime-type in order to do so.
 
-        try:
-            requires_mimetype = u'fileSize' not in self.__raw_data and \
-                                raw_data[u'mimeType'] != self.__directory_mimetype
+        requires_mimetype = u'fileSize' not in self.__raw_data and \
+                            raw_data[u'mimeType'] != self.__directory_mimetype
 
-            self.__info['requires_mimetype'] = \
-                requires_mimetype
-            
-            self.__info['title'] = \
-                raw_data[u'title']
-            
-            self.__info['mime_type'] = \
-                raw_data[u'mimeType']
-            
-            self.__info['labels'] = \
-                raw_data[u'labels']
-            
-            self.__info['id'] = \
-                raw_data[u'id']
-            
-            self.__info['last_modifying_user_name'] = \
-                raw_data[u'lastModifyingUserName']
-            
-            self.__info['writers_can_share'] = \
-                raw_data[u'writersCanShare']
+        self.__info['requires_mimetype'] = \
+            requires_mimetype
+        
+        self.__info['title'] = \
+            raw_data[u'title']
+        
+        self.__info['mime_type'] = \
+            raw_data[u'mimeType']
+        
+        self.__info['labels'] = \
+            raw_data[u'labels']
+        
+        self.__info['id'] = \
+            raw_data[u'id']
+        
+        self.__info['last_modifying_user_name'] = \
+            raw_data[u'lastModifyingUserName']
+        
+        self.__info['writers_can_share'] = \
+            raw_data[u'writersCanShare']
 
-            self.__info['owner_names'] = \
-                raw_data[u'ownerNames']
-            
-            self.__info['editable'] = \
-                raw_data[u'editable']
-            
-            self.__info['user_permission'] = \
-                raw_data[u'userPermission']
-        except KeyError:
-            _logger.exception("Could not normalize with missing key.\nRAW:\n"
-                              "%s", pprint.pformat(raw_data))
-            raise
+        self.__info['owner_names'] = \
+            raw_data[u'ownerNames']
+        
+        self.__info['editable'] = \
+            raw_data[u'editable']
+        
+        self.__info['user_permission'] = \
+            raw_data[u'userPermission']
 
         self.__info['link'] = \
             raw_data.get(u'embedLink')