added getent.py

HariSekhon · HariSekhon · commit ac983e18515f · 2016-11-20T15:35:23.000Z
diff --git a/getent.py b/getent.py
@@ -0,0 +1,286 @@
+#!/usr/bin/env python
+#  vim:ts=4:sts=4:sw=4:et
+#
+#  Author: Hari Sekhon
+#  Date: 2016-11-20 12:35:49 +0000 (Sun, 20 Nov 2016)
+#
+#  https://github.com/harisekhon/pytools
+#
+#  License: see accompanying Hari Sekhon LICENSE file
+#
+#  If you're using my code you're welcome to connect with me on LinkedIn
+#  and optionally send me feedback to help steer this or other code I publish
+#
+#  https://www.linkedin.com/in/harisekhon
+#
+
+"""
+
+Tool to abstract and normalize Mac's user/group/host system resolver calls to the same format
+as the more standard Linux getent for simplified scripting between the two platforms
+
+Will detect if the platform is Mac and call the necessary commands and translate.
+
+For Linux it becomes a straight pass through to getent.
+
+Supported getent commands: passwd, group
+
+Tested on Linux and Mac OSX 10.10.x (Yosemite)
+
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+#from __future__ import unicode_literals
+
+import os
+import platform
+import subprocess
+import sys
+import time
+import traceback
+try:
+    import psutil
+except ImportError:
+    print(traceback.format_exc(), end='')
+    sys.exit(4)
+srcdir = os.path.abspath(os.path.dirname(__file__))
+libdir = os.path.join(srcdir, 'pylib')
+sys.path.append(libdir)
+try:
+    # pylint: disable=wrong-import-position
+    from harisekhon.utils import log, die, qquit, plural, which, isList, isInt
+    from harisekhon import CLI
+except ImportError as _:
+    print('module import failed: %s' % _, file=sys.stderr)
+    print("Did you remember to build the project by running 'make'?", file=sys.stderr)
+    print("Alternatively perhaps you tried to copy this program out without it's adjacent libraries?", file=sys.stderr)
+    sys.exit(4)
+
+__author__ = 'Hari Sekhon'
+__version__ = '0.1'
+
+
+class Getent(CLI):
+
+    def __init__(self):
+        # Python 2.x
+        super(Getent, self).__init__()
+        # Python 3.x
+        # super().__init__()
+        # special case to make all following args belong to the passed in command and not to this program
+        #self._CLI__parser.disable_interspersed_args()
+        self._CLI__parser.set_usage('{prog} [options] <command> <args> ...'.format(prog=self._prog))
+
+    def timeout_handler(self, signum, frame): # pylint: disable=unused-argument
+        for child in psutil.Process().children():
+            child.kill()
+        time.sleep(1)
+        qquit('UNKNOWN', 'self timed out after %d second%s' % (self.timeout, plural(self.timeout)))
+
+    def run(self):
+        if not self.args:
+            self.usage()
+        command = self.args[0]
+        if len(self.args) > 1:
+            args = self.args[1:]
+        else:
+            args = []
+        args_string = ' '.join(self.args[1:])
+        operating_system = platform.system()
+        if operating_system == 'Darwin':
+            log.info('detected system as Mac')
+            log.info('calling mac_getent_%s(%s)', command, args_string)
+            (formatted_output, returncode) = self.mac_getent(command, args)
+            if formatted_output:
+                print(formatted_output)
+            sys.exit(returncode)
+        elif operating_system == 'Linux':
+            log.info('detected system as Linux')
+            log.info('calling %s %s', command, args_string)
+            sys.exit(subprocess.call(command, args, shell=False))
+        else:
+            die("operating system '{operating_system}' is not one of the supported Linux or Darwin (Mac)"\
+                .format(operating_system=operating_system))
+
+    def mac_getent(self, command, args):
+#        if command == 'passwd':
+#            (output, returncode) = self.cmd(command, args)
+#            formatted_output = self.mac_getent_passwd(args)
+#        elif command == 'group':
+#            (output, returncode) = self.cmd(command, args)
+#            formatted_output = self.mac_getent_group(output)
+#        elif command == 'host':
+#            (output, returncode) = self.cmd(command, args)
+#            formatted_output = self.mac_getent_host(output)
+        if command in ('passwd', 'group'): #, 'host'):
+            # might be too clever to dynamically determine the method to reduce code dup
+            (formatted_output, returncode) = getattr(self, 'mac_getent_{command}'.format(command=command))(args)
+        else:
+            die("unsupported getent command '{0}', must be one of: passwd, group, host".format(command))
+        return (formatted_output, returncode)
+
+    def mac_getent_passwd(self, args):
+        arg = self.mac_get_arg(args)
+        final_returncode = 0
+        final_output = ""
+        if arg:
+            (final_output, final_returncode) = self.mac_getent_passwd_user(arg)
+        else:
+            users = [user for user in
+                     subprocess.Popen('dscl . -list /Users'.split(),
+                                      stdout=subprocess.PIPE).stdout.read().split('\n')
+                     if user]
+            log.info('found users: %s', users)
+            for user in users:
+                (formatted_output, returncode) = self.mac_getent_passwd_user(user)
+                if formatted_output:
+                    final_output += formatted_output + '\n'
+                if returncode > final_returncode:
+                    final_returncode = returncode
+            final_output = final_output.rstrip('\n')
+            # reorder output by UID to be similar to what you'd see on Linux
+            lines = final_output.split('\n')
+            final_output = '\n'.join(sorted(lines, cmp=lambda x, y: cmp(int(x.split(':')[2]), int(y.split(':')[2]))))
+        return (final_output, final_returncode)
+
+    def mac_getent_passwd_user(self, user):
+        log.info('mac_getent_passwd_user(%s)', user)
+        command = 'dscl . -read /Users/{user}'.format(user=user)
+        (output, returncode) = self.cmd(command)
+        user = password = uid = gid = name = homedir = shell = ''
+        #log.info('parsing output for passwd conversion')
+        for line in output.split('\n'):
+            tokens = line.split()
+            if len(tokens) < 2:
+                continue
+            field = tokens[0]
+            value = tokens[1]
+            if field == 'RecordName:':
+                user = value
+            elif field == 'Password:':
+                password = value
+            elif field == 'UniqueID:':
+                uid = value
+            elif field == 'PrimaryGroupID:':
+                gid = value
+            elif field == 'RealName:':
+                name = value
+            elif field == 'NFSHomeDirectory:':
+                homedir = value
+            elif field == 'UserShell:':
+                shell = value
+        if not user:
+            return('', returncode)
+        getent_record = '{user}:{password}:{uid}:{gid}:{name}:{homedir}:{shell}'.format\
+                        (user=user, password=password, uid=uid, gid=gid, name=name, homedir=homedir, shell=shell)
+        if not isInt(uid, allow_negative=True):
+            die("parsing error: UID '{uid}' is not numeric in record {record}!".format(uid=uid, record=getent_record))
+        if not isInt(gid, allow_negative=True):
+            die("parsing error: GID '{gid}' is not numeric in record {record}!".format(gid=gid, record=getent_record))
+        return (getent_record, returncode)
+
+    def mac_getent_group(self, args):
+        arg = self.mac_get_arg(args)
+        final_returncode = 0
+        final_output = ""
+        if arg:
+            (final_output, final_returncode) = self.mac_getent_group_name(arg)
+        else:
+            groups = [group for group in
+                      subprocess.Popen('dscl . -list /Groups'.split(),
+                                       stdout=subprocess.PIPE).stdout.read().split('\n')
+                      if group]
+            log.info('found groups: %s', groups)
+            for group in groups:
+                (formatted_output, returncode) = self.mac_getent_group_name(group)
+                if formatted_output:
+                    final_output += formatted_output + '\n'
+                if returncode > final_returncode:
+                    final_returncode = returncode
+            final_output = final_output.rstrip('\n')
+            # reorder output by GID to be similar to what you'd see on Linux
+            lines = final_output.split('\n')
+            final_output = '\n'.join(sorted(lines, cmp=lambda x, y: cmp(int(x.split(':')[0]), int(y.split(':')[0]))))
+        return (final_output, final_returncode)
+
+    def mac_getent_group_name(self, group):
+        log.info('mac_getent_group_name(%s)', group)
+        command = 'dscl . -read /Groups/{group}'.format(group=group)
+        (output, returncode) = self.cmd(command)
+        gid = password = name = members = ''
+        #log.info('parsing output for group conversion')
+        output = output.split('\n')
+        for index, line in enumerate(output):
+            tokens = line.split()
+            if len(tokens) < 1:
+                continue
+            field = tokens[0]
+            if len(tokens) < 2:
+                value = ''
+            else:
+                value = tokens[1]
+            if field == 'PrimaryGroupID:':
+                gid = value
+            elif field == 'Password:':
+                password = value
+            elif field == 'RealName:':
+                name = value
+                if not value and len(output) > index + 1 and output[index+1].startswith(' '):
+                    name = output[index+1].strip()
+            elif not name and field == 'RecordName:':
+                name = value
+            elif field == 'GroupMembership:':
+                members = ','.join(tokens[1:])
+        if not gid:
+            return('', returncode)
+        getent_record = '{gid}:{password}:{name}:{members}'.format\
+                        (gid=gid, password=password, name=name, members=members)
+        if not isInt(gid, allow_negative=True):
+            die("parsing error: GID '{gid}' is not numeric in record {record}!".format(gid=gid, record=getent_record))
+        return (getent_record, returncode)
+
+#    TODO: dscacheutil is much too slow to be used as a replacement for doing `host <fqdn>`, figure out faster way
+#    dscacheutil -q host -a name <fqdn>
+#    def mac_getent_host(self, args):
+#        arg = self.mac_get_arg(args)
+#        (output, returncode) = self.cmd(command)
+
+    @staticmethod
+    def mac_get_arg(args):
+        if not args:
+            return ''
+        if not isList(args):
+            die("non-list '{args}' passed to mac_getent_passwd()".format(args=args))
+        if len(args) > 1:
+            die('only one arg is supported on Mac at this time')
+        arg = args[0]
+        return arg
+
+    # TODO: make a slightly more generic version similar to Perl lib and put in PyLib
+    @staticmethod
+    def cmd(command):
+        log.debug('command: %s', command)
+        command_binary = command.split()[0]
+        if not which(command_binary):
+            die("command '{command}' not found in $PATH".format(command=command_binary))
+        try:
+            process = subprocess.Popen(command.split(),
+                                       stdin=subprocess.PIPE,
+                                       stdout=subprocess.PIPE,
+                                       stderr=subprocess.STDOUT)
+            (stdout, _) = process.communicate()
+            process.wait()
+            log.debug('returncode: %s', process.returncode)
+            log.debug('output: %s\n', stdout)
+            return(stdout, process.returncode)
+        except subprocess.CalledProcessError as _:
+            log.debug('CalledProcessError Exception!')
+            log.debug('returncode: %s', _.returncode)
+            log.debug('output: %s\n', _.output)
+            return(_.output, _.returncode)
+
+
+if __name__ == '__main__':
+    Getent().main()
