moulinette/yunohost

#!/usr/bin/env python
# -*- coding: utf-8 -*-

__credits__ = """
    Copyright (C) 2012 YunoHost

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program; if not, see http://www.gnu.org/licenses
    """
__author__  = 'Kload <kload@kload.fr>'
__version__ = '2.0 beta1'

import os
import sys
import argparse
import gettext
import json
if not __debug__:
    import traceback

gettext.install('YunoHost')

try:
    sys.path.append('lib')
    from yunohost import YunoHostError, YunoHostLDAP, str_to_func, colorize, pretty_print_dict
except ImportError:
    sys.stderr.write('Require YunoHost lib')
    sys.exit(1)

"""
Category/actions/arguments dictionnary


Except for general_arguments, this dictionary contains 3 levels
as in this sample command line :

    yunohost   monitor    info    --cpu --ram
       ^          ^         ^          ^
    (script) | category | action | parameters


Above example will lead to the function 'monitor_info(args)'
in the file 'lib/yunohost_monitor.py' with 'cpu' and 'ram'
stored in args dictionnary.

Usage:
    You can add a category at the first level, action at the second one,
    and arguments at the third one.
    If the action need LDAP connexion, don't forget to add 'ldap' : True
    to the action parameters.

Documentation:
    You can see all arguments settings at the argparse documentation:
    http://docs.python.org/dev/library/argparse.html
    #argparse.ArgumentParser.add_argument

    Don't forget to turn them as a dictionnary ('setting' : 'value')

"""
action_dict = { 
    #############################
    #       General args        #
    #############################
    'general_arguments' : {
        '-v' : {
            'full'      : '--version',
            'help'      : _("Display %(prog)s version"),
            'action'    : 'version',
            'version'   : '%(prog)s ' + __version__,
        },
    },
    #############################
    #           User            #
    #############################
    'user' : {
        'category_help' : _("Manage users"),
        'actions'       : {
            ### user_list()
            'list' : {
                'action_help'   : _("List users"),
                'ldap'          : True,
                'arguments'     : {
                   '--fields' : {
                        'help'      : _("Fields to fetch"),
                        'nargs'     : '+',
                   },
                   '-f' : {
                        'full'      : '--filter',
                        'help'      : _("LDAP filter used to search"),
                   },
                   '-l' : {
                        'full'      : '--limit',
                        'help'      : _("Maximum number of users fetched"), 
                   },
                   '-o' : {
                        'full'      : '--offset',
                        'help'      : _("Starting number for user fetching"), 
                   },
                }
            },
            ### user_create()
            'create' : {
                'action_help'   : _("Create user"),
                'ldap'          : True,
                'arguments'     : {
                    '-u' : {
                        'full'      : '--username',
                        'help'      : _("Must be unique"),
                    },
                    '-f' : {
                        'full'      : '--firstname',
                    },
                    '-l' : {
                        'full'      : '--lastname',
                    },
                    '-m' : {
                        'full'      : '--mail',
                        'help'      : _("Main mail address, must be unique"),
                    },
                    '-p' : {
                        'full'      : '--password',
                    }, 
                }
            },
            ### user_delete()
            'delete' : {
                'action_help'   : _("Delete user"),
                'ldap'          : True,
                'arguments'     : {
                    'users' : {
                        'help'      : _("Username of users to delete"),
                        'nargs'     : '+',
                    },
                }
            },
            ### user_update()
            'update' : {
                'action_help'   : _("Update user informations"),
                'ldap'          : True,
                'arguments'     : {
                    'user' : {
                        'help'      : _("Username of user to update"),
                    },
                    '-f' : {
                        'full'      : '--firstname',
                    },
                    '-l' : {
                        'full'      : '--lastname',
                    },
                    '-m' : {
                        'full'      : '--mail',
                    },
                    '-cp' : {
                        'full'      : '--change-password',
                        'help'      : _("New password to set"),
                        'metavar'   : 'PASSWORD',
                    },
                    '--add-mailforward' : {
                        'help'      : _("Mailforward addresses to add"),
                        'nargs'     : '+',
                        'metavar'   : 'MAIL',
                    },
                    '--remove-mailforward' : {
                        'help'      : _("Mailforward addresses to remove"),
                        'nargs'     : '+',
                        'metavar'   : 'MAIL',
                    },
                    '-add-mailalias' : {
                        'help'      : _("Mail aliases to add"),
                        'nargs'     : '+',
                        'metavar'   : 'MAIL',
                    },
                    '-remove-mailalias' : {
                        'help'      : _("Mail aliases to remove"),
                        'nargs'     : '+',
                        'metavar'   : 'MAIL',
                    },
                }
            },
            ### user_info()
            'info'      : {
                'action_help'   : _("Get user informations"),
                'ldap'          : True,
                'arguments'     : {
                    'user' : {
                        'nargs'     : '?',
                    }, 
                    '-m' : {
                        'full'      : '--mail',
                    }, 
                    '-cn' : {
                        'full'      : '--fullname',
                    }, 
                }
            },
        }
    },
    #############################
    #          Domain           #
    #############################
    'domain' : {
        'category_help' : _("Manage domains"),
        'actions'       : {
            ### domain_list()
            'list' : {
                'action_help'   : _("List domains"),
                'ldap'          : True,
                'arguments'     : {
                    '-f' : {
                        'full'      : '--filter',
                        'help'      : _("LDAP filter used to search"),
                    },
                    '-l' : {
                        'full'      : '--limit',
                        'help'      : _("Maximum number of users fetched"), 
                    },
                    '-o' : {
                        'full'      : '--offset',
                        'help'      : _("Starting number for user fetching"), 
                   },
                }
            },
            ### domain_create()
            'create' : {
                'action_help'   : _("Create a custom domain"),
                'ldap'          : True,
                'arguments'     : {
                    'domain name' : {
                        'help'      : _("Domain name to create"),
                    }
                }
            },
            ### domain_delete()
            'delete' : {
                'action_help'   : _("Delete domains"),
                'ldap'          : True,
                'arguments'     : {
                    'domains' : {
                        'help'      : _("Domain names to delete"),
                        'nargs'     : '+',
                    },
                }
            },
            ### domain_info()
            'info' : {
                'action_help'   : _("Get domain informations"),
                'ldap'          : True,
                'arguments'     : {
                    'domain-name' : {}
                }
            },
            ### domain_renewcert()
            'renewcert' : {
                'action_help'   : _("Renew domain certificate"),
                'ldap'          : True,
                'arguments'     : {
                    'domain-name' : {}
                }
            },
        }
    },
    'app' : {
        'category_help' : _("Manage apps"),
        'actions'       : {}
    },
    'monitor' : {
        'category_help' : _("Monitoring functions"),
        'actions'       : {}
    },
    'tools' : {
        'category_help' : _("Specific tools"),
        'actions'       : {}
    }
}

def parse_dict(action_dict):
    """
    Turn action dictionnary to parser, subparsers and arguments
    
    Keyword arguments:
        action_dict -- Multi-level dictionnary of categories/actions/arguments list
    
    Returns: 
        Namespace of args

    """
    # Connection required
    ldap = False

    # Intialize parsers
    parsers = subparsers_category = subparsers_action = {}
    parsers['general'] = argparse.ArgumentParser()
    subparsers = parsers['general'].add_subparsers()

    # Add general arguments
    for arg_name, arg_params in action_dict['general_arguments'].items():
        if arg_params['full']:
            arg_fullname = arg_params['full']
            del arg_params['full']
            parsers['general'].add_argument(arg_name, arg_fullname, **arg_params)
        else:
            parsers['general'].add_argument(arg_name, **arg_params)

    del action_dict['general_arguments'] 

    # Split categories into subparsers
    for category, category_params in action_dict.items():
        if 'category_help' not in category_params: category_params['category_help'] = ''
        subparsers_category[category] = subparsers.add_parser(category, help=category_params['category_help'])
        subparsers_action[category] = subparsers_category[category].add_subparsers()
        # Split actions
        if 'actions' in category_params:
            for action, action_params in category_params['actions'].items():
                # Service settings
                if 'ldap' in action_params: ldap = action_params['ldap']
                if 'action_help' not in action_params: action_params['action_help'] = ''
                parsers[category + '_' + action] = subparsers_action[category].add_parser(action, help=action_params['action_help'])
                # Set the action s related function
                parsers[category + '_' + action].set_defaults(
                    func=str_to_func('yunohost_' + category + '.' 
                                     + category + '_' + action)) 
                # Add arguments
                if 'arguments' in action_params:
                    for arg_name, arg_params in action_params['arguments'].items():
                        if 'full' in arg_params:
                            arg_fullname = arg_params['full']
                            del arg_params['full']
                            parsers[category + '_' + action].add_argument(arg_name, arg_fullname, **arg_params)
                        else:
                            parsers[category + '_' + action].add_argument(arg_name, **arg_params)

    args = parsers['general'].parse_args()
    return { 'ldap' : ldap, 'args' : args }

def main():
    """ 
    Main instructions 
   
    Parse the action_dict and execute the action-specific function,
    then print json or pretty result if executed in a tty :)

    Returns:
        int -- 0 or error code
    
    """ 
    action = parse_dict(action_dict)

    # Connect to LDAP if the action is requiring it
    if action['ldap']:
        yldap = YunoHostLDAP()

    try:
        if action['ldap']:
            result = action['args'].func(vars(action['args']), yldap)
        else:
            result = action['args'].func(vars(action['args']))
    #except TypeError:
        #print(_("Not (yet) implemented function"))
        #return 1
    except YunoHostError, error:
        if not __debug__ :
            traceback.print_exc()
        if os.isatty(1):
            print('\n' + colorize(_("Error: "), 'red') + error.message)
        else:
            print(json.dumps({ 'error' : error.message }))
        return error.code
    else: 
        if os.isatty(1):
            pretty_print_dict(result)
        else:
            print(json.dumps(result))
    finally:
        if action['ldap']:
            yldap.disconnect()
    
    return 0        

if __name__ == '__main__':
    sys.exit(main())