tde-guidance/serviceconfig/serviceconfig.py

#!/usr/bin/python
# -*- coding: UTF-8 -*-
###########################################################################
# serviceconfig.py - description                                          #
# ------------------------------                                          #
# begin     : Wed Apr 30 2003                                             #
# copyright : (C) 2003-2006 by Simon Edwards                              #
# email     : simon@simonzone.com                                         #
#                                                                         #
###########################################################################
#                                                                         #
#   This program is free software; you can redistribute it and/or modify  #
#   it under the terms of the GNU General Public License as published by  #
#   the Free Software Foundation; either version 2 of the License, or     #
#   (at your option) any later version.                                   #
#                                                                         #
###########################################################################

import sys
import os
import os.path
from PyTQt.tqt import *
from tdeui import *
from tdecore import *
import posix
import re
from pickle import Pickler,Unpickler
import locale

programname = "Services Configuration"
version = "0.8.1"

# Holding the name of the distribution, defaults to ...
DISTRO = "Mandrake"

# These get overridden for Debian. 
initdir = "/etc/init.d"
rcdir = "/etc/rc.d"

chkconfigpath = "/sbin/chkconfig"
statusblacklist = ['iptables']

# Are we running as a separate standalone application or in KControl?
standalone = __name__=='__main__'

# Running as the root user or not?
isroot = os.getuid()==0

#print "Warning:: root check is disabled"
#isroot = True

############################################################################
class DescriptionCache(object):

    proto = 2 ## Choose latest available version of Pickler
    _lines = []
    data = {}

    def __init__(self,filename,path="/tmp"):
        if not os.path.isdir(path):
            print(path, "is not a valid directory, can't cache.")

        self.filename = os.path.join(path,filename)

    def loadCache(self):
        try:
            fhandle = open(self.filename, "r")
            pickler = Unpickler(fhandle)
            self.data = pickler.load()
            fhandle.close()
        except IOError as e:
            print("Couldn't load file:", e)
            print("Not reading description cache data")

    def saveCache(self):
        """ Save pickled dataobject to the file. We don't want the user to be able to save a datastructure that root 
            will read in since that would have implications for security."""
        if not isroot:
            print("Not saving description cache data for security reasons, we're not root")
            return

        try:
            fhandle = open(self.filename, "w")
            pickler = Pickler(fhandle, self.proto) 
            pickler.dump(self.data) 
            fhandle.close()
            #print "Saved description cache data to ", self.filename
        except IOError as e:
            print("Can't cache:", e)

    def add(self,filename,packagename,description):
        self.data[filename] = (packagename,description)

    def readDescription(self,filename):
        """ Tries to look up the package description, returns None if it can't find it."""
        try:
            return self.data[filename][1]
        except KeyError:
            return None

    def readPackagename(self,filename):
        """ Tries to look up the Packagename, returns None if it can't find it."""
        try:
            return self.data[filename][0]
        except KeyError:
            return None

############################################################################
# Holds all of the info about a single service.
class Service(object):
    ########################################################################
    def __init__(self,context,filename):
        self.context = context
        self.filename = filename
        self.longname = ""
        self.description = ""
        self.runlevels = []
        self.gotStatus = False
        self.statusable = False
        self.status = str(i18n("?"))
        self.startpriority = "50"
        self.killpriority = "50"

        try:
            fhandle = open(os.path.join(initdir,self.filename))
            place = 0
            for line in fhandle.readlines():
                line = line.strip()
                if place==0:
                    if line.startswith("#!/bin/sh") or line.startswith("#! /bin/sh") or \
                            line.startswith("#!/bin/bash") or line.startswith("#! /bin/bash"):
                        place = 1
                elif place==1:  # Grab the short description line.
                    if line!="#":
                        if line.startswith("# chkconfig:"):
                            parts = line[12:].split()
                            if len(parts)>=1:
                                for c in parts[0]:
                                    try:
                                        rl = self.context.getRunLevelByNumber(int(c))
                                        if rl is not None:
                                            self.runlevels.append(rl)
                                            rl.availableservices.append(self)
                                    except ValueError:
                                        pass
                            if len(parts)>=2:
                                self.startpriority = parts[1]
                            if len(parts)>=3:
                                self.killpriority = parts[2]
                        else:
                            self.longname = line[2:]
                        place = 2
                elif place==2:  # Look for the description line
                    if line.startswith("# chkconfig:"):
                        parts = line[12:].split()
                        if len(parts)>=1:
                            for c in parts[0]:
                                try:
                                    rl = self.context.getRunLevelByNumber(int(c))
                                    if rl is not None:
                                        self.runlevels.append(rl)
                                        rl.availableservices.append(self)
                                except ValueError:
                                    pass
                        if len(parts)>=2:
                            self.startpriority = parts[1]
                        if len(parts)>=3:
                            self.killpriority = parts[2]
                    elif line.startswith("# description:"):
                        self.description = line[15:]
                        if self.description[-1:]=="\\":
                            self.description = self.description[:-1]
                            place = 3
                        else:
                            place = 2
                elif place==3:  # Grab a description continuation line.
                    if line[0]=="#":
                        self.description += line[1:].strip()
                        if self.description[-1:]=="\\":
                            self.description = self.description[:-1]
                        else:
                            place = 2
                if line.startswith("status)"):
                    self.statusable = True

            fhandle.close()
            if self.filename in statusblacklist:
                self.statusable = False
        except IOError:
            pass

        if self.longname=="":
            self.longname = self.filename

        if len(self.runlevels)==0:
            self.runlevels = self.context.runlevels[:]
            for rl in self.context.runlevels:
                rl.availableservices.append(self)

    ########################################################################
    def isAvailableInRunlevel(self,level):
        return level in self.runlevels

    ########################################################################
    def fetchStatus(self):
        global initdir
        if self.statusable:
            self.status = os.popen(os.path.join(initdir,self.filename) + " status").read()
        self.gotStatus = True

    ########################################################################
    def doStartCommand(self):
        self.gotStatus = False
        return "export CONSOLETYPE=serial && " + os.path.join(self.context.initdir,self.filename) + " start"

    ########################################################################
    def doStopCommand(self):
        self.gotStatus = False
        return "export CONSOLETYPE=serial && " + os.path.join(self.context.initdir,self.filename) + " stop"

    ########################################################################
    def doRestartCommand(self):
        self.gotStatus = False
        return "export CONSOLETYPE=serial && " + os.path.join(self.context.initdir,self.filename) + " restart"

############################################################################
class ServiceContext(object):
    def __init__(self):
        self.runlevels = []
        self.services = {}

    def loadInfo(self): pass
    def currentRunLevel(self): pass
    def newRunLevel(self): pass
    def newService(self,file): pass
    def getRunLevelByNumber(self,num):
        for rl in self.runlevels:
            if rl.levelnum==num:
                return rl
        return None

############################################################################
def getServiceContext():
    global DISTRO
    # Detect if we are running on Debian, Mandrake or what.

    # Uncomment here to test Gentoo compatibility.
    #DISTRO = "Gentoo"; return GentooServiceContext()

    # Check for Debian - is this the 'good' way? 
    etc_issue = '/etc/issue'

    # Knoppix and Kanotix have a symlink called /etc/issue
    if os.path.islink(etc_issue):
        etc_issue = posix.readlink(etc_issue)

    if os.path.isfile(etc_issue):
        etc_issue = open(etc_issue)
        system_name = etc_issue.readline()
        etc_issue.close()
        if system_name.startswith("Debian") or system_name.startswith("Ubuntu"):
            DISTRO = "Debian"
            return DebianServiceContext()

    # Might this be Gentoo Linux?
    if os.path.isfile('/etc/gentoo-release'):
        DISTRO = "Gentoo"
        return GentooServiceContext()

    # Mandrake is default.
    return MandrakeServiceContext()

############################################################################
class MandrakeServiceContext(ServiceContext):
    ########################################################################
    def __init__(self):
        ServiceContext.__init__(self)
        self.initdir = "/etc/init.d"
        self.rcdir = "/etc/rc.d"
        self.runlevels.append(SysVRunLevel(self,0,i18n("Halt (0)")))
        self.runlevels.append(SysVRunLevel(self,1,i18n("Single User Mode (1)")))
        self.runlevels.append(SysVRunLevel(self,2,i18n("Multiuser mode with Networking (2)")))
        self.runlevels.append(SysVRunLevel(self,3,i18n("Multiuser mode (3)")))
        self.__currentrunlevel =  SysVRunLevel(self,5,i18n("GUI Multiuser mode (5)"))
        self.runlevels.append(self.__currentrunlevel)
        self.runlevels.append(SysVRunLevel(self,6,i18n("Reboot (6)")))
        self._filenametoservice = {}

    ########################################################################
    def currentRunLevel(self):
        return self.__currentrunlevel

    ########################################################################
    def loadInfo(self):
        # Load in all of the service info.
        for filename in os.listdir(self.initdir):
            newservice = self.newService(filename)
            self.services[filename] = newservice
            self._filenametoservice[filename] = newservice

        # Now load in which services are active in which run level.
        for rl in self.runlevels:
            rl.loadInfo()

    ########################################################################
    def newService(self,file):
        return Service(self,file)

############################################################################
class SysVRunLevel(object):
    ########################################################################
    def __init__(self,context,levelnum,name):
        self.context = context
        self.levelnum = levelnum
        self.name = name
        self.availableservices = []
        self.activeservices = []
        self.leveldir = os.path.join(self.context.rcdir,"rc"+str(self.levelnum)+".d")

    ########################################################################
    def loadInfo(self):
        #print "SysVRunLevel(object).loadInfo",self.leveldir
        for filename in os.listdir(self.leveldir):
            if filename.startswith("S") and os.path.islink(self.leveldir+"/"+filename):
                target = os.path.basename(posix.readlink(self.leveldir+"/"+filename))
                if target in self.context._filenametoservice:
                    self.activeservices.append(self.context._filenametoservice[target])
                #else:
                #    print "Couldn't find service '%s' in runlevel %i." % (target, self.levelnum)

    ########################################################################
    def isActiveAtBoot(self,service):
        return service in self.activeservices

    ########################################################################
    def setActiveAtBoot(self,service,activeflag):
        leveldir = self.leveldir

        # Remove any existing links to the service script
        for filename in os.listdir(leveldir):
            link = os.path.join(leveldir,filename)
            if os.path.islink(link):
                target = os.path.basename(posix.readlink(os.path.join(leveldir,filename)))
                if target==service.filename:
                    # Kill target.
                    #print "Killing link",link
                    os.remove(link)

        if activeflag:
            #print "symlink(",leveldir+"/S"+service.startpriority+service.filename,",",self.context.initdir+"/"+service.filename,")"
            posix.symlink( os.path.join(self.context.initdir,service.filename),
                os.path.join(leveldir,"S"+service.startpriority+service.filename))
            self.activeservices.append(service)
        else:
            #print "symlink(", leveldir+"/K"+service.killpriority+service.filename,",",self.context.initdir+"/"+service.filename,")"
            posix.symlink( os.path.join(self.context.initdir,service.filename),
                os.path.join(leveldir,"K"+service.killpriority+service.filename))
            self.activeservices.remove(service)

############################################################################
#
# Here's the Debian specific stuff, a Service, a ServiceContext and a RunLevel
# 
# Enjoy. ;-)

class DebianService(Service):
    """ Mapping for services which don't use a pidfile like /var/run/<service>.pid
        Services not in here are lookup up "normally" """
    pidfiles = {    'acpid':'acpid.socket',
                    'spamassassin':'spamd.pid',
                    'dbus':'dbus/pid',
                    'klogd':'klogd/klogd.pid',
                    'samba':'samba/smbd.pid',
                    'zope':'zope/default/Z2.pid',
                    'mysql':'mysqld/mysqld.pid',
                    'hald':'hal/hald.pid',
                    'sysklogd':'syslogd.pid',
                    'ssh':'sshd.pid',
                    'cron':'crond.pid',
                    'slapd':'slapd/slapd.pid',
                    'laptop-mode':'laptop-mode-enabled',
                    'cupsys':'cups/cupsd.pid'
                }

    ########################################################################
    def __init__(self,context,filename):
        self.context = context
        self.filename = filename
        self.path_and_filename = os.path.join(context.initdir, self.filename)
        self.packagename = False
        self.description = i18n("Description is being loaded.")
        self.runlevels = []
        self.gotStatus = False
        self.statusable = False
        self.status = str(i18n("not running"))
        self.startpriority = "50"
        self.killpriority = "50"
        self.getStatusFrom = "pidfile"

        self.fetchStatus()    

        if len(self.runlevels)==0:
            self.runlevels = self.context.runlevels[:]
            for rl in self.context.runlevels:
                rl.availableservices.append(self)

    def fetchDescription(self):
        self.description = self.context.descriptioncache.readDescription(self.filename)
        self.packagename = self.context.descriptioncache.readPackagename(self.filename)
        if not self.description:
            if not self.packagename:
                self.fetchPackageName()
                #print "     packagename", self.packagename
            if self.packagename:
                # FIXME: don't assume english output!
                command = "apt-cache show " + self.packagename

                self.description = ""
                description_label = "Description:"
                for line in os.popen(command).readlines():
                    if line.startswith(description_label):
                        self.description = line.strip()[len(description_label):]

                self.context.descriptioncache.add(self.filename, self.packagename, self.description, )
            else:
                self.description = i18n("Couldn't fetch a description from apt.")

    def fetchPackageName(self):
        if os.path.isfile(self.path_and_filename):
            command = "dpkg -S " + self.path_and_filename
            self.packagename = None # as opposed to False( = not yet fetched)
            for line in os.popen(command).readlines():
                if ":" in line:
                    self.packagename = line.strip().split(":")[0]
        else:
            print(self.path_and_filename + " is no file or does not exist!")

    ########################################################################
    def fetchStatus(self):
        if self.getStatusFrom == "pidfile":
            self.fetchStatusFromPidFile()
        elif self.getStatusFrom == "top":
            # FIXME: not yet implemented
            self.fetchStatusFromTop()

    ########################################################################
    def fetchStatusFromTop(self):
        # FIXME, incomplete.
        top = os.popen("ps -aux")

    ########################################################################
    def fetchStatusFromPidFile(self):
        try:
            if os.path.isfile(os.path.join('/var/run',self.pidfiles[self.filename])):
                self.status = str(i18n("running"))
            else:
                self.status = str(i18n("not running"))
        except KeyError:
            if os.path.isfile(os.path.join('/var/run',self.filename + '.pid')):
                self.status = str(i18n("running"))
            else:
                self.status = str(i18n("not running"))
        self.gotStatus = True

############################################################################
class DebianServiceContext(ServiceContext):
    """ bootscripts are scripts that are only running once at boot and where starting, 
    stopping and restarting does not really make sense, generally exclude these from 
    serviceconfig list."""
    bootscripts = ( 'README',
                    'acpi-support',
                    'xorg-common',
                    'binfmt-support',
                    'bootclean.sh',
                    'bootmisc.sh',
                    'checkfs.sh',
                    'checkroot.sh',
                    'console-screen.sh',
                    'dns-clean',
                    'glibc.sh',
                    'halt',
                    'hostname.sh',
                    'hwclock.sh',
                    'hwclockfirst.sh',
                    'initrd-tools.sh',
                    'keymap.sh',
                    'makedev',
                    'module-init-tools',
                    'mountall.sh',
                    'mountvirtfs',
                    'mountnfs.sh',
                    'nvidia-kernel',
                    'procps.sh',
                    'pppd-dns',
                    'powernowd.early',
                    'rc',
                    'rc.local',
                    'rcS',
                    'readahead',
                    'readahead-desktop',
                    'reboot',
                    'rmnologin',
                    'screen-cleanup',
                    'screen',
                    'sendsigs',
                    'single',
                    'skeleton',
                    'stop-bootlogd',
                    'stop-readahead',
                    'umountfs',
                    'umountnfs.sh',
                    'urandom'
            )

    def __init__(self):
        """
        Debian uses the following runlevels: 

        1 (single-user mode), 
        2 through 5 (multiuser modes), and 
        0 (halt the system), 
        6 (reboot the system). 

        Runlevels 7, 8, and 9 can also be used but their rc directories are not populated 
        when packages are installed. They are intentionally left out here, but should be 
        easy to add.
        """
        ServiceContext.__init__(self)

        self.initdir = "/etc/init.d"
        self.rcdir = "/etc"
        self.relative_initdir = "../init.d"

        deb_runlevels = {   0 : i18n("Halt (0)"), 
                            1 : i18n("Single User Mode (1)"),
                            "S" : i18n("Single User Mode (S)"),
                            2 : i18n("Multiuser Mode (2)"),
                            3 : i18n("Multiuser Mode (3)"),
                            4 : i18n("Multiuser Mode (4)"),
                            5 : i18n("Multiuser Mode (5)"),
                            6 : i18n("Reboot (6)") }

        # Lookup what runlevel we're in.
        shell_output = os.popen('/sbin/runlevel')
        raw_runlevel = shell_output.readline()
        shell_output.close()
        cur_runlevel = raw_runlevel[2:-1]

        for num in list(deb_runlevels.keys()):
            if cur_runlevel.isdigit():
                if num == int(cur_runlevel):
                    self.__currentrunlevel =  DebianRunLevel(self, num, deb_runlevels[num])
                    self.runlevels.append(self.__currentrunlevel)
                else:
                    self.runlevels.append(DebianRunLevel(self, num, deb_runlevels[num]))
            else:
                if num == cur_runlevel:
                    self.__currentrunlevel =  DebianRunLevel(self, num, deb_runlevels[num])
                    self.runlevels.append(self.__currentrunlevel)
                else:
                    self.runlevels.append(DebianRunLevel(self, num, deb_runlevels[num]))
        self._filenametoservice = {}

    ########################################################################
    def currentRunLevel(self):
        return self.__currentrunlevel

    ########################################################################
    def loadInfo(self):
        # Load in all of the service info.
        initscripts = os.listdir(self.initdir)
        # Remove "bootscripts" from our list.
        servicefiles = []
        self.services = []
        for script in initscripts:
            if script not in self.bootscripts:
                try:
                    # Exclude backup copies.
                    if script.split(".")[1] not in ("orig","dpkg-dist"):
                        servicefiles.append(script)
                except IndexError:
                    servicefiles.append(script)

        for filename in servicefiles:
            if filename not in self.bootscripts:
                newservice = self.newService(filename)
                self.services.append(newservice)
                self._filenametoservice[filename] = newservice

        # Now load in which services are active in which run level.
        for rl in self.runlevels:
            rl.loadInfo()

    ########################################################################
    def newService(self,file):
        return DebianService(self,file)

############################################################################
class DebianRunLevel(SysVRunLevel):
    ########################################################################
    def setActiveAtBoot(self,service,activeflag):
        """ Adds a Service to a runlevel.

        Activating a service adds start symlinks in the respective levels, and 
        maintains symlinks in levels 0, 1 and 6 (halt, single user and reboot).
        """
        leveldir = self.context.rcdir

        def createSymlink(target, linkname):
            """ Creates a symlink after having checked if it makes sense to do so.
            We first change to the rcdir, then create a relative symlink and then 
            change back, sounds weird, but Debian's own scripts break when the 
            symlinks are not relative.

            Returns True or False and prints debugging message.
            """
            odir = os.getcwd()
            tmpdir = "/".join(linkname.split("/")[0:-1]) # FIXME use os.path
            os.chdir(tmpdir)

            if not os.path.isfile(target) or os.path.islink(target):
                #print target + " is not a valid filename. Can't create symlink."
                os.chdir(odir)
                return False

            if os.path.islink(linkname) and posix.readlink(linkname) == target:
                #print "Symlink " + linkname + " -> " + target + " already exists."
                os.chdir(odir)
                return True

            if os.path.islink(linkname) and posix.readlink(linkname) != target:
                #print "Removing symlink, " + linkname + ", the target does not match."
                try:
                    posix.unlink(linkname)
                except OSError as e:
                    print("Couldn't remove symlink " + linkname + " :: " + str(e))

            try:
                posix.symlink(target, linkname)
                #print "Created symlink " + linkname + " -> " + target + " successfully."
                os.chdir(odir)
                return True
            except OSError as e:
                #print "Creating symlink " + linkname + " -> " + target + " failed: " + str(e)
                os.chdir(odir)
                return False

        def removeSymlink(servicename, runleveldir, KorS):
            if KorS not in ('K','S'): 
                print("OUCH, symlinks have to start with S or K!")
                return
            for link in os.listdir(runleveldir):
                if (link[0] == KorS) and (link[3:] == servicename):
                    #print "Killing ...", runleveldir+link
                    posix.unlink(os.path.join(runleveldir,link))

        # In these levels, the K symlinks are created.                
        stop_levels = (0,1,6)                        
        l_num = str(self.levelnum)

        if activeflag:
            target = os.path.join(self.context.relative_initdir,service.filename)
            createSymlink(target, os.path.join(self.context.rcdir,"rc"+l_num+".d","S"+service.startpriority+service.filename))
            # Kill links:
            for i in stop_levels: 
                createSymlink(target, os.path.join(self.context.rcdir,"rc"+str(i)+".d","K"+service.killpriority+service.filename))
            self.activeservices.append(service)
        else:

            try:
                s_link = os.path.join(leveldir,"rc"+l_num+".d","S"+service.startpriority+service.filename)
                runleveldir = os.path.join(leveldir,"rc"+l_num+".d")
                #print "Removing symlink " + s_link 
                removeSymlink(service.filename, runleveldir, "S")
            except OSError as e:
                print("Could not remove symlink " + s_link + " :: " + str(e))

            self.activeservices.remove(service)

            # check if service has to be started in other runlevels:
            #    Y: Don't touch links
            #    N: Remove symlinks

            #print "Should remove symlinks here."
            for rl in self.context.runlevels:
                if service in rl.activeservices:
                    #print "Service " + service.filename + " is still used in runlevel " + \
                    #    str(rl.levelnum) + ", not removing K-Links."
                    break
            else:
                # The service is not being used anywhere. We can remove it now.

                #print "Service completely inactive, removing K-links."
                for i in stop_levels:
                    k_link = os.path.join(leveldir,"rc"+str(i)+".d","K"+service.killpriority+service.filename)
                    runleveldir = os.path.join(leveldir,"rc"+str(i)+".d")

                    try:
                        #print "Removing " + k_link
                        removeSymlink(service.filename, runleveldir, "K")
                    except OSError as e:
                        print("Could not remove " + k_link + " :: " + str(e))


############################################################################
#
# Here come all the Gentoo specific pieces.
# Gentoo Linux has a special way of organizing the init and runlevels stuff.

class GentooService(DebianService):
    """ GentooService

    Services in Gentoo are handled very much like the ones in Debian, except
    that there is rc-status to check whether a service is running or not.
    """
    ########################################################################
    def fetchStatus(self):
        # rc-status is run everytime we check a service, this might be some
        # more efficiently solved.
        # FIXME: add check if 'rc-status' is in current PATH
        rc_status_fhandle = os.popen('rc-status')
        for line in rc_status_fhandle.readlines():
            parts = line.split()
            if parts[0] == self.filename:
                # Who needs Perl? ;-)
                # FIXME: set the terminal type to serial when running rc-status.
                self.status = line.split(';01m')[2].split('\x1b[')[0].strip()
        rc_status_fhandle.close()
        self.gotStatus = True

    def fetchDescription(self):
        # Temporary vars.
        description_lines = []
        first_block = True

        if os.path.isfile(self.path_and_filename):
            fhandle = open(self.path_and_filename)
            for line in fhandle.readlines():
                # Ignore blank lines and CVS Headers:
                if len(line.strip()) > 1 and line[:2] != '#!' and line[:10] != '# $Header:':
                    # Cut off newline at the end.
                    line = line[:-1]
                    # The first commencted block might be the description.
                    if first_block:
                        if line[0] != '#': first_block = False
                        else: description_lines.append(line[1:].strip())
            fhandle.close()
        else:
            print(self.path_and_filename + " is no file or does not exist!")

        if len(description_lines):
            self.description = "\n".join(description_lines)
        else:
            self.description = i18n("Could not extract description.")

    ########################################################################
    def doZapCommand(self):
        self.gotStatus = False
        return "export CONSOLETYPE=serial && rc-status"
        return "export CONSOLETYPE=serial && "+os.path.join(self.context.initdir,self.filename)+" zap"

############################################################################
class GentooServiceContext(ServiceContext):
    ########################################################################
    def __init__(self):
        """
        Gentoo uses customized runlevels, see the Gentoo Documentation for 
        the dirty details. The runlevels are defined in inittab, so we have 
        a look there. 

        - Runlevel links reside in /etc/runlevels/${RUNLEVEL}/.
        - Default existing runlevels are boot/, nonetwork/ and default/.
        - Custom runlevels and default are defined in /etc/inittab.

        Dependencies between runscripts / initscrips are not handled here, 
        this is responsibility of rc-update. Also, after rc-update has run,
        some items might be necessary to refresh.

        """
        ServiceContext.__init__(self)

        # Here comes the Gentoo specific stuff.
        # First off, parsing inittab for runlevels available.
        def parseInittab():
            if os.path.isfile(self.inittab):
                inittab_fhandle = open(self.inittab, 'r')
                rl_appended =  []
                for line in inittab_fhandle.readlines():
                    line = line[:-1]
                    # Ignore blank and commented lines.
                    if len(line.strip()) > 1 and line.strip()[0] != '#':
                        parts = line.split(':')
                        if len(parts) == 4 and parts[2] == 'wait':
                            rl_num, rl_label = parts[1], parts[3].split()[1] +' ('+parts[1]+')'
                            rl_name = parts[3].split()[1]
                            #print "Num: " + rl_num + " Label: " + rl_label + " Name: " + parts[3].split()[1]
                            # This is a runlevel in Gentoo, is it the current one?
                            if parts[1] == self.current_runlevelnum:
                                self.__currentrunlevel = GentooRunLevel(self, rl_num, rl_name, rl_label)
                                self.runlevels.append(self.__currentrunlevel)
                                rl_appended.append(rl_name)
                            else:
                                if rl_name not in rl_appended:
                                    self.runlevels.append(GentooRunLevel(self, rl_num, rl_name, rl_label))
                                    rl_appended.append(rl_name)
                        elif len(parts) == 4 and parts[2] == 'bootwait':
                            # The boot runlevel does not have a 'real' runlevel number, so we use 0.
                            self.runlevels.append(GentooRunLevel(self, 0, parts[3].split()[1], 'boot'))
                            rl_appended.append('boot')
                    inittab_fhandle.close()

        def currentRunLevelNum():
            runlevelbin = "/sbin/runlevel"
            if not os.path.isfile(runlevelbin):
                print("Couldn't find %s, that sucks. :o" % runlevelbin)
                sys.exit(1)
            shell_output = os.popen(runlevelbin)
            raw_runlevel = shell_output.readline()
            shell_output.close()
            return raw_runlevel[2:-1]

        self.initdir = "/etc/init.d"
        self.rcdir = "/etc/runlevels"
        self.inittab = "/etc/inittab"

        #self.initdir = "/home/sebas/gentooinit/init.d"
        #self.rcdir = "/home/sebas/gentooinit/runlevels"
        #self.inittab = "/home/sebas/gentooinit/inittab"

        self.current_runlevelnum = currentRunLevelNum()
        parseInittab()
        self._filenametoservice = {}

    ########################################################################
    def currentRunLevel(self):
        return self.__currentrunlevel

    ########################################################################
    def loadInfo(self):
        """ Load in all of the service info for every file in the init.d directory. """
        for filename in os.listdir(self.initdir):
            # Exclude backup files from portage and .sh files like shutdown, depscan, etc.
            if (filename.find('._cfg')<0)  and not filename.endswith(".sh"):
                newservice = self.newService(filename)
                self.services[filename] = newservice
                self._filenametoservice[filename] = newservice

        # Now load in which services are active in which run level.
        for rl in self.runlevels:
            rl.loadInfo()

    ########################################################################
    def newService(self,file):
        return GentooService(self,file)


############################################################################
class GentooRunLevel(SysVRunLevel):
    """ Gentoo Runlevel

        GentooRunLevel has an additional parameter. the 'label' gets displayed in the 
        'Run level:' drop-down menu, the 'name' is used. 'name' is internally handled 
        in very much the same way as SysVRunLevel.levelnum. It corresponds to the 
        actual runlevels Gentoo uses, such as /etc/runlevels/default/, rather than 
        using SysVRunLevel.levelnum, as it would be in a SysV init. """

    ########################################################################
    def __init__(self,context,levelnum,dirname,label):
        SysVRunLevel.__init__(self,context,levelnum,label)

        self.dirname = dirname

        self.leveldir = self.context.rcdir+'/'+self.dirname
        # Not all runlevels in Gentoo correspond to a runlevel directory.
        self.no_dirs = []
        if not os.path.isdir(self.leveldir): 
            #self.no_dirs = ('reboot', 'shutdown', 'single')
            if self.dirname not in self.no_dirs: 
                self.no_dirs.append(self.dirname)
                print("Runlevel " + self.leveldir + " is not a valid path. '" +  self.dirname + "'")
            self.leveldir = False
            return

    ########################################################################
    def loadInfo(self):
        """ Only look up active services if runlevel path exists, else leave empty. """
        if self.leveldir:
            print("GentooRunLevel.loadInfo() from " + self.leveldir)
            for filename in os.listdir(self.leveldir):
                # Exclude backup files from portage and .sh files like shutdown, depscan, etc.
                if (filename.find('._cfg')<0) and not filename.endswith('.sh'):
                    linkname = self.leveldir+"/"+filename
                    if os.path.islink(linkname):
                        target = os.path.basename(posix.readlink(linkname))
                        if target in self.context._filenametoservice:
                            self.activeservices.append(self.context._filenametoservice[target])
                        else:
                            print("Couldn't find service '%s'. " % target)
                    else:
                        print("%s is not a valid symlink." % linkname)

    ########################################################################
    def setActiveAtBoot(self,service,activeflag):
        """ Runs rc-update to add and remove Services from RunLevels.

            Dependencies are checked from within runscript.sh, so we don't handle them here. """

        # FIXME :: "Start at Boot" column does not properly get updated once it's "False".
        # The commands issued might better be passed through via CommandRunner.
        if self.name in self.no_dirs:
            print("Runlevel has no corresponding path, running rc-update anyway.")
        if activeflag:
            if not service in self.activeservices:
                rc_add_cmd = "rc-update add %s %s" % (service.filename, self.dirname) 
                print(rc_add_cmd)
                # The brave really run it yet.
                os.system(rc_add_cmd)
                self.activeservices.append(service)
        else:
            if service in self.activeservices:
                rc_del_cmd = "rc-update del %s %s" % (service.filename, self.dirname)
                print(rc_del_cmd)
                # The brave really run it yet.
                os.system(rc_dell_cmd)
                self.activeservices.remove(service)

############################################################################

# Try translating this code to C++. I dare ya!
if standalone:
    programbase = KDialogBase
else:
    programbase = TDECModule

# is_shown exists to prevent loadDescriptions from running two times, which is 
# the case when we're running inside kcontrol. Yes, this is an ugly hack. :(
# It's set to True after show has finished once. It doesn't play a role when
# we're running standalone.
is_shown = False

class SysVInitApp(programbase):
    ########################################################################

    def __init__(self,parent=None,name=None):
        global standalone,isroot, DISTRO, is_shown
        TDEGlobal.locale().insertCatalogue("guidance")

        if standalone:
            KDialogBase.__init__(self,KJanusWidget.Plain,i18n("Service Configuration"), \
                KDialogBase.User1|KDialogBase.Close, KDialogBase.Close)
            self.setButtonText(KDialogBase.User1,i18n("About"))
        else:
            TDECModule.__init__(self,parent,name)
            self.setButtons(1)
            self.aboutdata = MakeAboutData()

        # Create a configuration object.
        self.config = TDEConfig("serviceconfigrc")
        TDEGlobal.iconLoader().addAppDir("guidance")

        self.updatingGUI = False
        self.context = getServiceContext()
        self.servicestolistitems = {}   # Map service names to TQListViewItems
        self.currentrunlevel = self.context.currentRunLevel()

        self.context.loadInfo()

        self.aboutus = TDEAboutApplication(self)

        if standalone:
            toplayout = TQVBoxLayout( self.plainPage(), 0, KDialog.spacingHint() )
            tophb = TQSplitter(TQt.Horizontal, self.plainPage())
        else:
            toplayout = TQVBoxLayout( self, 0, KDialog.spacingHint() )
            tophb = TQSplitter(TQt.Horizontal, self)

        toplayout.addWidget(tophb)

        vb = TQVBox(tophb)
        vb.setSpacing(KDialog.spacingHint())

        hb = TQHBox(vb)
        hb.setSpacing(KDialog.spacingHint())
        vb.setStretchFactor(hb,0)

        label = TQLabel(hb)
        label.setPixmap(UserIcon("hi32-app-daemons"))
        hb.setStretchFactor(label,0)

        label = TQLabel(i18n("Run level:"),hb)
        hb.setStretchFactor(label,0)
        self.runlevelcombo = TQComboBox(hb)

        # Load up the runlevel combo box.
        i = 0
        for runlevel in self.context.runlevels:
            self.runlevelcombo.insertItem(runlevel.name)
            if self.context.currentRunLevel() is runlevel:
                self.runlevelcombo.setCurrentItem(i)
            i += 1

        hb.setStretchFactor(self.runlevelcombo,0)

        self.connect(self.runlevelcombo, SIGNAL("activated(int)"), self.slotRunLevelChanged)

        widget = TQWidget(hb)
        hb.setStretchFactor(widget,1)

        self.servicelistview = TDEListView(vb)
        self.servicelistview.addColumn(i18n("Service"))
        self.servicelistview.addColumn(i18n("Start at Boot"))
        self.servicelistview.addColumn(i18n("Status"))
        self.servicelistview.setAllColumnsShowFocus(True)
        self.servicelistview.setSelectionMode(TQListView.Single)
        self.connect(self.servicelistview, SIGNAL("selectionChanged(TQListViewItem *)"), self.slotListClicked)

        # Right hand side of the dialog.
        vb = TQVBox(tophb)
        vb.setSpacing(KDialog.spacingHint())

        hgb = TQHGroupBox(i18n("Service Details"),vb)
        vb.setStretchFactor(hgb,1)
        vb2 = TQVBox(hgb)
        vb2.setSpacing(KDialog.spacingHint())

        label = TQLabel(i18n("Description:"),vb2)
        vb2.setStretchFactor(label,0)
        self.descriptiontextedit = TQTextEdit(vb2)
        vb2.setStretchFactor(self.descriptiontextedit,2)
        self.descriptiontextedit.setReadOnly(True)
        self.startatbootcheckbox = TQCheckBox(i18n("Start during boot"),vb2)
        vb2.setStretchFactor(self.startatbootcheckbox,0)
        self.connect(self.startatbootcheckbox, SIGNAL("toggled(bool)"), self.slotBootChanged)

        label = TQLabel(i18n("Status:"),vb2)
        vb2.setStretchFactor(label,0)
        self.statustext = TQTextEdit(vb2)
        self.statustext.setReadOnly(True)
        vb2.setStretchFactor(self.statustext,1)

        hb2 = TQHBox(vb2)
        hb2.setSpacing(KDialog.spacingHint())
        vb2.setStretchFactor(hb2,0)
        self.startbutton = TQPushButton(i18n("Start"),hb2)
        hb2.setStretchFactor(self.startbutton,1)
        self.connect(self.startbutton, SIGNAL("clicked()"), self.slotStartButton)
        self.stopbutton = TQPushButton(i18n("Stop"),hb2)
        hb2.setStretchFactor(self.stopbutton,1)
        self.connect(self.stopbutton, SIGNAL("clicked()"), self.slotStopButton)
        self.restartbutton = TQPushButton(i18n("Restart"),hb2)
        hb2.setStretchFactor(self.restartbutton,1)
        self.connect(self.restartbutton, SIGNAL("clicked()"), self.slotRestartButton)

        if DISTRO == "Gentoo":
            # Gentoo Linux gets an extra button.
            self.zapbutton = TQPushButton(i18n("Zap"),hb2)
            hb2.setStretchFactor(self.zapbutton,1)
            self.connect(self.zapbutton, SIGNAL("clicked()"), self.slotZapButton)

        if not isroot:
            self.disableStuff()
        else:
            self.connect(self.servicelistview, SIGNAL("contextMenu(TDEListView*,TQListViewItem*,const TQPoint&)"), 
                    self.slotServiceContextMenu)

        self.__fillListView(self.currentrunlevel)
        self.__selectFirstService()

        self.cr = CommandRunner(None,"title")
        self.timerid = None

    ########################################################################
    def __del__(self):
        pass

    def disableStuff(self):
        """Disable a couple of widgets when not running as root"""
        self.startatbootcheckbox.setDisabled(True)
        self.startbutton.setDisabled(True)
        self.restartbutton.setDisabled(True)
        self.stopbutton.setDisabled(True)
        if DISTRO == "Gentoo":
            self.zapbutton.setDisabled(True)

    def slotServiceContextMenu(self,l,v,p):
        self.cmenu = TDEPopupMenu(self,"MyActions")
        self.cmenu.insertItem(i18n("Start..."), self.slotStartButton)
        self.cmenu.insertItem(i18n("Stop..."), self.slotStopButton)
        self.cmenu.insertItem(i18n("Restart..."), self.slotRestartButton)
        self.cmenu.insertItem(i18n("Toggle start during boot..."), self.slotBootChangedAndToggle)

        self.cmenu.exec_loop(p)

    def slotBootChangedAndToggle(self):
        """Wrap slotBootChanged in order to pass the status of the checkbox, used from contextmenu."""
        self.startatbootcheckbox.toggle()

    ########################################################################
    # KDialogBase method
    def exec_loop(self):
        global programbase

        self.__loadOptions()
        programbase.exec_loop(self)
        self.__saveOptions()

    ########################################################################
    def __selectFirstService(self):                
        # Grab the first service in the list and select it.
        services = self.currentrunlevel.availableservices[:]
        services.sort(key=lambda x: x.filename)
        self.selectedservice = None
        try:
            self.selectedservice = services[0]
            lvi = self.servicestolistitems[self.selectedservice]
            self.servicelistview.setSelected(lvi,True)
        except IndexError:
            pass
        self.__selectService(self.selectedservice)

    ########################################################################
    def show(self):
        global standalone,isroot, is_shown

        programbase.show(self)
        self.updatingGUI = True
        if isroot:
            self.__selectFirstService()
        self.updatingGUI = False
        self.__checkServiceStatus()

        if DISTRO == "Debian" and (standalone or (not standalone and is_shown)):
            TQTimer.singleShot(0,self.__startLoadDescriptions)
        is_shown = True


    ########################################################################
    # KDialogBase method
    def slotUser1(self):
        self.aboutus.show()

    ########################################################################
    def __fillListView(self,runlevelobj):
        self.servicelistview.clear()
        self.servicestolistitems = {}

        services = self.currentrunlevel.availableservices[:]
        services.sort(key=lambda x: x.filename)

        for item in services:
            if item.isAvailableInRunlevel(runlevelobj):
                status = item.status.strip().replace("\n",", ")[:32]
                if item in runlevelobj.activeservices:
                    lvi = TQListViewItem(self.servicelistview,item.filename,i18n("Yes"),status)
                else:
                    lvi = TQListViewItem(self.servicelistview,item.filename,i18n("No"),status)
                self.servicestolistitems[item] = lvi

    ########################################################################
    def __selectService(self,service):
        if service!=None:
            self.descriptiontextedit.setEnabled(True)
            self.descriptiontextedit.setText(service.description)

            if isroot:
                self.startatbootcheckbox.setEnabled(True)

            self.startatbootcheckbox.setChecked(self.currentrunlevel.isActiveAtBoot(service))
            self.statustext.setEnabled(True)
            self.statustext.setText(service.status)
        else:
            self.disableStuff()
            self.descriptiontextedit.setText("")
            self.descriptiontextedit.setEnabled(False)
            self.statustext.setText("")
            self.statustext.setEnabled(False)

    ########################################################################
    def slotRunLevelChanged(self,levelnum):
        if self.updatingGUI:
            return
        self.updatingGUI = True

        self.currentrunlevel = self.context.runlevels[levelnum]
        self.__fillListView(self.currentrunlevel)
        self.__selectFirstService()
        self.__checkServiceStatus()

        self.updatingGUI = False

    ########################################################################
    def slotListClicked(self,item):
        if self.updatingGUI:
            return
        self.updatingGUI = True

        for service in list(self.servicestolistitems.keys()):
            if self.servicestolistitems[service] is item:
                self.selectedservice = service
                self.__selectService(self.selectedservice)
                break
        self.updatingGUI = False

    ########################################################################
    def slotBootChanged(self,state):
        if self.updatingGUI:
            return
        self.updatingGUI = True
        level = self.currentrunlevel
        level.setActiveAtBoot(self.selectedservice,state)
        if level.isActiveAtBoot(self.selectedservice):
            self.servicestolistitems[self.selectedservice].setText(1,i18n("Yes"))
        else:
            self.servicestolistitems[self.selectedservice].setText(1,i18n("No"))
        self.updatingGUI = False                         

    ########################################################################
    def slotCloseButton(self):
        self.close()

    ########################################################################
    def slotStartButton(self):
        self.__runInitScript(i18n("Starting %1").arg(self.selectedservice.filename), \
                             self.selectedservice,"start")

    ########################################################################
    def slotStopButton(self):
        self.__runInitScript(i18n("Stopping %1").arg(self.selectedservice.filename), \
                             self.selectedservice,"stop")

    ########################################################################
    def slotRestartButton(self):
        self.__runInitScript(i18n("Restarting %1").arg(self.selectedservice.filename), \
                             self.selectedservice,"restart")

    ########################################################################
    def slotZapButton(self):
        """This button lets the Gentoo user use the zap command, if process
        information has not properly been cleaned up by the init script.
        """
        if DISTRO == "Gentoo":
            self.__runInitScript(i18n("Zapping %1").arg(self.selectedservice.filename), \
                             self.selectedservice,"zap")


    ########################################################################
    def __startLoadDescriptions(self):
        if DISTRO=="Debian":
            cachepath = "/var/tmp"
            cachefile = "guidance-packagedescriptioncache"
            self.context.descriptioncache = DescriptionCache(cachefile,cachepath)
            self.context.descriptioncache.loadCache()
        self.__loadDescriptions()

    ########################################################################
    def __loadDescriptions(self):
        """
        Loads the description of all services showing a progressbar if it takes longer,
        tries to get the descriptions from cache first.
        """
        for service in self.context.services:
            if service.packagename is None:
                continue
            # Check if we want to fetch a description for the currently selected item
            # before we go on fetching other descriptions.
            if not self.selectedservice.packagename:
                self.selectedservice.fetchDescription()
                self.slotListClicked(self.servicelistview.currentItem())
                break
            if not service.packagename:
                service.fetchDescription()
                break
        else:
            self.slotListClicked(self.servicelistview.currentItem())
            if DISTRO=="Debian":
                self.context.descriptioncache.saveCache()
            return

        TQTimer.singleShot(0,self.__loadDescriptions)

    ########################################################################
    def __runInitScript(self,title,service,command):        
        global DISTRO
        self.cr.setCaption(title)
        self.cr.setHeading(title)
        if command=="start":
            cmd = service.doStartCommand()
        elif command=="stop":
            cmd = service.doStopCommand()
        elif command=="restart":
            cmd = service.doRestartCommand()
        elif DISTRO == "Gentoo" and command=="zap":
            cmd = service.doZapCommand()

        self.cr.run(["/bin/bash","-c",cmd])

        # Does not seem to properly update ...
        self.__checkServiceStatus()

    ########################################################################
    def __checkServiceStatus(self):
        global kapp
        global progcount

        # Put up the progress dialog. (User pacifier).
        dialog = KProgressDialog(self,"statusprogress",
            i18n("Querying System Service Status"),
            i18n("Querying system service status"))
        dialog.setLabel(i18n("Querying system service status"))
        dialog.setAutoClose(True)
        dialog.showCancelButton(False)

        services = self.currentrunlevel.availableservices[:]
        services.sort(key=lambda x: x.filename)
        dialog.progressBar().setTotalSteps(len(services))

        kapp.processEvents()
        self.updatingGUI = True

        for item in services:
            if item.gotStatus==False:
                item.fetchStatus()
                lvi = self.servicestolistitems[item]
                lvi.setText(2,item.status.strip().replace("\n",", ")[:32])
                if self.selectedservice is item:
                    self.statustext.setText(item.status)
            dialog.progressBar().advance(1)
            kapp.processEvents()
        dialog.setMinimumDuration(2000000000)
        dialog.hide()
        self.updatingGUI = False

    ########################################################################
    def __loadOptions(self):
        self.config.setGroup("General")
        size = self.config.readSizeEntry("Geometry")
        if size.isEmpty()==False:
            self.resize(size)
        size = self.config.readSizeEntry("CommandRunnerGeometry")
        if size.isEmpty()==False:
            self.cr.resize(size)

    #######################################################################
    def __saveOptions(self):
        global isroot
        if isroot:
            return
        self.config.setGroup("General")
        self.config.writeEntry("Geometry", self.size())
        self.config.writeEntry("CommandRunnerGeometry",self.cr.size())
        self.config.sync()

    #######################################################################
    # KControl virtual void methods
    def load(self):
        pass
    def save(self):
        pass
    def defaults(self):
        pass        
    def sysdefaults(self):
        pass

    def aboutData(self):
        # Return the TDEAboutData object which we created during initialisation.
        return self.aboutdata

    def buttons(self):
        # Only supply a Help button. Other choices are Default and Apply.
        return TDECModule.Help

############################################################################
class CommandRunner(KDialogBase):
    ########################################################################
    def __init__(self,parent,name):
        KDialogBase.__init__(self,parent,name,1,"",KDialogBase.Ok)
        self.output = ""
        self.running = False        

        self.resize(400,200)
        vbox = self.makeVBoxMainWidget()

        hbox = TQHBox(vbox)
        hbox.setSpacing(self.spacingHint())

        tmplabel = TQLabel(hbox)
        tmplabel.setPixmap(UserIcon("laserwarn"))
        hbox.setStretchFactor(tmplabel,0)

        self.headinglabel = TQLabel(hbox)
        hbox.setStretchFactor(self.headinglabel,1)

        self.outputtextview = TQTextView(vbox)
        self.outputtextview.setTextFormat(TQTextView.PlainText)

        self.kid = TQProcess()
        self.kid.setCommunication(TQProcess.Stdout|TQProcess.Stderr)
        self.connect(self.kid,SIGNAL("processExited()"),self.slotProcessExited)
        self.connect(self.kid,SIGNAL("readyReadStdout()"),self.slotReadyReadStdout)
        self.connect(self.kid,SIGNAL("readyReadStderr()"),self.slotReadyReadStderr)

    ########################################################################
    def run(self,argslist):
        self.kid.clearArguments()
        for arg in argslist:
            self.kid.addArgument(arg)
        self.output = ""
        self.outputtextview.setText(self.output)
        self.bootstraptimer = self.startTimer(0)
        self.running = True
        self.enableButtonOK(False)
        self.exec_loop()

    ########################################################################
    def timerEvent(self,timer):
        self.killTimer(self.bootstraptimer)

        # Create a slightly new environment where TERM is vt100
        new_env = TQStringList()
        for key in os.environ:
            if key=="TERM":
                new_env.append("TERM=vt100")
            else:
                new_env.append(key + "=" + os.environ[key])

        self.kid.launch("",new_env)

    ########################################################################
    def setHeading(self,heading):
        self.headinglabel.setText(heading)

    ########################################################################
    def slotOKButton(self):
        self.accept()        

    ########################################################################
    def slotReadyReadStdout(self):
        # Remove the colors used by some programs.
        # FIXME: this probably isn't neccessary anymore.
        uncolor = lambda text: re.compile('\\x1b\[[0-9]+;01m').sub("", \
          re.compile('\\x1b\[0m').sub("", re.compile('\\033\[1;[0-9]+m').sub("", \
          re.compile('\\033\[0m').sub("", text))))
        self.output += uncolor(str(self.kid.readStdout()))
        self.outputtextview.setText(self.output)
        self.outputtextview.ensureVisible(0,self.outputtextview.contentsHeight())

    ########################################################################
    def slotReadyReadStderr(self):
        self.output += str(self.kid.readStderr())
        self.outputtextview.setText(self.output)
        self.outputtextview.ensureVisible(0,self.outputtextview.contentsHeight())

    ########################################################################
    def slotProcessExited(self):
        self.running = False        
        self.enableButtonOK(True)

############################################################################
# Factory function for KControl
def create_serviceconfig(parent,name):
    global kapp
    kapp = TDEApplication.kApplication()
    return SysVInitApp(parent, name)

############################################################################
def MakeAboutData():
    aboutdata = TDEAboutData("guidance",programname,version, \
        "Services Configuration Tool", TDEAboutData.License_GPL, \
        "Copyright (C) 2003-2007 Simon Edwards", \
        "Thanks go to  Phil Thompson, Jim Bublitz and David Boddie.")
    aboutdata.addAuthor("Simon Edwards","Developer","simon@simonzone.com","http://www.simonzone.com/software/")
    aboutdata.addAuthor("Sebastian Kügler","Developer","sebas@kde.nl","http://vizZzion.org");
    return aboutdata

if standalone:
    aboutdata = MakeAboutData()
    TDECmdLineArgs.init(sys.argv,aboutdata)

    kapp = TDEApplication()
    sysvapp = SysVInitApp()
    sysvapp.exec_loop()