F:/thesis_austausch/dissertation/code_docu_doxygen/Server/server_classes.py

Go to the documentation of this file.

#!/usr/bin/env python

'''
This module contains all necessary classes and functions for the gz_parser.py and srb log file parser -> start_server.py .

Reading University
MSc in Network Centered Computing
a.weise - a.weise@reading.ac.uk - December 2005
'''

# ssl connection
from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
from M2Crypto import SSL

# misc
import os, time, stat

# regular expressions
import re

# utilities
from utils_server import delete_file, list_to_string, get_keywords, LoadConfig, find

# threads
import thread
import threading

import socket

################## CLASS  SimpleSSLXMLRPCServer  ##################

class SimpleSSLXMLRPCServer(SSL.SSLServer, SimpleXMLRPCServer):
    '''
    This class is derived from SSL.SSLServer and SimpleXMLRPCServer.
    '''
    def __init__(self, ssl_context, address, verbose, handler=SimpleXMLRPCRequestHandler):
        '''
        Constructor overwrites the init function of the SimpleXMLRPCServer and replace it with the secure SSLServer.        
        '''
        SSL.SSLServer.__init__(self, address, handler, ssl_context)
        self.funcs = {}
        self.logRequests = 0
        self.instance = None
        self._verbose = verbose

    def handle_request(self, serv):
        '''
        Handle one request by passing it on the a thread.
        '''
        try:
            request, client_address = self.get_request()
            if self._verbose == 1:
                print "%s -> request accepted from %s....." % (time.ctime(), client_address[0])

        except socket.error:
            return
        if self.verify_request(request, client_address):
            thd = MyClientThread(request, client_address, serv)
            thd.start()

################## CLASS  My_SSL_Server  ##################

class My_SSL_Server:
    '''
    provide functions for the server class
    '''

    def __init__(self, server_cert, ca_cert, verbose):
        '''
        Constructor
        '''
        self._server_certificate = server_cert
        self._ca_certificate = ca_cert
        self._verbose = verbose
    
    def start_server(self, address, port, xmlrpcserver=SimpleSSLXMLRPCServer):
        '''
        Start the actual server using SSL:
        
        sslv23 -> compatibility mode, can handle any of the three SSL/TLS protocol versions
        server.pem -> server certificate including server RSA private key
        ca.pem -> root certificate
        SSL.verify_none -> no request that the client has to send his certificate as well
        '''
        # create SSL context
        ctx = self.init_context('sslv3', self._verbose, self._server_certificate, self._ca_certificate, SSL.verify_none)
        # create server object
        server = xmlrpcserver(ctx, (address, port), self._verbose)
        # return server object
        return server

    def init_context(self, protocol, verbose, certfile, cafile, verify, verify_depth=10):
        '''
        This function is used to generate the SSL context:
        - verify_depth -> chain depth
        '''
        ctx = SSL.Context(protocol)             # create context object
        ctx.load_cert_chain(certfile)           # load server certificate chain
        ctx.load_verify_locations(cafile)
        ctx.set_client_CA_list_from_file(cafile)
        ctx.set_verify(verify, verify_depth)    # verfiy options
        ctx.set_session_id_ctx('server')        # set session id
        #if verbose == 1:
        #    ctx.set_info_callback()            # show handshake information --- debug
        return ctx

################## CLASS  MyClientThread  ##################

class MyClientThread(threading.Thread):
    '''
    This class presents a client, which connects to the server.
    '''
    
    def __init__(self, request, address, serv_object):
        '''
        Constructor
        '''
        self._request = request
        self._client = address
        self._serv = serv_object
        threading.Thread.__init__(self)
       
    def run(self):
        '''
        This function overrides the standard run method.
        '''
        try:
            self._serv.process_request(self._request, self._client)
            self._serv.close_request(self._request)
        except:
            self._serv.handle_error(self._request, self._client)
            self._serv.close_request(self._request)

################## CLASS  LogFileParser  ##################

class LogFileParser:
    '''
    This class provides all the neccessarey tools to parse and work up to logfile of the SRB-System.
    '''
    
    def __init__(self, logfilepath, keywords, ignore_error, xml_file_path, xml_file_name, verbose):
        '''
        Constructor
        '''
        self._verbose = verbose
        self._ignore_error = ignore_error
        self._keywords = keywords  # keywords
        self._logfile_path = logfilepath
        self._client_log_file =  "%s/%s" % (xml_file_path, xml_file_name)  # name and path of client log file
        self._client_log_file_fd = -1      # client log file - file descriptor
        self._first_line = range(15)   # save first 15 lines of log file
        self._last_byte_number = 0     # save last byte number which was parsed
        self._line_number     = 1         #save last line number which was parsed
        
        if(0 == os.path.exists(self._logfile_path)):
            print "Could not locate log file path under %s !\nMaybe change configuration file and try again!\n\n" % self._logfile_path
            os._exit(-1)
   
    def _fetch_first_lines(self, file_name):
        '''
        This function returns the first 15 lines from current logfile without saving them anywhere.
        '''
        try:
            log_file_fd = open(file_name, "r")
                
            listline = range(15)
            log_file_fd.seek(0) #set cursor on first position
            for i in range(15):
                listline[i] = log_file_fd.readline()
            log_file_fd.close()
            return listline
        except IOError:
            print "Could not open file -> ", file_name
        
    def set_first_lines(self, file_name):
        '''
        This function saves the first 15 lines of the log file into the member variable.
        '''
        try:
            log_file_fd = open(file_name, 'r')
            log_file_fd.seek(0) #set cursor on first position
            for i in range(15):
                self._first_line[i] = log_file_fd.readline()
            log_file_fd.close()
        except IOError:
            if self._verbose == 1:
                print "%s -> Could not open file -> \"%s\"" % (time.ctime(), file_name)
        
    def get_first_lines(self):
        '''
        This function returns the member variable _first_lines.
        '''
        return self._first_line
    
    def test_first_lines(self, file_name):
        '''
        This function compares the first 15 lines of a log file and return 0 if they are the same, otherwise -1.
        '''
        listline = self._fetch_first_lines(file_name)
        z = 0
        while(z<15):
            if(listline == self._first_line):
                z += 1
            else:
                return -1
            
        return 0
    
    def find_size_last_message_tag(self, fd, msg_tag):
        '''
        This function find out, how many bytes the last message tag needs. This function was necessary, because this new xml messages have to be added into the client xml file. Since the creating of this file is not very straightforward using known techniques like sax or dom, the last tag gets deleted, the new messages added and the last tag writen again.
        
        fd = file descriptor of the file
        msg_tag = message tag to search for
        '''
        #set cursor back
        z = -1
        fd.seek(0, 2)

        while(1):
            fd.seek(z, 2)
            tag = fd.read()
            if (-1 != tag.rfind(msg_tag)):
                return z
            z -= 1
            if -15 == z:
                # message tag was not part of the file
                return 0

    def analyse_log_file(self, parser_file_name, file_time=None):
        '''
        takes the templog file and goes through each lines and searches for keywords, if keywords are found, the line and the two lines before and after are dumped into a xml file, which the client can collect. This function uses the system function write to create the xml file. The dom function were to ineffectiv and sax unflexible.
        
        parser_file_name = file name of the file, which needs to be parsed
        '''
        # determine year of paser file, needed for extract time, since log file content does not provide a year
        if file_time != None:    
            tupel = time.gmtime(file_time)
        else:
            status = os.stat(parser_file_name)
            file_time = status[8]
            tupel = time.gmtime(file_time)
        
        pf_year = time.strftime("%Y ", tupel)
        
        byte_count = 0
        interrupt = 0
        z = 0
        
        try:
            self._client_log_file_fd = file(self._client_log_file, 'r+')

        except IOError:
            # create new client log file
            self._client_log_file_fd = open(self._client_log_file, 'w')
           
            xml_header = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>\n"
            self._client_log_file_fd.writelines(xml_header)
            self._client_log_file_fd.writelines("<message>\n")
            self._client_log_file_fd.writelines("</message>\n")
            self._client_log_file_fd.close()
            self._client_log_file_fd = file(self._client_log_file, 'r+')
            
        
        # set cursor in file
        x = self.find_size_last_message_tag(self._client_log_file_fd, "</message>")
        
        self._client_log_file_fd.seek(x, 2)
        shorten = self._client_log_file_fd.tell()
        # delete last </message>
        self._client_log_file_fd.truncate(shorten)
        self._client_log_file_fd.seek(0, 2)

        #open log file
        log_file = parser_file_name
        
        try:
            log_file_fd = open(log_file, "r")
            log_file_fd.seek(self._last_byte_number)
            
        except IOError:
            if self._verbose == 1:
                print "%s -> could not open srb log file -> %s" % (time.ctime(), log_file)
            return -1
            
        if self._verbose == 1:
            print "%s -> start parsing " % (time.ctime())
        starttime = time.time()
        while(interrupt == 0):
            # read line
            content = log_file_fd.readline()
            if(content == ''):
                interrupt = 1
                break
            
            if 0 == len(self._keywords):
                check = 0
            else:
                check = self._test_keywords(self._keywords, len(self._keywords)-1, content)
            
            if(0 == check):
                # extract error number
                error_number = self._extract_error_number(content)

                if (None == error_number):
                    error_number = "-"
                    temp = ""
                else:
                    temp = int(error_number)
                    
                if ( None == find(temp, self._ignore_error)):

                    line_number_string = "%d" % self._line_number
                    # delete whitespace
                    content_ = content.rstrip()

                    date_time = self._extract_time(content, pf_year)
                    
                    if (date_time == -1):
                        date_time = ["", ""]
                        # save current byte count
                        byte_count = log_file_fd.tell()
                        back = -1
                        read = 0
                        while(1):
                            try:
                                # find time pattern by going back character by character
                                log_file_fd.seek(back, 1)
                                read = back*(-1)
                                tag = log_file_fd.read(read)
                                if (None !=  re.search('^NOTICE: *[A-Z][a-z]{2} +[0-9]{1,2} +[0-9]{2}:[0-9]{2}:[0-9]{2}:', tag)):
                                    date_time = self._extract_time(tag, pf_year)
                                    break
                                back = back-1
                            except IOError:
                                # no time available
                                date_time[0] = time.strftime("%Y-%m-%d", tupel)
                                date_time[1] = time.strftime("%H:%M:%S", tupel)
                                 
                                break
                    
                        #restore byte count
                        log_file_fd.seek(byte_count)
                        
                    z += 1 # entry counter

                    if -1 == self.start_entry('entry'):
                        interrupt = 1
                        break
                    if -1 == self.write_entry('date', date_time[0]):
                        interrupt = 1
                        break                        
                    if -1 == self.write_entry('time', date_time[1]):
                        interrupt = 1
                        break                        
                    if -1 == self.write_entry('error_number', error_number):
                        interrupt = 1
                        break                        
                    if -1 == self.write_entry('error_string', content_):
                        interrupt = 1
                        break                        
                    if -1 == self.write_entry('linenumber', line_number_string):
                        interrupt = 1
                        break                        
                    if -1 == self.end_entry('entry'):
                        interrupt = 1
                        break                        
            
            self._line_number += 1
        if self._verbose == 1:
            print "%s -> end parsing " % (time.ctime())
        endtime = time.time()
        if self._verbose == 1:
            print "%s -> parsing time: %s" % (time.ctime(), (endtime-starttime))
        self.end_entry('message')
        if self._verbose == 1:
            print "%s -> %d errors found\n" % (time.ctime(), z) #--- debug ---
        # save last byte number
        try:
            self._client_log_file_fd.close()
        except IOError, e:
            if self._verbose == 1:
                print "%s -> Problem closing XML file: \"%s\" !" % (time.ctime(), e)
        self._last_byte_number = log_file_fd.tell()
    
    def start_entry(self, name):
        '''
        This function inserts a start tag into the XML file. (name = tag name)
        '''
        start_tag = "<%s>\n" % name
        try:
            self._client_log_file_fd.write(start_tag)
            return 0
        except IOError, e:
            if self._verbose == 1:
                print "%s -> Problem writing XML file: \"%s\" !" % (time.ctime(), e)
            return -1
        
    def write_entry(self, tagname, content):
        '''
        This function inserts an entry into the xml file.
        
        tagname = tag name
        content = message between start and end tag
        '''
       
        if len(content) < 50000000:
            #find all not allowed character  old: [\x09\x0a\x0d\x20-\xd7]*
            bad_character = re.sub('[\x09\x0a\x0d\x20-\x25\x27-\xd7]*', "", content)
            # replace each not allowed character with "?"
            for i in range(len(bad_character)):
                if bad_character[i] == '\x00':
                    # delete NUL character
                    content = content.replace(bad_character[i], '')
                else:
                    content = content.replace(bad_character[i], "?")
    
            entry = "<%s>%s</%s>\n" % (tagname, content, tagname)
            try:
                self._client_log_file_fd.write(entry)
                return 0
            except IOError, e:
                if self._verbose == 1:
                    print "%s -> Problem writing XML file: \"%s\" !" % (time.ctime(), e)
                return -1
            
        else:
            entry = "<%s>LOGFILE ENTRY TO LONG !!!</%s>\n" % (tagname, tagname)
            try:
                self._client_log_file_fd.write(entry)
                return 0
            except IOError, e:
                if self._verbose == 1:
                    print "%s -> Problem writing XML file: \"%s\" !" % (time.ctime(), e)
                return -1
        
    def end_entry(self, name):
        '''
        This function inserts an end tag into the XML file. (name = tag name)
        '''
        endtag = "</%s>\n" % name
        try:
            self._client_log_file_fd.write(endtag)
            return 0
        except IOError, e:
            if self._verbose == 1:
                print "%s -> Problem writing XML file: \"%s\" !" % (time.ctime(), e)
            return -1
        
    def reset(self):
        '''
        This function resets member variable, in case of a new log file.
        '''
        self._line_number = 1
        self._last_byte_number = 0
        
    def _test_keywords(self, keywordlist, amount_of_keywords, teststring):
        '''
        This is a recursive function, which tests if a list of keywords is part of a string (AND relation). If all keywords found 0 is returned, otherwise -1
        
        keywordlist = list of all keywords
        amount_of_keywords = number of keywords in list
        teststring = string, which needs to be investigated
        
        return -1 if line is not interesting
        return 0 if line is taken
        '''
        if (amount_of_keywords == 0):
            #last keyword check   -1 != content.rfind("NOTICE")
            if( 2 == len(keywordlist[amount_of_keywords])):
                if (-1 == teststring.rfind(keywordlist[amount_of_keywords][0])):
                    # not in string go to next keyword
                    return 0
                else:
                    if( -1 == keywordlist[amount_of_keywords][1].rfind("!")):
                        # check for NO keyword
                        temp = keywordlist[amount_of_keywords][1].strip("!")
                        if ( -1 == teststring.rfind(temp)):
                            # go on to next keyword
                            return 0
                        else:
                            return -1
                    else:
                        # there is no "!"
                        if ( -1 != teststring.rfind(keywordlist[amount_of_keywords][1])):
                            # string is there, go on to next keyword
                            return 0
                        else:
                            return -1
            else:
                if (-1 == teststring.rfind(keywordlist[amount_of_keywords][0])):
                    # not in string go to next keyword
                    return 0
                else:
                    return -1
        else:
            if( 2 == len(keywordlist[amount_of_keywords])):
                if (-1 == teststring.rfind(keywordlist[amount_of_keywords][0])):
                    # not in string go to next keyword
                    return self._test_keywords(keywordlist, amount_of_keywords-1, teststring)
                else:
                    if( -1 == keywordlist[amount_of_keywords][1].rfind("!")):
                        # check for NO keyword
                        temp = keywordlist[amount_of_keywords][1].strip("!")
                        if ( -1 == teststring.rfind(temp)):
                            # go on to next keyword
                            return self._test_keywords(keywordlist, amount_of_keywords-1, teststring)
                        else:
                            return -1
                    else:
                        # there is no "!"
                        if ( -1 != teststring.rfind(keywordlist[amount_of_keywords][1])):
                            # string is there, go on to next keyword
                            return self._test_keywords(keywordlist, amount_of_keywords-1, teststring)
                        else:
                            return -1
            else:
                if (-1 == teststring.rfind(keywordlist[amount_of_keywords][0])):
                    # not in string go to next keyword
                    return self._test_keywords(keywordlist, amount_of_keywords-1, teststring)
                else:
                    return -1

    def update_keywords(self, keys):
        '''
        This function updates the member variable keywords.
        
        keys = new keyword list
        '''
        self._keywords = keys
        
    def update_ignore_error(self, error):
        '''
        This function updates the ignore_error list.
        
        error = new ignore list
        '''
        self._ignore_error = error
        
    def _extract_time(self, time_string, year):
        '''
        This function takes a line from the logfile and extracts the time from there.
        '''
        if ( None == re.search('^NOTICE: *[A-Z][a-z]{2} +[0-9]{1,2} +[0-9]{2}:[0-9]{2}:[0-9]{2}:', time_string)):
            return -1
        else:
            listus = time_string.split(":")
            zeit = year+listus[1]+":"+listus[2]+":"+listus[3]
            time_tupel = time.strptime(zeit, "%Y %b %d %X")
            date_time = range(2)
            date_time[0] = time.strftime("%Y-%m-%d", time_tupel)
            date_time[1] = time.strftime("%H:%M:%S", time_tupel)
            return date_time

    def _extract_error_number(self, text):
        '''
        Thhis function takes a line from the logfile and extract the error number.
        '''
        match = re.search('(status|errno) *= *-*\d{1,10}', text)
        if(None != match):
            #if match then give me number
            listus = match.string[match.start():match.end()]
            listus = re.findall('-*\d{1,10}', listus)
            if(1 == len(listus)):
                return listus[0]
            else:
                return None
        else:
            return None

################## CLASS  MyParserThread  ##################

class MyParserThread(threading.Thread):
    '''
    This class is used to create a thread, which is doing all the necessery work in the background.
    '''
    def __init__(self, shared, timus, gz_path, logfilepath, logfilename, keyword, ignore_error, xml_file_path, xml_file_name, configfile, keywordfile, verbose):
        '''
        Constructor
        '''
        self._keywordfile = keywordfile
        temp = os.stat(self._keywordfile)
        self._keywordfile_time = temp[8]
        self._configfile = configfile
        temp = os.stat(self._configfile)
        self._configfile_time = temp[8]
        self._verbose = verbose
        self._id = thread.get_ident()
        self._shared_obj = shared
        self._interval = timus
        self._stop = 0
        threading.Thread.__init__(self)
        self._parser = LogFileParser (logfilepath, keyword, ignore_error, xml_file_path, xml_file_name, self._verbose)
        self._logfilepath = logfilepath
        self._log_file_name = logfilepath+"/"+logfilename
        self._gz_diect = gz_path
        self._list = [] #save *.gz files
        
    def run(self):
        '''
        This function overwrites the standard run method.
        '''
        block_counter = 0
        while(1):
            # acquire lock
            if self._stop == 1:
                print "%s -> working thread stopped !!!" % time.ctime()
                os._exit(0)
            # check if config file has changed
            if (self._configfile != ""):
                temp = os.stat(self._configfile)
                if self._configfile_time != temp[8]:
                    #if time has changed save new time
                    if self._verbose == 1:
                        print "%s -> config file has changed, reading new values ..." % time.ctime()
                    self._configfile_time = temp[8]
                    self._refresh_configuration()
                
            # check if keyword file has changed
            if (self._keywordfile != ''):
                temp = os.stat(self._keywordfile)
                if self._keywordfile_time != temp[8]:
                    #if time has changed
                    if self._verbose == 1:
                        print "%s -> keyword file has changed, reading new values ..." % time.ctime()
                    self._keywordfile_time = temp[8]
                    self._refresh_keywords()

            if(-1 == self._shared_obj.set_variable_parsing(1, self)):
                # client is busy
                block_counter += 1
                time.sleep(5*block_counter)
                if self._verbose == 1:
                    print "%s -> client busy" % time.ctime()
                if block_counter > 5:
                    if self._verbose == 1:
                        print "%s -> client needs a long time, miss this parsing period" % time.ctime()
                    block_counter = 0
                    time.sleep(self._interval*60)
            else:
                # no client busy
                try:
                    
                    # check if the first lines the same
                    if(0 == self._parser.test_first_lines(self._log_file_name)):
                        #if the first 15 lines still the same
                        if self._verbose == 1:
                            print "%s -> no log file rotation" % time.ctime()
                        self._parser.analyse_log_file(self._log_file_name)
                    else:
                        if self._verbose == 1:
                            print "%s -> new log file" % time.ctime()
                        # create gz file list
                        # empty list for the gz_files
                        self._list = []

                        os.path.walk(self._gz_diect, self.parse_directory, self._list)
                        if (0 < len(self._list)):
                            self.gunzip(self._list[0][1])
                            d = os.getcwd()
                            try:
                                os.chdir(self._gz_diect)
                                self.gunzip(self._list[0][1])    
                                self._parser.analyse_log_file(self._gz_diect+"/temp_srbLog")
                                delete_file("temp_srbLog", self._verbose)
                                os.chdir(d)
                            except:
                                if self._verbose == 1:
                                    print "%s -> could not find directory \"%s\"" % (time.ctime(), self._gz_diect)
                        else:
                            pass
                        
                        self._parser.reset()
                        self._parser.set_first_lines(self._log_file_name)
                        self._parser.analyse_log_file(self._log_file_name)
                    
                finally:
                    
                    # release lock
                    self._shared_obj.set_variable_parsing(0, self)
                        
            time.sleep(self._interval*60)#
                
            if self._verbose == 1:
                print "\n%s -> -------- parse ------" % time.ctime() #--- debug ---

    def _refresh_keywords(self):
        '''
        This function gets keywords from the keyword file !
        '''
        if(1 == os.path.exists(self._keywordfile)):
            keyword = get_keywords(self._keywordfile)
            self._parser.update_keywords(keyword)
            return 0
        else:
            # if file NOT use old configuration
            if self._verbose == 1:
                print "%s -> Sorry, the keyword file does NOT exist !\nUsing old configuration!\n\n" % time.ctime()
            return -1
                
    def _refresh_configuration(self):
        '''
        This function gets the needed information from the configfile!
        '''
        if(1 == os.path.exists(self._configfile)):
            config = LoadConfig(self._configfile)
            error = config.get("misc.ignore_error")
            error = error.strip()
            error = error.strip(",")
            ignore_error = error.split(",")
            for i in range(len(ignore_error)):
                # check if there is an entry at all
                if ignore_error[i] != '':
                    try:
                        ignore_error[i] = int(ignore_error[i].strip())
                    except ValueError:
                        if self._verbose == 1:
                            print "%s -> \"ignore_error\" in the config file has NO valid values, use old configuration" % time.ctime()
                            return -1
                else:
                    del ignore_error[i]
            
            self._parser.update_ignore_error(ignore_error)        
            
            return 0
        else:
            # if file NOT exists terminate program
            if self._verbose == 1:
                print "%s -> Sorry, the given config file does NOT exist !\nUsing old configuration!\n\n" % time.ctime()
            return -1

    def stop_thread(self):
        """
        Stop the thread
        """
        self._stop = 1

    def parse_directory(self, arg, dirname, fnames):
        '''
        This function "walks" through a given directory and considers all srbLOG*.gz files. The name and last modified time are saved in a list (2 dimensional array). The function should be used with os.path.walk(path, function_name, arg)!
        '''
        d = os.getcwd()
        # change into log file directory
        try:
            os.chdir(dirname)
        except:
            if self._verbose == 1:
                print "%s -> could not find directory \"%s\"" % (time.ctime(), dirname)
            return -1
        # for each file   
        for f in fnames:
            # check if file and if file is a log file e.g. srbLog.20051003.gz
            if (not os.path.isfile(f)) or (None == re.search('^srbLog[_0-9.-]*.gz', f)):
                continue
            # get last modified time
            date = os.stat(f)[stat.ST_MTIME]
            # create tupel
            tupel = (date, f)
            # save last modified time and filename into am arrray (list)
            self._list.append(tupel)
        # change back into the working directory
        os.chdir(d)
        # sort list ascending (aufsteigend)
        self._list.sort() 
        # reverse list order, sorted descending (absteigend), the greater the time number the younger the file
        self._list.reverse()
        return 0

    def gunzip(self, filus, name_temp_file="temp_srbLog"):
        '''
        This function unzips a *.gz file using the system tool gunzip. Make sure when calling the function the file exists in this directory. The function creates a temporary file and leave the orignal *.gz file untouched!
        '''
        if (not os.path.isfile(filus)):
            return -1
        else:
            command = "gunzip -c %s > %s" % (filus, name_temp_file)
            try:
                os.system(command)
                return 0
            except:
                return -1

##########################  C L A S S   M U T E X    #######################

class Mutex:
    '''
    This class makes sure that server and client are not accessing the same file at the same time.
    '''
    # lock
    _locked = threading.Lock()
    
    
    def __init__(self):
        '''
        Constructor
        '''
        self.parsing = 0
        self._parsing_thread_id = 0
        self.client = 0
        
        
    def set_variable_parsing(self, value, the_thread):
        '''
        set variable parsing
        '''
        Mutex._locked.acquire()  # lock
        self._parsing_thread_id = the_thread

        if self.client == 0:
            #set variable
            self.parsing = value
            Mutex._locked.release()
            time.sleep(1)
            if value == 0:
                # reset parsing thread identity
                self._parsing_thread_id = 0
            return 0
        else:
            Mutex._locked.release()   # release lock
            time.sleep(1)
            return -1
           
    def set_variable_client(self, value):
        '''
        set variable client
        '''
        Mutex._locked.acquire()  # lock
        # if client is not fetching the file
        if self.parsing == 0:
            #set variable
            self.client = value
            #print "client variable gesetzt"
            Mutex._locked.release()   # release lock
            time.sleep(1)
            return 0
        else:
            if (0 != self._parsing_thread_id):
                if (1 != self._parsing_thread_id.isAlive()):
                    # if parsing thread dead, reset semphore
                    self.parsing = 0
                    self._parsing_thread_id = 0
            Mutex._locked.release()   # release lock
            time.sleep(1)
            return -1
 
########################   C L A S S     R P C     #######################
 
class RPC:
    '''
    This class contains the RPC functions.
    '''
    def __init__(self, verbose, semaphore, config_file, interval, keyword_path, keyword_name, xml_file_path):
        '''
        constructor
        '''
        self._verbose = verbose
        self._client = True
        self._share = semaphore
        self._config_file = config_file
        self._interval = interval
        self._keyword_path = keyword_path
        self._keyword_name = keyword_name
        self._xml_file_path = xml_file_path
        
        self._list = [] #for walking through the directory
        
    def rpc_stop_server(self):
        '''
        This function stops the server!
        '''
        command = "./stop_server"
        
        answer = os.system(command)
        print answer
        return answer
            
    def rpc_disable_rpc_calls(self):
        '''
        This function disables rpc.
        '''
        self._client = False
        if self._verbose == 1:
            print "%s -> RPC through \"admin tool\" disabled!" % time.ctime()
        return "RPC disabled"
            
    def rpc_enable_rpc_calls(self):
        '''
        This function enables rpc.
        '''
        self._client = True
        if self._verbose == 1:
            print "%s -> RPC through \"admin tool\" enabled!" % time.ctime()
        return "RPC enabled"
    
    def rpc_status(self):
        '''
        This function return the current status of the self._client variable.
        '''
        if self._client == True:
            return "RPC enabled"
        else:
            return "RPC disabled"
        
    def rpc_interval_status(self):
        '''
        This function returns the current parsing interval time.
        '''
        if self._client == True:
            return self._interval
        else:
            return -2
    
    def rpc_get_my_xml_file(self, filename):
        '''
        This functions gets the xml file from the server !
        '''
        if (self._client == True):
            if (0 == self._share.set_variable_client(1)):
                # check if file is available
                try:
                    filus = self._xml_file_path+"/"+filename
                    client_xml_fd = open(filus, 'r')
                    file_content = client_xml_fd.read()
                    client_xml_fd.close()
                except  IOError:
                    self._share.set_variable_client(0)
                    return "no file"
                #delete xml file
                if (0 == delete_file((self._xml_file_path+"/"+filename), self._verbose)):
                    self._share.set_variable_client(0) # reset variable
                    return file_content
                else:
                    if self._verbose == 1:
                        print "problems deleting file"
                    self._share.set_variable_client(0)
                    return -1
            else:
                return -3   # server is busy parsing
        else:
            return -2 # rpc disalbed

    def rpc_check_availabitity(self):
        '''
        This function check if the server is still in the parsing process.
        '''
        if (self._client == True):
            if (0 == self._share.set_variable_client(1)):
                return 0
            else:
                return -3
        else:
            return -2

    def rpc_get_file_list(self):
        '''
        This function walks through the *.xml directory and finds all files, which need to be fetched form the client.
        '''
        if (self._client == True):
            self._list = [] # empty list
            try:
                os.path.walk(self._xml_file_path, self._parse_directory, self._list)
                if (0 < len(self._list)):
                    return self._list
                else:
                    return 0
            except:
                return -1
        else:
            return -2 # rpc disalbed
        
    def rpc_update_configuration(self, section, key, value, action):
        '''
        This functions adds or deletes values in the config.ini.
        action:
        0 = delete
        1 = add
        2 = exchange
        4 = info
        '''
        print "section: ", section
        print "key: ", key
        print "value: ", value
        print "action: ", action
        if(self._client == True):
            try:
                config_fd = file(self._config_file, 'r+')
            except IOError, e:
                return "Problem -> %s" % e
            
            byte_count = 0
            
            while(1):
                byte_count = config_fd.tell()
                line = config_fd.readline()
                if line == '':
                    if self._verbose == 1:
                        print "%s -> Section: \"%s\" and key: \"%s\" do not exist in config file!" % (time.ctime(), section, key)
                    config_fd.close()
                    return "Section: \"%s\" and key: \"%s\" do not exist in config file!" % (section, key)
                if (-1 != line.find(section)):
                    while(1):
                        byte_count = config_fd.tell()
                        line = config_fd.readline()
                        if line == '':
                            if self._verbose == 1:
                                print "%s -> Key: \"%s\" do not exist under section \"%s\" in config file!" % (time.ctime(), key, section)
                            config_fd.close()
                            return "Key \"%s\" do not exist under section \"%s\" in config file!" % (key, section)
                        if (-1 != line.find(key) and -1 != line.find("=") and -1 == line.find("#", 0, 1)):
                            if action == 0:
                                if self._verbose == 1:
                                    print "%s -> Delete \"%s:%s\" value \"%s\"" % (time.ctime(), section, key, value)
                                listus = line.split("=")
                                listus[1] = listus[1].strip()
                                listus[1] = listus[1].strip(",")
                                listus = listus[1].split(",")
                                for i in range(len(listus)):
                                    listus[i] = listus[i].strip()
                                new_content = ''
                                for i in range(len(listus)):
                                    if int(listus[i]) != value:                      
                                        new_content = new_content+"%s, " % listus[i]
                                        
                                new_content = new_content.strip()
                                new_content = new_content.strip(",")
                                new_content = "%s = %s\n" % (key, new_content)
                                rest = config_fd.read()
                                config_fd.truncate(byte_count)
                                config_fd.seek(byte_count)                            
                                config_fd.writelines(new_content)
                                config_fd.write(rest)
                                config_fd.close()                            
                                return "Changes applied: %s" % new_content                            
                            elif action == 1:
                                if self._verbose == 1:
                                    print "%s -> Add \"%s:%s\" value \"%s\"" % (time.ctime(), section, key, value)
                                listus = line.split("=")
                                listus[1] = listus[1].strip()
                                listus[1] = listus[1].strip(",")
                                listus = listus[1].split(",")
                                finish = 0
                                while (finish == 0):
                                    if len(listus) == 0:
                                        finish = 1
                                    for i in range(len(listus)):
                                        finish = 1 # break the while loop
                                        print listus[i]
                                        listus[i] = listus[i].strip()
                                        
                                        try:
                                            print "test auf int"
                                            temp_value = int(listus[i])
                                            if value == temp_value:
                                                config_fd.close()
                                                return "Value %d already exists!" % value
                                        except ValueError, e:
                                            finish = 0 # activate while loop
                                            print e, listus[i]
                                            del listus[i]
                                            break
                                    
                                    
                                new_content = ''
                                for i in range(len(listus)):
                                    new_content = new_content+"%s, " % listus[i]
                                new_content = "%s = %s%s\n" % (key, new_content, value)
                                rest = config_fd.read()
                                config_fd.truncate(byte_count)
                                config_fd.seek(byte_count)                            
                                config_fd.writelines(new_content)
                                config_fd.write(rest)
                                config_fd.close()
                                return "Changes applied: %s" % new_content
                            elif action == 2:
                                # exchange
                                if self._verbose == 1:
                                    print "%s -> Change \"%s:%s\" to value \"%s\"" % (time.ctime(), section, key, value)
                                rest = config_fd.read()
                                config_fd.truncate(byte_count)
                                config_fd.seek(byte_count)
                                new_content = "%s = %s\n" % (key, value)
                                config_fd.writelines(new_content)
                                config_fd.write(rest)
                                config_fd.close()
                                if section == 'misc' and key == 'minute':
                                    self._interval = int(value)
                                return 0
                            elif action == 4:
                                config_fd.close()
                                return line
                            else:
                                config_fd.close()
                                return -1
        else:
            return "RPC disabled" # rpc disalbed
        
    def rpc_update_keyword_file(self, keyword, action):
        '''
        This function updates the keyword file.
        
        action:
        0 = delete
        1 = add
        2 = info
        '''
        if(self._client == True):
            byte_count = 0
            file_size = 0
            comments = ''
    
            filus = self._keyword_path+"/"+self._keyword_name
    
            try:
                key_fd = file(filus, 'r+')
            except IOError, e:
                if self._verbose == 1:
                    print "%s -> Problem open keyword file -> %s !" % (time.ctime(), e)
                return "Problem -> %s" % e
    
            key_fd.seek(0, 2) # set cursor to end of file
            file_size = key_fd.tell()
            key_fd.seek(0) # set cursor to begining of file
    
            while(1):
                # get comments 
                byte_count = key_fd.tell()
                line = key_fd.readline()
                if byte_count >= file_size:
                    break
                if (-1 != line.find("#", 0, 1)):
                    comments += line
            
            key_fd.close()
            keyword_list = get_keywords(filus)
            keyword = keyword.split(":")
            
            if action == 0:
                # test if keyword is already there
                for i in range(len(keyword_list)):
                    if 1 == len(keyword) and 1 == len(keyword_list[i]):
                        if keyword[0] == keyword_list[i][0]:
                            del keyword_list[i]
                            try:
                                key_fd = file(filus, 'w+')
                                print key_fd
                                key_string = list_to_string(keyword_list)
                                key_fd.write(comments)
                                key_fd.write(key_string)
                                key_fd.close()                            
                            except IOError, e:
                                if self._verbose == 1:
                                    print "%s -> Problem open keyword file -> %s !" % (time.ctime(), e)
                                return "Problem -> %s" % e                        
                            return "keyword %s from keyword list deleted" % keyword
                    elif 2 == len(keyword) and 2 == len(keyword_list[i]):
                        if keyword[0] == keyword_list[i][0] and keyword[1] == keyword_list[i][1]:
                            del keyword_list[i]
                            try:
                                key_fd = file(filus, 'w+')
                                key_string = list_to_string(keyword_list)
                                key_fd.write(comments)
                                key_fd.write(key_string)
                                key_fd.close()                                                        
                            except IOError, e:
                                if self._verbose == 1:
                                    print "%s -> Problem open keyword file -> %s !" % (time.ctime(), e)
                                return "Problem -> %s" % e                        
                            return "keyword %s from keyword list deleted" % keyword
                        
                return "keyword %s was not part of keyword list" % keyword
                
            if action == 1:
                # test if keyword is already there
                for i in range(len(keyword_list)):
                    if 1 == len(keyword) and 1 == len(keyword_list[i]):
                        if keyword[0] == keyword_list[i][0]:
                            return "keyword %s already in keyword list" % keyword
                    elif 2 == len(keyword) and 2 == len(keyword_list[i]):
                        if keyword[0] == keyword_list[i][0] and keyword[1] == keyword_list[i][1]:
                            return "keywords %s already in keyword list" % keyword
    
                keyword_list.append(keyword)
                try:
                    key_fd = file(filus, 'w+')
                except IOError, e:
                    if self._verbose == 1:
                        print "%s -> Problem open keyword file -> %s !" % (time.ctime(), e)
                    return "Problem -> %s" % e
                
                key_string = list_to_string(keyword_list)
                key_fd.write(comments)
                key_fd.write(key_string)
                key_fd.close()
                    
                return key_string
            
            if action == 2:
                return list_to_string(keyword_list)
        
        else:
            return "RPC disabled"

    def _parse_directory(self, arg, dirname, fnames):
        '''
        This function "walks" through a given directory and looks for the client_log.xml file. The name and last modified time are saved in a list (2 dimensional array). The function should be used with os.path.walk(path, function_name, arg)!
        
        dirname = directory which need to be pared
        fnames = files within dirname
        '''
        d = os.getcwd()
        # change into log file directory
        try:
            os.chdir(dirname)
        except:
            if self._verbose == 1:
                print "could not find directory \"%s\"" % dirname
            return -1
        # for each file   
        for f in fnames:
            # check if file and if file is a log file e.g. client_log.xml
            if (not os.path.isfile(f)) or (None == re.search('client_log.xml', f)):
                continue
            else:
            # save filename into an arrray (list)
                self._list.append(f)
        # change back into the working directory
        os.chdir(d)

---