path: root/src/java-config

#!/usr/bin/python -E
# -*- coding: UTF-8 -*-

# Copyright 2004-2005 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: $

from java_config import __version__
from java_config.OutputFormatter import OutputFormatter
from java_config.EnvironmentManager import EnvironmentManager
from java_config.Errors import *

import os
import sys
from commands import getoutput

from optparse import OptionParser, make_option


def version(option, opt, value, parser):
    printer._print("%H%BJava Configuration Utility %GVersion " + str(__version__))
    raise SystemExit()

def nocolor(option, opt, value, parser):
    printer.setColorOutputStatus(False)

def java(option, opt, value, parser):
    try:
        printer._print(manager.get_active_vm().find_exec('java'))
    except PermissionError:
        fatalError("The java executable was not found in the Java path")
    except InvalidVMError:
        fatalError("The active vm could not be found")

def javac(option, opt, value, parser):
    try:
        printer._print(manager.get_active_vm().find_exec('javac'))
    except PermissionError:
        fatalError("The javac executable was not found in the Java path")
    except InvalidVMError:
        fatalError("The active vm could not be found")

def jar(option, opt, value, parser):
    try:
        printer._print(manager.get_active_vm().find_exec('jar'))
    except PermissionError:
        fatalError("The jar executable was not found in the Java path")
    except InvalidVMError:
        fatalError("The active vm could not be found")

def jdk_home(option, opt, value, parser):
    try:
        #printer._print(manager.get_active_vm().query('JDK_HOME'))
        printer._print(manager.get_active_vm().query('JAVA_HOME'))
    except EnvironmentUndefinedError:
        print
    except InvalidVMError:
        fatalError("The active vm could not be found")

def jre_home(option, opt, value, parser):
    try:
        #printer._print(manager.get_active_vm().query('JRE_HOME'))
        printer._print(manager.get_active_vm().query('JAVA_HOME'))
    except EnvironmentUndefinedError:
        print
    except InvalidVMError:
        fatalError("The active vm could not be found")

def runtime(option, opt, value, parser):
    try:
        printer._print(manager.get_active_vm().query('BOOTCLASSPATH'))
    except EnvironmentUndefinedError:
        print
    except InvalidVMError:
        fatalError("The active vm could not be found")


def show_active_vm(option, opt, value, parser):
    try:
        printer._print(manager.get_active_vm().name())
    except InvalidVMError:
        fatalError("The active vm could not be found")

def java_version(option, opt, value, parser):
    try:
        printer._print(getoutput('%s -version' % manager.get_active_vm().find_exec('java')))
    except PermissionError:
        fatalError("The java executable was not found in the Java path")
    except InvalidVMError:
        fatalError("The active vm could not be found")

def classpath(option, opt, value, parser):
    packages = value.split(',')
    classpath = manager.build_classpath(packages)

    printer._print(':'.join(classpath))

    if len(packages) > 0:
        for package in packages:
            printer._printError("Package %s was not found!" % package)
        sys.exit(1)


def get_env(option, opt, value, parser):
    try:
        for env in value.split(','):
            printer._print(manager.get_active_vm().query(env))
    except EnvironmentUndefinedError:
        print
    except InvalidVMError:
        fatalError("The active vm could not be found")

def exec_cmd(option, opt, value, parser):
    for cmd in iter(value.split(',')):
        os.system(cmd)

def list_available_packages(option, opt, value, parser):
    for package in manager.get_packages().itervalues():
        printer._print("[%s] %s (%s)" % (package.name(), package.description(), package.file()))

def list_available_vms(option, opt, value, parser):
    vm_list = manager.get_virtual_machines()
    try:
        active = manager.get_active_vm()
    except InvalidVMError:
        active = None

    for i, vm in vm_list.iteritems():
        if vm is active:
            printer._print('%H%G' + '*) %s [%s] (%s)' % (vm.query('VERSION'), vm.name(), vm.filename()) + '%$')
        else:
            if vm.is_jdk():
                printer._print('%H' + '%i) %s [%s] (%s)' % (i, vm.query('VERSION'), vm.name(), vm.filename()) + '%$')
            else:
                printer._print('%i) %s [%s] (%s)' % (i, vm.query('VERSION'), vm.name(), vm.filename()) + '%$')

def print_environment(option, opt, value, parser):
    vm = manager.get_vm(value) 
    if vm:
        manager.create_env_entry(vm, printer, "%s=%s")
    else:
        fatalError("Could not find a vm matching: %s" % value)

def set_system_vm(option, opt, value, parser):
    vm = manager.get_vm(value)

    if not vm:
        fatalError("Could not find a vm matching: %s" % value)
    else:
        if os.getuid() is 0:
            if not vm.is_jdk():
                printer._printWarning("The specified VM is a JRE! It is suggested you use a JDK!")

            try:
                manager.set_system_vm(vm)
            except PermissionError:
                fatalError("You do not have enough permissions to set the system VM!")
            except EnvironmentUndefinedError:
                fatalError("The selected VM is missing critical environment variables.")
        else:
            fatalError("You do not have enough permissions to set the system VM!")

def set_user_vm(option, opt, value, parser):
    vm = manager.get_vm(value)

    if not vm:
        fatalError("Could not find a vm matching: %s" % value)
    else:
        if os.getuid() is 0:
            fatalError("The user 'root' should always use the System VM")
        else:
            try:
                manager.set_user_vm(vm)
            except PermissionError:
                fatalError("You do not have enough permissions to set the VM!")

def system_classpath_target():
    # TODO: MAKE THIS MODULAR!! (compnerd)
    return [{'file': '/etc/env.d/21java-classpath', 'format': '%s=%s\n' }]

def user_classpath_target():
    # TODO: MAKE THIS MODULAR!! (compnerd)
    return [
            {'file': os.path.join(os.environ.get("HOME"), '.gentoo/java-env-classpath'),     'format': 'export %s=%s\n' },
            {'file': os.path.join(os.environ.get("HOME"), '.gentoo/java-env-classpath.csh'), 'format': 'setenv %s %s\n' }
        ]

def set_system_classpath(option, opt, value, parser):
    deprecation_notice()
    if os.getuid() is 0:
        pkgs = value.split(',')
        manager.set_classpath(system_classpath_target(), pkgs)
        
        for package in pkgs:
            printer._printError("Package %s was not found!" % package)
            
        update_env()
    else:
       fatalError("You do not have enough permissions to set the system classpath!")

def set_user_classpath(option, opt, value, parser):
    deprecation_notice()
    pkgs = value.split(',')
    manager.set_classpath(user_classpath_target(), pkgs)

    for package in pkgs:
        printer._printError("Package %s was not found!" % package)

    user_update_env()

def append_system_classpath(option, opt, value, parser):
    deprecation_notice()
    if os.getuid() is 0:
        pkgs = value.split(',')
        manager.append_classpath(system_classpath_target(), pkgs)

        for package in pkgs:
            printer._printError("Package %s was not found!" % package)

        update_env()
    else:
        fatalError("You do not have enough permissioins to append to the system classpath!")

def append_user_classpath(option, opt, value, parser):
    deprecation_notice()
    pkgs = value.split(',')
    manager.append_classpath(user_classpath_target(),  pkgs)

    for package in pkgs:
        printer._printError("Package %s was not found!" % package)

    user_update_env()

def clean_system_classpath(option, opt, value, parser):
    deprecation_notice()
    if os.getuid() is 0:
        manager.clean_classpath(system_classpath_target())
        update_env()
    else:
        fatalError("You do not have enough permissions to clean the system classpath!")

def clean_user_classpath(option, opt, value, parser):
    deprecation_notice()
    manager.clean_classpath(user_classpath_target())

def library(option, opt, value, parser):
    packages = value.split(',')
    library = manager.query_packages(packages, "LIBRARY_PATH")

    for package in packages:
        printer._printError("Package %s was not found!" % package)

    printer._print(':'.join(library))
    
def select_vm(option, opt, value, parser):
    vm = manager.get_vm(value)
    if vm:
        manager.set_active_vm(manager.get_vm(value))
    else:
        fatalError("The vm could not be found")

def update_env():
    printer._print(getoutput("/usr/sbin/env-update"))
    printer._printAlert("If you want the changes too take effect in your current session, you should update\n\
            your environment by running: source /etc/profile")

def user_update_env():
    printer._printAlert("Environment files in ~/.gentoo/ have been updated. You should source these from your shell's profile.\n\
            If you want the changes too take effect in your current sessiosn, you should resource these files")

def deprecation_notice():
    printer._printWarning("Setting a user and system classpath is deprecated, this option will be removed from future versions.")

def fatalError(msg):
    printer._printError(msg)
    sys.exit(1)

if __name__ == '__main__':
    global printer, manager
    printer = OutputFormatter(True, True)
    manager = EnvironmentManager()

    usage =  "java-config [options]\n\n"
    usage += "Java Configuration Utility Version " + str(__version__) + "\n"
    usage += "Copyright 2004-2005 Gentoo Foundation\n"
    usage += "Distributed under the terms of the GNU General Public License v2\n"
    usage += "Please contact the Gentoo Java Herd <java@gentoo.org> with problems."

    options_list = [
                     make_option ("-V", "--version",                 action="callback", callback=version,                   help="Print version information"),
                     make_option ("-n", "--nocolor",                 action="callback", callback=nocolor,                   help="Disable color output"),
                     make_option ("-J", "--java",                    action="callback", callback=java,                      help="Print the location of the java executable"),
                     make_option ("-c", "--javac",                   action="callback", callback=javac,                     help="Print the location of the javac executable"),
                     make_option ("-j", "--jar",                     action="callback", callback=jar,                       help="Print the location of the jar executable"),
                     make_option ("-O", "--jdk-home",                action="callback", callback=jdk_home,                  help="Print the location of the active JDK home"),
                     make_option ("-o", "--jre-home",                action="callback", callback=jre_home,                  help="Print the location of the active JRE home"),
                     make_option ("-r", "--runtime",                 action="callback", callback=runtime,                   help="Print the runtime classpathh"),
                     make_option ("-f", "--show-active-vm",          action="callback", callback=show_active_vm,            help="Print the active Virtual Machine"),
                     make_option ("-v", "--java-version",            action="callback", callback=java_version,              help="Print version information for the active VM"),
                     make_option ("-p", "--classpath",               action="callback", callback=classpath,                 help="Print entries in the environment classpath",                       type="string", dest="package(s)"),
                     make_option ("-g", "--get-env",                 action="callback", callback=get_env,                   help="Print an environment variable from the active VM",                 type="string", dest="var"),
                     make_option ("-e", "--exec_cmd",                action="callback", callback=exec_cmd,                  help="Execute something which is in JAVA_HOME",                          type="string", dest="command"),
                     make_option ("-l", "--list-available-packages", action="callback", callback=list_available_packages,   help="List all available packages on the system."),
                     make_option ("-L", "--list-available-vms",      action="callback", callback=list_available_vms,        help="List available Java Virtual Machines"),
                     make_option ("-P", "--print",                   action="callback", callback=print_environment,         help="Print the environment for the specified VM",                       type="string", dest="vm"),
                     make_option ("-S", "--set-system-vm",           action="callback", callback=set_system_vm,             help="Set the default Java VM for the system",                           type="string", dest="vm"),
                     make_option ("-s", "--set-user-vm",             action="callback", callback=set_user_vm,               help="Set the default Java VM for the user",                             type="string", dest="vm"),
                     make_option ("-A", "--set-system-classpath",    action="callback", callback=set_system_classpath,      help="(Deprecated) Set the system classpath to include the libraries",  type="string", dest="package(s)" ),
                     make_option ("-B", "--append-system-classpath", action="callback", callback=append_system_classpath,   help="(Deprecated) Append the libraries to the system classpath",       type="string", dest="package(s)"),
                     make_option ("-X", "--clean-system-classpath",  action="callback", callback=clean_system_classpath,    help="(Deprecated) Clean the current system classpath"),
                     make_option ("-a", "--set-user-classpath",      action="callback", callback=set_user_classpath,        help="(Deprecated) Set the user classpath to include the libraries",    type="string", dest="package(s)"),
                     make_option ("-b", "--append-user-classpath",   action="callback", callback=append_user_classpath,     help="(Deprecated) Append the libraries to the user classpath",         type="string", dest="package(s)"),
                     make_option ("-x", "--clean-user-classpath",    action="callback", callback=clean_user_classpath,      help="(Deprecated) Clean the current user classpath"),
                     make_option (""  , "--select-vm",               action="callback", callback=select_vm,                 help="Use this vm when returning information not the active vm",         type="string", dest="vm"),
                     make_option ("-i", "--library",                 action="callback", callback=library,                   help="Print java library paths for these packages",                      type="string", dest="package(s)")
                   ]

    parser = OptionParser(usage, options_list)
    (options, args) = parser.parse_args()

# vim:set expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap: