You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1482 lines
60 KiB
1482 lines
60 KiB
#!/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 python_tqt.qt 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, 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, 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 = unicode(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 = unicode(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 = unicode(i18n("running"))
|
|
else:
|
|
self.status = unicode(i18n("not running"))
|
|
except KeyError:
|
|
if os.path.isfile(os.path.join('/var/run',self.filename + '.pid')):
|
|
self.status = unicode(i18n("running"))
|
|
else:
|
|
self.status = unicode(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 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, 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, 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, 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, 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(lambda x,y: cmp(x.filename,y.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(lambda x,y: cmp(x.filename,y.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 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(lambda x,y: cmp(x.filename,y.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(unicode(self.kid.readStdout()))
|
|
self.outputtextview.setText(self.output)
|
|
self.outputtextview.ensureVisible(0,self.outputtextview.contentsHeight())
|
|
|
|
########################################################################
|
|
def slotReadyReadStderr(self):
|
|
self.output += unicode(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()
|