path: root/scripts/g-octave

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

"""
    g-octave
    ~~~~~~~~
    
    Main script of g-Octave.
    
    :copyright: (c) 2009-2010 by Rafael Goncalves Martins
    :license: GPL-2, see LICENSE for more details.
"""

from __future__ import print_function

has_fetch = True

__issue_tracker = 'Mail to: rafael@rafaelmartins.eng.br'

import sys

# This block ensures that ^C interrupts are handled quietly.
# Code snippet from Portage
try:
    import signal

    def exithandler(signum,frame):
        signal.signal(signal.SIGINT, signal.SIG_IGN)
        signal.signal(signal.SIGTERM, signal.SIG_IGN)
        sys.exit(1)

    signal.signal(signal.SIGINT, exithandler)
    signal.signal(signal.SIGTERM, exithandler)

except KeyboardInterrupt:
    sys.exit(1)


import getpass
import os
import optparse
import portage
import subprocess

out = portage.output.EOutput()

current_dir = os.path.dirname(os.path.realpath(__file__))
if os.path.exists(os.path.join(current_dir, '..', 'g_octave')):
    sys.path.insert(0, os.path.join(current_dir, '..'))

from g_octave.log import Log
log = Log('g-octave')

log.info('Initializing...')
import g_octave

def main():

    parser = optparse.OptionParser(
        usage = '%prog [options] <package_name | package_name-version>',
        version = '%prog ' + g_octave.__version__,
        description = g_octave.__description__
    )
    
    parser.add_option(
        '-l', '--list',
        action = 'store_true',
        dest = 'list',
        default = False,
        help = 'show a list of packages available to install and exit'
    )
    
    parser.add_option(
        '-i', '--info',
        action = 'store_true',
        dest = 'info',
        default = False,
        help = 'show a description of the required package and exit'
    )
    
    parser.add_option(
        '-p', '--pretend',
        action = 'store_true',
        dest = 'pretend',
        default = False,
        help = 'don\'t (un)merge packages, only create ebuilds and solve the dependencies'
    )
    
    parser.add_option(
        '-a', '--ask',
        action = 'store_true',
        dest = 'ask',
        default = False,
        help = 'ask to confirmation before perform (un)merges'
    )
    
    parser.add_option(
        '-v', '--verbose',
        action = 'store_true',
        dest = 'verbose',
        default = False,
        help = 'Portage makes a lot of noise.'
    )
    
    parser.add_option(
        '-u', '--update',
        action = 'store_true',
        dest = 'update',
        default = False,
        help = 'try to update a package or all the installed packages'
    )
    
    parser.add_option(
        '-C', '--unmerge',
        action = 'store_true',
        dest = 'unmerge',
        default = False,
        help = 'try to unmerge a package instead of merge'
    )
    
    parser.add_option(
        '-f', '--force',
        action = 'store_true',
        dest = 'force',
        default = False,
        help = 'forces the recreation of the ebuilds'
    )
    
    parser.add_option(
        '--force-all',
        action = 'store_true',
        dest = 'force_all',
        default = False,
        help = 'forces the recreation of the overlay and of the ebuilds'
    )
    
    parser.add_option(
        '--no-colors',
        action = 'store_false',
        dest = 'colors',
        default = True,
        help = 'don\'t use colors on the CLI'
    )
    
    parser.add_option(
        '--sync',
        action = 'store_true',
        dest = 'sync',
        default = False,
        help = 'search for updates of the package database, patches and auxiliary files'
    )
    
    parser.add_option(
        '--config',
        action = 'store_true',
        dest = 'config',
        default = False,
        help = 'return a value from the configuration file (/etc/g-octave.cfg)'
    )
    
    options, args = parser.parse_args()
    
    if not options.colors:
        portage.output.nocolor()
    
    from g_octave.config import Config
    from g_octave.fetch import need_update, check_updates, download_files, check_db_cache
    
    conf_prefetch = Config(True)
    
    if options.config:
        try:
            log.info('Returning configuration data.')
            print(conf_prefetch.__getattr__(args[0]))
        except:
            log.error('Invalid configuration key: %s' % args[0])
            return os.EX_DATAERR
        return os.EX_OK
    
    from g_octave.package_manager import Portage, Pkgcore, Paludis
    
    if conf_prefetch.package_manager == 'portage':
        log.info('Your package manager is: Portage')
        pkg_manager = Portage(options.ask, options.verbose, options.pretend, not options.colors)
    elif conf_prefetch.package_manager == 'pkgcore':
        log.info('Your package manager is: Pkgcore')
        pkg_manager = Pkgcore(options.ask, options.verbose, options.pretend, not options.colors)
    elif conf_prefetch.package_manager == 'paludis':
        log.info('Your package manager is: Paludis')
        pkg_manager = Paludis(options.ask, options.verbose, options.pretend, not options.colors)
    else:
        log.error('Invalid package manager: %s' % conf_prefetch.package_manager)
        out.eerror('Invalid package manager: %s' % conf_prefetch.package_manager)
        return os.EX_CONFIG
    
    # checking if the package manager is installed
    if not pkg_manager.is_installed():
        log.error('Package manager not installed: %s' % conf_prefetch.package_manager)
        out.eerror('Package manager not installed: %s' % conf_prefetch.package_manager)
        return os.EX_CONFIG
    
    # checking if the current user is allowed to run g-octave
    current_user = getpass.getuser()
    if current_user not in pkg_manager.allowed_users():
        log.error(
            'The current user (%s) can\'t run the current selected '
            'package manager (%s)' % (current_user, conf_prefetch.package_manager)
        )
        out.eerror(
            'The current user (%s) can\'t run the current selected '
            'package manager (%s)' % (current_user, conf_prefetch.package_manager)
        )
        return os.EX_NOPERM
    
    # checking if our overlay is correctly added to PORTDIR_OVERLAY
    if not pkg_manager.check_overlay(conf_prefetch.overlay, out):
        log.error('Overlay not properly configured.')
        return os.EX_CONFIG
    
    if has_fetch:
        log.info('You can fetch package databases.')
        
        # checking if we have a package database
        if need_update() and not options.sync:
            log.error('No package database found.')
            out.eerror('Please run "g-octave --sync" to download a package database!')
            return os.EX_USAGE
        
        if options.sync:
            
            log.info('Searching updates ...')
            out.einfo('Searching updates ...')
            
            files = check_updates()
            
            if len(files) > 0:
                
                log.info('Updates are available. Downloading ...')
                out.einfo('Updates are available. Downloading ...')
                print()
                download_files(files)
                print()
                log.info('Package database update done.')
                out.einfo('Done.')
            else:
                log.info('No updates available.')
                out.einfo('No updates available.')
            
            return os.EX_OK
    else:
        log.info('You can\'t fetch package databases.')
        if options.sync:
            log.error('You can\'t fetch package databases.')
            out.eerror('"--sync" not available, please install g-octave-9999 if you want this.')
            return os.EX_USAGE
    
    check_db_cache()
    
    conf = Config()
    
    from g_octave.description import Description
    from g_octave.description_tree import DescriptionTree
    from g_octave.ebuild import Ebuild, EbuildException
    from g_octave.overlay import create_overlay

    if options.list:
        log.info('Listing available packages.')
        tree = DescriptionTree()
        print(portage.output.blue('Available packages:\n'))
        for category in tree.pkg_list:
            print(portage.output.white('%s:') % category)
            for pkg in tree.pkg_list[category]:
                print('\t%s-%s' % (pkg['name'], pkg['version']))
            print()
        return os.EX_OK
    if options.update:
        pass
    elif len(args) == 0:
        log.error('You need provide an argument.')
        out.eerror('You need provide an argument.')
        return os.EX_USAGE
    elif len(args) > 1:
        log.error('g-octave can install only one package at once.')
        out.eerror('At this moment g-octave can install only one package at once')
        return os.EX_USAGE
    
    # if we're alive yet, we have a package to install! :D
    
    create_overlay(options.force_all)
    
    if len(args) > 0:
        log.info('Processing a package: %s' % args[0])
        try:
            ebuild = Ebuild(args[0], options.force or options.force_all, pkg_manager=pkg_manager)
        except EbuildException:
            log.error('Package not found: %s' % args[0])
            out.eerror('Package not found: %s' % args[0])
            return os.EX_DATAERR
        
        if options.info:
            log.info('Returning info about the package.')
            pkg = ebuild.description()
            print(portage.output.blue('Package:'), portage.output.white(str(pkg.name)))
            print(portage.output.blue('Version:'), portage.output.white(str(pkg.version)))
            print(portage.output.blue('Date:'), portage.output.white(str(pkg.date)))
            print(portage.output.blue('Maintainer:'), portage.output.white(str(pkg.maintainer)))
            print(portage.output.blue('Description:'), portage.output.white(str(pkg.description)))
            print(portage.output.blue('Categories:'), portage.output.white(str(pkg.categories)))
            print(portage.output.blue('License:'), portage.output.white(str(pkg.license)))
            print(portage.output.blue('Url:'), portage.output.white(str(pkg.url)))
            return os.EX_OK
        
        atom, catpkg = ebuild.create()
    
    if options.unmerge:
        log.info('Calling the package manager to uninstall the package.')
        ret = pkg_manager.uninstall_package(atom, catpkg)
    elif options.update:
        if len(args) > 0:
            log.info('Calling the package manager to update the package.')
            ret = pkg_manager.update_package(atom, catpkg)
        else:
            log.info('Calling the package manager to update all the installed packages.')
            ret = pkg_manager.update_package()
    else:
        log.info('Calling the package manager to install the package.')
        ret = pkg_manager.install_package(atom, catpkg)
    
    if ret != os.EX_OK:
        log.error('"%s" returned an error.' % conf.package_manager)
        out.eerror('"%s" returned an error.' % conf.package_manager)
        sys.exit(ret)
    
    if options.unmerge and len(pkg_manager.post_uninstall) > 0:
        log.info(' '.join(pkg_manager.post_uninstall))
        print()
        for i in pkg_manager.post_uninstall:
            out.einfo(i)
    
    log.info('Finishing g-octave... all OK!')
    return os.EX_OK


if __name__ == '__main__':
    
    from g_octave.exception import *
    
    return_code = os.EX_OK
    
    try:
        return_code = main()
    except ConfigException as error:
        log.error('Config class error - %s' % error)
        out.eerror('Config class error - %s' % error)
        return_code = os.EX_CONFIG
    except DescriptionException as error:
        log.error('Description class error - %s' % error)
        out.eerror('Description class error - %s' % error)
        return_code = os.EX_SOFTWARE
    except DescriptionTreeException as error:
        log.error('DescriptionTree class error - %s' % error)
        out.eerror('DescriptionTree class error - %s' % error)
        return_code = os.EX_SOFTWARE
    except EbuildException as error:
        log.error('Ebuild class error - %s' % error)
        out.eerror('Ebuild class error - %s' % error)
        return_code = os.EX_SOFTWARE
    except FetchException as error:
        log.error('Fetch module error - %s' % error)
        out.eerror('Fetch module error - %s' % error)
        return_code = os.EX_SOFTWARE
    except OSError as error:
        log.error('Operating System error - %s' % error)
        out.eerror('Operating System error - %s' % error)
        out.eerror('Try run "g-octave" as root.')
        return_code = os.EX_OSERR
    except IOError as error:
        log.error('I/O error - %s' % error)
        out.eerror('I/O error - %s' % error)
        out.eerror('Try run "g-octave" as root.')
        return_code = os.EX_IOERR
    except KeyError as error:
        log.error('Key error - %s' % error)
        out.eerror('Key error - %s' % error)
        out.eerror('Probably you have more than one overlay configured to use with g-octave')
        out.eerror('Try remove the oldest and maintain only the overlay actually in use.')
        return_code = os.EX_SOFTWARE
    except Exception as error:
        log.error('Unknown error - %s' % error)
        out.eerror('Unknown error - %s' % error)
        return_code = os.EX_SOFTWARE
    
    if return_code not in [os.EX_OK, os.EX_CONFIG, os.EX_USAGE, os.EX_DATAERR, os.EX_NOPERM]:
        out.einfo('If you fell that this is a bug, please report to us.')
        out.einfo(__issue_tracker)
    
    sys.exit(return_code)