Merge pull request #23 from pnovotnak/feat/pnovotnak/py3-pep8-logging

lots of pep8 cleanup, py3 compatibility, and configurable verbosity

Author: Bart Spaans

kubefuse/cache.py

@@ -1,6 +1,9 @@
 import logging
 import time
 
+logger = logging.getLogger(__name__)
+
+
 class ExpiringCache(object):
     def __init__(self, expire_in_seconds):
         self._cache = {}
@@ -11,15 +14,15 @@ def set(self, key, value):
         t = time.time() + self.EXPIRE_IN_SECONDS
         self._cache[key] = value
         self._timestamps[key] = t
-        logging.info("Add key '%s' to cache (expires %d)" % (key, t))
+        logger.info("Add key '%s' to cache (expires %d)" % (key, t))
 
     def get(self, key):
         if key not in self._timestamps:
             return None
         now = time.time()
         expires_at = self._timestamps[key]
         if now < expires_at:
-            logging.info("Retrieved '%s' from cache" % key)
+            logger.info("Retrieved '%s' from cache" % key)
             return self._cache[key]
         self.delete(key)
         return None

kubefuse/client.py

@@ -5,8 +5,9 @@
 
 from . import cache
 
+
 class KubernetesClient(object):
-    def __init__(self, kubeconfig = None, cluster = None, context = None, user = None):
+    def __init__(self, kubeconfig=None, cluster=None, context=None, user=None):
         self._cache = cache.ExpiringCache(30)
         self.kubeconfig = kubeconfig
         self.cluster = cluster 
@@ -31,7 +32,8 @@ def _run_command(self, cmd):
     def _run_command_and_parse_yaml(self, cmd):
         return yaml.load(self._run_command(cmd))
 
-    def _namespace(self, ns):
+    @staticmethod
+    def _namespace(ns):
         return ['--namespace', ns] if ns != 'all' else ['--all-namespaces']
 
     def _load_from_cache_or_do(self, key, func):
@@ -49,7 +51,7 @@ def get_namespaces(self):
 
     def get_entities(self, ns, entity):
         key = "%s.%s" % (ns, entity)
-        cb = lambda: self._get_entities(ns,entity)
+        cb = lambda: self._get_entities(ns, entity)
         return self._load_from_cache_or_do(key, cb)
 
     def get_object_in_format(self, ns, entity_type, object, format):
@@ -89,13 +91,13 @@ def _get_namespaces(self):
         payload = self._run_command_and_parse_yaml('get ns -o yaml'.split())
         if payload is None or 'items' not in payload:
             return []
-        return [ item['metadata']['name'] for item in payload['items']]
+        return [item['metadata']['name'] for item in payload['items']]
 
     def _get_entities(self, ns, entity):
         payload = self._run_command_and_parse_yaml(['get', entity, '-o', 'yaml'] + self._namespace(ns))
         if payload is None or 'items' not in payload:
             return []
-        return [ item['metadata']['name'] for item in payload['items']]
+        return [item['metadata']['name'] for item in payload['items']]
 
     def _get_object_in_format(self, ns, entity_type, object, format):
         return self._run_command(['get', entity_type, object, '-o', format] + self._namespace(ns))

kubefuse/filesystem.py

@@ -1,23 +1,28 @@
-from stat import S_IFDIR, S_IFLNK, S_IFREG, S_IFIFO
+from stat import S_IFDIR, S_IFREG
 from time import time
 import logging
 import errno
 from fuse import FuseOSError
 from . import path 
 KubePath = path.KubePath
 
+logger = logging.getLogger(__name__)
+
+
 class KubeFileSystem(object):
     def __init__(self, client):
         self.client = client
         self.open_files = {}
         self.flushed = {}
 
-    def _stat_dir(self):
+    @staticmethod
+    def _stat_dir():
         return dict(st_mode=(S_IFDIR | 0o555), st_nlink=2,
                 st_size=0, st_ctime=time(), st_mtime=time(),
                 st_atime=time())
 
-    def _stat_file(self, client, path, size=None):
+    @staticmethod
+    def _stat_file(client, path, size=None):
         if size is None:
             size = len(path.do_action(client))
         ts = path.get_creation_date_for_action_file(client)
@@ -71,10 +76,10 @@ def persist(self, path, data, dry_run=False):
     def list_files(self, path):
         p = KubePath().parse_path(path)
         if not p.exists(self.client):
-            logging.info("path doesn't exist")
+            logger.info("path doesn't exist")
             raise FuseOSError(errno.ENOENT)
         if not p.is_dir():
-            logging.info("not a directory")
+            logger.info("not a directory")
             raise FuseOSError(errno.ENOTDIR)
         if p.object_id is not None: 
             if p.resource_type != 'pod':
@@ -85,14 +90,14 @@ def list_files(self, path):
             return self.client.get_entities(p.namespace, p.resource_type)
         if p.namespace is not None:
             return p.SUPPORTED_RESOURCE_TYPES
-        return self.client.get_namespaces() # + ['all']
+        return self.client.get_namespaces()  # + ['all']
 
     def getattr(self, path):
         p = KubePath().parse_path(path)
         if path in self.open_files:
             return self._stat_file(self.client, p, len(self.open_files[path]))
         if not p.exists(self.client):
-            logging.info("path doesn't exist")
+            logger.info("path '%s' doesn't exist" % path)
             raise FuseOSError(errno.ENOENT)
         if p.action is not None:
             return self._stat_file(self.client, p)

kubefuse/kubefuse.py

@@ -1,26 +1,24 @@
 #!/usr/bin/env python
 
 import logging
-import sys
-import os
-import errno
 import six
 import argparse
 import sys
 try:
     from fuse import FUSE, FuseOSError, Operations, LoggingMixIn
 except EnvironmentError:
-    print "It looks like the Fuse system library is missing."
-    print "Please install libfuse using your OS's package manager, or download OSXFUSE if you're on a Mac"
+    print("It looks like the Fuse system library is missing.")
+    print("Please install libfuse using your OS's package manager, or download OSXFUSE if you're on a Mac")
     sys.exit(1)
 
 
 from . import client
-from . import filesystem 
+from . import filesystem
+
 
 class KubeFuse(LoggingMixIn, Operations):
 
-    def __init__(self, mount, kubeconfig = None, cluster = None, context = None, user = None):
+    def __init__(self, mount, kubeconfig=None, cluster=None, context=None, user=None):
         self.client = client.KubernetesClient(kubeconfig, cluster, context, user)
         self.fs = filesystem.KubeFileSystem(self.client)
         self.fd = 0
@@ -58,23 +56,32 @@ def release(self, path, fh):
 
 def parse_args():
     parser = argparse.ArgumentParser(description='A file system view for Kubernetes')
-    parser.add_argument('mountpoint', metavar='MOUNTPOINT', type=str, 
-        help='The directory to mount on')
-    parser.add_argument('--kubeconfig', dest='kubeconfig', 
-        help='Path to the kubeconfig file')
-    parser.add_argument('--cluster', dest='cluster', 
-        help='The name of the kubeconfig cluster to use')
-    parser.add_argument('--context', dest='context', 
-        help='The name of the kubeconfig context to use')
-    parser.add_argument('--user', dest='user', 
-        help='The name of the kubeconfig user to use')
+    parser.add_argument('mountpoint', metavar='MOUNTPOINT', type=str,
+                        help='The directory to mount on')
+    parser.add_argument('--kubeconfig', dest='kubeconfig',
+                        help='Path to the kubeconfig file')
+    parser.add_argument('--cluster', dest='cluster',
+                        help='The name of the kubeconfig cluster to use')
+    parser.add_argument('--context', dest='context',
+                        help='The name of the kubeconfig context to use')
+    parser.add_argument('--user', dest='user',
+                        help='The name of the kubeconfig user to use')
+    parser.add_argument('--verbose', '-v', action='count', dest='verbosity',
+                        default=0, help='Verbosity of program output')
     return parser.parse_args()
 
 def main():
     args = parse_args()
-    logging.basicConfig(level=logging.INFO)
-    fuse = FUSE(KubeFuse(args.mountpoint, args.kubeconfig, args.cluster, args.context),
-                    args.mountpoint, foreground=True)
+    if args.verbosity == 0:
+        logging.basicConfig(level=logging.WARNING)
+    elif args.verbosity == 1:
+        logging.basicConfig(level=logging.INFO)
+    elif args.verbosity == 2:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=0)
+    FUSE(KubeFuse(args.mountpoint, args.kubeconfig, args.cluster, args.context),
+         args.mountpoint, foreground=True)
 
 if __name__ == '__main__':
     main()

kubefuse/path.py

@@ -1,8 +1,9 @@
 import json
 from datetime import datetime
 
+
 class KubePath(object):
-    def __init__(self, namespace = None, resource_type = None, object_id = None, action = None):
+    def __init__(self, namespace=None, resource_type=None, object_id=None, action=None):
         self.namespace = namespace 
         self.resource_type = resource_type
         self.object_id = object_id
@@ -33,7 +34,8 @@ def __init__(self, namespace = None, resource_type = None, object_id = None, act
         self.SUPPORTED_POD_ACTIONS = ['logs'] + self.SUPPORTED_ACTIONS
 
     def parse_path(self, path):
-        if path == '/': return self
+        if path == '/':
+            return self
         parts = path[1:].split("/")
         self.namespace = parts[0] if len(parts) > 0 else None
         self.resource_type = parts[1] if len(parts) > 1 else None