diff --git a/TestON/core/teston.py b/TestON/core/teston.py
new file mode 100644
index 0000000..73997f4
--- /dev/null
+++ b/TestON/core/teston.py
@@ -0,0 +1,758 @@
+#!/usr/bin/env python
+'''
+Created on 22-Oct-2012
+    
+@author: Anil Kumar (anilkumar.s@paxterrasolutions.com)
+
+
+    TestON 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.
+
+    TestON is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with TestON.  If not, see <http://www.gnu.org/licenses/>.		
+
+
+
+teston is the main module.
+
+'''
+
+import sys
+import getpass
+import os
+import re
+import __builtin__
+import new
+import xmldict
+module = new.module("test")
+import openspeak
+global path, drivers_path, core_path, tests_path,logs_path
+path = re.sub("(core|bin)$", "", os.getcwd())
+drivers_path = path+"drivers/"
+core_path = path+"core"
+tests_path = path+"tests"
+logs_path = path+"logs/"
+config_path = path + "config/"
+sys.path.append(path)
+sys.path.append( drivers_path)
+sys.path.append(core_path )
+sys.path.append(tests_path)
+
+from core.utilities import Utilities
+
+import logging 
+import datetime
+from optparse import OptionParser
+
+class TestON:
+    '''
+    
+    TestON will initiate the specified test. 
+    The main tasks are : 
+    * Initiate the required Component handles for the test. 
+    * Create Log file  Handles.
+    
+    '''
+    def __init__(self,options):
+        '''
+           Initialise the component handles specified in the topology file of the specified test.
+          
+        '''
+        # Initialization of the variables.
+        __builtin__.main = self
+        
+        __builtin__.path = path
+        __builtin__.utilities = Utilities()
+        self.TRUE = 1
+        self.FALSE = 0
+        self.ERROR = -1
+        self.FAIL = False
+        self.PASS = True
+        self.CASERESULT = self.TRUE
+        self.init_result = self.TRUE
+        self.testResult = "Summary"
+        self.stepName =""
+        self.EXPERIMENTAL_MODE = False   
+        self.test_target = None
+        self.lastcommand = None
+        self.testDir = tests_path 
+        self.configFile = config_path + "teston.cfg" 
+        self.parsingClass = "xmlparser"
+        self.parserPath = core_path + "/xmlparser"
+        self.loggerPath = core_path + "/logger"
+        self.loggerClass = "Logger"
+        self.logs_path = logs_path
+        self.driver = ''
+        
+        self.configparser()
+        verifyOptions(options)
+        load_logger()
+        self.componentDictionary = {}
+        self.componentDictionary = self.topology ['COMPONENT']
+        self.driversList=[]
+        if type(self.componentDictionary) == str :
+            self.componentDictionary = dict(self.componentDictionary)
+            
+        for component in self.componentDictionary :
+            self.driversList.append(self.componentDictionary[component]['type'])
+            
+        self.driversList = list(set(self.driversList)) # Removing duplicates.
+        # Checking the test_target option set for the component or not
+        if type(self.componentDictionary) == dict:
+            for component in self.componentDictionary.keys():
+                if 'test_target' in self.componentDictionary[component].keys():
+                    self.test_target = component
+             
+        # Checking for the openspeak file and test script 
+        self.logger.initlog(self)
+
+        # Creating Drivers Handles
+        initString = "\n"+"*" * 30+"\n CASE INIT \n"+"*" * 30+"\n"
+        self.log.exact(initString)
+        self.driverObject = {}
+        self.random_order = 111 # Random order id to connect the components
+        components_connect_order = {}
+        #component_list.append()
+        if type(self.componentDictionary) == dict:
+            for component in self.componentDictionary.keys():
+                self.componentDictionary[component]['connect_order'] = self.componentDictionary[component]['connect_order'] if ('connect_order' in self.componentDictionary[component].keys()) else str(self.get_random())
+                components_connect_order[component] =  eval(self.componentDictionary[component]['connect_order'])
+            #Ordering components based on the connect order.
+            ordered_component_list =sorted(components_connect_order, key=lambda key: components_connect_order[key])
+            print ordered_component_list
+            
+            for component in ordered_component_list:
+                self.componentInit(component)
+
+    def configparser(self):
+        '''
+        It will parse the config file (teston.cfg) and return as dictionary
+        '''
+        matchFileName = re.match(r'(.*)\.cfg', self.configFile, re.M | re.I)
+        if matchFileName:
+            xml = open(self.configFile).read()
+            try :
+                self.configDict = xmldict.xml_to_dict(xml)
+                return self.configDict
+            except :
+                print "There is no such file to parse " + self.configFile
+                        
+    def componentInit(self,component):
+        '''
+        This method will initialize specified component
+        '''
+        global driver_options
+        self.log.info("Creating component Handle: "+component)
+        driver_options = {}         
+        if 'COMPONENTS' in self.componentDictionary[component].keys():
+            driver_options =dict(self.componentDictionary[component]['COMPONENTS'])
+
+        driver_options['name']=component
+        driverName = self.componentDictionary[component]['type']
+        driver_options ['type'] = driverName
+        
+        classPath = self.getDriverPath(driverName.lower())
+        driverModule = __import__(classPath, globals(), locals(), [driverName.lower()], -1)
+        driverClass = getattr(driverModule, driverName)
+        driverObject = driverClass()
+         
+        connect_result = driverObject.connect(user_name = self.componentDictionary[component]['user'] if ('user' in self.componentDictionary[component].keys()) else getpass.getuser(),
+                                              ip_address= self.componentDictionary[component]['host'] if ('host' in self.componentDictionary[component].keys()) else 'localhost',
+                                              pwd = self.componentDictionary[component]['password'] if ('password' in self.componentDictionary[component].keys()) else 'changeme',
+                                              port = self.componentDictionary[component]['port'] if ('port' in self.componentDictionary[component].keys()) else None,
+                                              options = driver_options)
+        if not connect_result:
+            self.log.error("Exiting form the test execution because the connecting to the "+component+" component failed.")
+            self.exit() 
+            
+        vars(self)[component] = driverObject
+                        
+    def run(self):
+        '''
+           The Execution of the test script's cases listed in the Test params file will be done here. 
+           And Update each test case result. 
+           This method will return TRUE if it executed all the test cases successfully, 
+           else will retun FALSE
+        '''
+        
+        self.testCaseResult = {}
+        self.TOTAL_TC_RUN = 0
+        self.TOTAL_TC_NORESULT = 0
+        self.TOTAL_TC_FAIL = 0
+        self.TOTAL_TC_PASS = 0
+        self.stepCount = 0
+        self.CASERESULT = self.TRUE
+        
+        import testparser
+        testFile = self.tests_path + "/"+self.TEST + "/"+self.TEST + ".py"
+        test = testparser.TestParser(testFile)
+        self.testscript = test.testscript
+        self.code = test.getStepCode()
+        
+        result = self.TRUE
+        for self.CurrentTestCaseNumber in self.testcases_list:
+            result = self.runCase(self.CurrentTestCaseNumber)
+        return result
+    
+    def runCase(self,testCaseNumber):
+        self.CurrentTestCaseNumber = testCaseNumber
+        result = self.TRUE
+        self.stepCount = 0
+        self.EXPERIMENTAL_MODE = self.FALSE
+        self.addCaseHeader()
+        self.testCaseNumber = str(testCaseNumber)
+        stopped = False
+        try :
+            self.stepList = self.code[self.testCaseNumber].keys()
+        except KeyError,e:
+            main.log.error("There is no Test-Case "+ self.testCaseNumber)
+            return main.FALSE
+        
+        self.stepCount = 0
+        while self.stepCount < len(self.code[self.testCaseNumber].keys()):
+            result = self.runStep(self.stepList,self.code,self.testCaseNumber)
+            if result == main.FALSE:
+                break
+            elif result == main.TRUE :
+                continue
+            
+        if not stopped :
+            self.testCaseResult[str(self.CurrentTestCaseNumber)] = self.CASERESULT
+            self.logger.updateCaseResults(self)
+        return result
+    
+    def runStep(self,stepList,code,testCaseNumber):
+        if not cli.pause:
+            try :
+                step = stepList[self.stepCount]
+                exec code[testCaseNumber][step] in module.__dict__
+                self.stepCount = self.stepCount + 1
+            except TypeError,e:
+                self.stepCount = self.stepCount + 1
+                self.log.error(e)
+            return main.TRUE
+        
+        if cli.stop:
+            cli.stop = False
+            stopped = True
+            self.TOTAL_TC_NORESULT = self.TOTAL_TC_NORESULT + 1
+            self.testCaseResult[str(self.CurrentTestCaseNumber)] = "Stopped"
+            self.logger.updateCaseResults(self)
+            result = self.cleanup()
+            return main.FALSE
+        
+    def addCaseHeader(self):
+        caseHeader = "\n"+"*" * 30+"\n Result summary for Testcase"+str(self.CurrentTestCaseNumber)+"\n"+"*" * 30+"\n"
+        self.log.exact(caseHeader) 
+        caseHeader = "\n"+"*" * 40 +"\nStart of Test Case"+str(self.CurrentTestCaseNumber)+" : " 
+        for driver in self.componentDictionary.keys():
+            vars(self)[driver+'log'].info(caseHeader)
+    
+    def addCaseFooter(self):
+        if self.stepCount-1 > 0 :
+            previousStep = " "+str(self.CurrentTestCaseNumber)+"."+str(self.stepCount-1)+": "+ str(self.stepName) + ""
+            stepHeader = "\n"+"*" * 40+"\nEnd of Step "+previousStep+"\n"+"*" * 40+"\n"
+            
+        caseFooter = "\n"+"*" * 40+"\nEnd of Test case "+str(self.CurrentTestCaseNumber)+"\n"+"*" * 40+"\n"
+            
+        for driver in self.driversList:
+            vars(self)[driver].write(stepHeader+"\n"+caseFooter)
+
+    def cleanup(self):
+        '''
+           Release all the component handles and the close opened file handles.
+           This will return TRUE if all the component handles and log handles closed properly,
+           else return FALSE
+
+        '''
+        result = self.TRUE
+        self.logger.testSummary(self)
+        
+        #self.reportFile.close()
+        
+
+        utilities.send_mail()
+        try :
+            for component in self.componentDictionary.keys():
+                tempObject  = vars(self)[component]    
+                print "Disconnecting "+str(tempObject)
+         
+                tempObject.disconnect()
+            #tempObject.execute(cmd="exit",prompt="(.*)",timeout=120) 
+
+        except(Exception):
+            #print " There is an error with closing hanldes"
+            result = self.FALSE
+        # Closing all the driver's session files
+        for driver in self.componentDictionary.keys():
+           vars(self)[driver].close_log_handles()
+           
+        print( "CLEAN!" )
+        return result
+        
+    def pause(self):
+        '''
+        This function will pause the test's execution, and will continue after user provide 'resume' command.
+        '''
+        __builtin__.testthread.pause()
+    
+    def onfail(self,*components):
+        '''
+        When test step failed, calling all the components onfail. 
+        '''
+         
+        if not components:
+            try :
+                for component in self.componentDictionary.keys():
+                    tempObject  = vars(self)[component]
+                    result = tempObject.onfail()
+            except(Exception),e:
+                print str(e)
+                result = self.FALSE
+                
+        else:
+            try :
+                for component in components:
+                    tempObject  = vars(self)[component]
+                    result = tempObject.onfail()
+            except(Exception),e:
+                print str(e)
+                result = self.FALSE
+    
+    
+    def getDriverPath(self,driverName):
+        '''
+           Based on the component 'type' specified in the params , this method will find the absolute path ,
+           by recursively searching the name of the component.
+        '''
+        import commands
+
+        cmd = "find "+drivers_path+" -name "+driverName+".py"
+        result = commands.getoutput(cmd)
+        
+        result_array = str(result).split('\n')
+        result_count = 0
+        
+        for drivers_list in result_array:
+            result_count = result_count+1
+        if result_count > 1 :
+            print "found "+driverName+" "+ str(result_count) + "  times"+str(result_array)
+            self.exit()
+            
+        result = re.sub("(.*)drivers","",result)
+        result = re.sub("\.py","",result)
+        result = re.sub("\.pyc","",result)
+        result = re.sub("\/",".",result)
+        result = "drivers"+result
+        return result
+    
+
+    def step(self,stepDesc):
+        '''
+           The step information of the test-case will append to the logs.
+        '''
+        previousStep = " "+str(self.CurrentTestCaseNumber)+"."+str(self.stepCount-1)+": "+ str(self.stepName) + ""
+        self.stepName = stepDesc
+
+        stepName = " "+str(self.CurrentTestCaseNumber)+"."+str(self.stepCount)+": "+ str(stepDesc) + ""
+        try :
+            if self.stepCount == 0:
+                stepName = " INIT : Initializing the test case :"+self.CurrentTestCase
+        except AttributeError:
+                stepName = " INIT : Initializing the test case :"+str(self.CurrentTestCaseNumber)
+            
+        self.log.step(stepName)
+        stepHeader = ""
+        if self.stepCount > 1 :
+            stepHeader = "\n"+"-"*45+"\nEnd of Step "+previousStep+"\n"+"-"*45+"\n"
+        
+        stepHeader += "\n"+"-"*45+"\nStart of Step"+stepName+"\n"+"-"*45+"\n" 
+        for driver in self.componentDictionary.keys():
+            vars(self)[driver+'log'].info(stepHeader)
+            
+    def case(self,testCaseName):
+        '''
+           Test's each test-case information will append to the logs.
+        '''
+        self.CurrentTestCase = testCaseName 
+        testCaseName = " " + str(testCaseName) + ""
+        self.log.case(testCaseName)
+        caseHeader = testCaseName+"\n"+"*" * 40+"\n" 
+        for driver in self.componentDictionary.keys():
+            vars(self)[driver+'log'].info(caseHeader)
+        
+    def testDesc(self,description):
+        '''
+           Test description will append to the logs.
+        '''
+        description = "Test Description : " + str (description) + ""
+        self.log.info(description)
+        
+    def _getTest(self):
+        '''
+           This method will parse the test script to find required test information.
+        '''
+        testFile = self.tests_path + "/"+self.TEST + "/"+self.TEST + ".py"
+        testFileHandler = open(testFile, 'r')
+        testFileList = testFileHandler.readlines()
+        testFileHandler.close()
+        #self.TOTAL_TC_PLANNED = 0
+        counter = 0
+        for index in range(len(testFileList)):
+            lineMatch = re.match('\s+def CASE(\d+)(.*):',testFileList[index],0)
+            if lineMatch:
+                counter  = counter + 1
+                self.TOTAL_TC_PLANNED = counter
+                
+    def response_parser(self,response, return_format):
+        ''' It will load the default response parser '''
+        response_dict = {}
+        response_dict = self.response_to_dict(response, return_format)
+        return_format_string = self.dict_to_return_format(response,return_format,response_dict)   
+        return return_format_string
+    
+    def response_to_dict(self,response,return_format):
+        
+        response_dict = {}
+        json_match = re.search('^\s*{', response)
+        xml_match = re.search('^\s*\<', response)
+        ini_match = re.search('^\s*\[', response)
+        if json_match :
+            main.log.info(" Response is in 'JSON' format and Converting to '"+return_format+"' format")
+            # Formatting the json string 
+            
+            response = re.sub(r"{\s*'?(\w)", r'{"\1', response)
+            response = re.sub(r",\s*'?(\w)", r',"\1', response)
+            response = re.sub(r"(\w)'?\s*:", r'\1":', response)
+            response = re.sub(r":\s*'(\w)'\s*([,}])", r':"\1"\2', response)
+            
+            try :
+                import json
+                response_dict = json.loads(response)
+            except Exception , e :
+                print e
+                main.log.error("Json Parser is unable to parse the string")
+            return response_dict
+        
+        elif ini_match :
+            main.log.info(" Response is in 'INI' format and Converting to '"+return_format+"' format")
+            from configobj import ConfigObj
+            response_file = open("respnse_file.temp",'w')
+            response_file.write(response)
+            response_file.close() 
+            response_dict = ConfigObj("respnse_file.temp")
+            return response_dict
+            
+        elif xml_match :
+            main.log.info(" Response is in 'XML' format and Converting to '"+return_format+"' format")
+            try :
+                from core import dicttoobject
+                response_dict = xmldict.xml_to_dict("<response> "+str(response)+" </response>")
+            except Exception, e:
+                main.log.error(e)
+            return response_dict
+        
+    def dict_to_return_format(self,response,return_format,response_dict):
+        
+        if return_format =='table' :
+            ''' Will return in table format'''
+            to_do = "Call the table output formatter"
+            global response_table
+            response_table = '\n'
+            response_table = response_table +'\t'.join(response_dict)+"\n"
+            
+            def get_table(value_to_convert):
+                ''' This will parse the dictionary recusrsively and print as table format'''
+                table_data = ""
+                if type(value_to_convert) == dict :
+                    table_data = table_data +'\t'.join(value_to_convert)+"\n"
+                    for temp_val in value_to_convert.values() :
+                        table_data = table_data + get_table(temp_val)
+                else :
+                    table_data = table_data + str(value_to_convert) +"\t"
+                return table_data 
+            
+            for value in response_dict.values() :
+                response_table =  response_table + get_table(value)
+                
+
+                
+            #response_table = response_table + '\t'.join(response_dict.values())
+                
+            return response_table
+        
+        elif return_format =='config':
+            ''' Will return in config format'''
+            to_do = 'Call dict to config coverter'
+            response_string = str(response_dict)
+            print response_string
+            response_config = re.sub(",", "\n\t", response_string)
+            response_config = re.sub("u\'", "\'", response_config)
+            response_config = re.sub("{", "", response_config)
+            response_config = re.sub("}", "\n", response_config)
+            response_config = re.sub(":", " =", response_config)
+            return "[response]\n\t "+response_config
+            
+        elif return_format == 'xml':
+            ''' Will return in xml format'''
+            from core import dicttoobject
+            response_xml = xmldict.dict_to_xml(response_dict)
+            response_xml = re.sub(">\s*<", ">\n<", response_xml)
+            return "\n"+response_xml
+        
+        elif return_format == 'json':
+            ''' Will return in json format'''
+            to_do = 'Call dict to xml coverter'
+            import json
+            response_json = json.dumps(response_dict)
+            return response_json
+    
+    def get_random(self):
+        self.random_order = self.random_order + 1
+        return self.random_order
+        
+    def exit(self):
+        __builtin__.testthread = None
+        sys.exit()
+
+def verifyOptions(options):
+    '''
+    This will verify the command line options and set to default values, if any option not given in command line.
+    '''
+    import pprint
+    pp = pprint.PrettyPrinter(indent=4)
+
+    #pp.pprint(options)
+    verifyTest(options)
+    verifyExample(options)
+    verifyTestScript(options)
+    verifyParams()
+    verifyLogdir(options)
+    verifyMail(options)
+    verifyTestCases(options)
+
+def verifyTest(options):
+    if options.testname:
+        main.TEST = options.testname
+        main.classPath = "tests."+main.TEST+"."+main.TEST
+        main.tests_path = tests_path
+    elif options.example :
+        main.TEST = options.example
+        main.tests_path = path+"/examples/"
+        main.classPath = "examples."+main.TEST+"."+main.TEST
+    else :
+        print "Test or Example not specified please specify the --test <test name > or --example <example name>"
+        self.exit()
+
+def verifyExample(options):
+    if options.example:
+        main.testDir = path+'/examples/'
+        main.tests_path = path+"/examples/"
+        main.classPath = "examples."+main.TEST+"."+main.TEST
+               
+def verifyLogdir(options):
+    #Verifying Log directory option      
+    if options.logdir:
+        main.logdir = options.logdir
+    else :
+        main.logdir = main.FALSE  
+        
+def verifyMail(options):
+    # Checking the mailing list 
+    if options.mail:
+        main.mail = options.mail
+    elif main.params.has_key('mail'):
+        main.mail = main.params['mail']
+    else :
+        main.mail = 'paxweb@paxterrasolutions.com'
+
+def verifyTestCases(options):
+    #Getting Test cases list 
+    if options.testcases:
+        testcases_list = re.sub("(\[|\])", "", options.testcases)
+        main.testcases_list = eval(testcases_list+",")
+    else :
+        if 'testcases' in main.params.keys():
+            main.params['testcases'] = re.sub("(\[|\])", "", main.params['testcases'])
+            if re.search('\d+', main.params['testcases'], 0):
+                main.testcases_list = eval(main.params['testcases']+",")
+            else :
+                print "Please provide the testcases list in Params file"
+                sys.exit()
+        else :
+            print "testcases not specifed in params, please provide in params file or 'testcases' commandline argument"
+            sys.exit() 
+                  
+def verifyTestScript(options):
+    '''
+    Verifyies test script.
+    '''
+    main.openspeak = openspeak.OpenSpeak()        
+    openspeakfile = main.testDir+"/" + main.TEST + "/" + main.TEST + ".ospk"
+    testfile = main.testDir+"/" + main.TEST + "/" + main.TEST + ".py"
+    if os.path.exists(openspeakfile) :
+        main.openspeak.compiler(openspeakfile=openspeakfile,writetofile=1)
+    elif os.path.exists(testfile):
+        print ''
+    else:
+        print "\nThere is no :\""+main.TEST+"\" test, Please Provide OpenSpeak Script/ test script"
+        __builtin__.testthread = None
+        main.exit()
+              
+    try :
+        testModule = __import__(main.classPath, globals(), locals(), [main.TEST], -1)
+    except(ImportError):
+        print "There is no test like "+main.TEST
+        main.exit()       
+
+    testClass = getattr(testModule, main.TEST)
+    main.testObject = testClass()
+    load_parser()
+    main.params = main.parser.parseParams(main.classPath)    
+    main.topology = main.parser.parseTopology(main.classPath) 
+    
+def verifyParams():
+    try :
+        main.params = main.params['PARAMS']
+    except(KeyError):
+        print "Error with the params file: Either the file not specified or the format is not correct"
+        main.exit()            
+    
+    try :
+        main.topology = main.topology['TOPOLOGY']
+    except(KeyError):
+        print "Error with the Topology file: Either the file not specified or the format is not correct"
+        main.exit()
+        
+def load_parser() :
+    '''
+    It facilitates the loading customised parser for topology and params file.
+    It loads parser mentioned in tab named parser of teston.cfg file.
+    It also loads default xmlparser if no parser have specified in teston.cfg file.
+
+    '''
+    confighash = main.configDict
+    if 'file' in confighash['config']['parser'] and 'class' in confighash['config']['parser']:
+        if confighash['config']['parser']['file'] != None or confighash['config']['parser']['class']!= None :
+            if os.path.exists(confighash['config']['parser']['file']) :
+                module = re.sub(r".py\s*$","",confighash['config']['parser']['file'])
+                moduleList = module.split("/")
+                newModule = ".".join([moduleList[len(moduleList) - 2],moduleList[len(moduleList) - 1]])
+                try :
+                    parsingClass = confighash['config']['parser']['class']
+                    parsingModule = __import__(newModule, globals(), locals(), [parsingClass], -1)
+                    parsingClass = getattr(parsingModule, parsingClass)
+                    main.parser = parsingClass()
+                    #hashobj = main.parser.parseParams(main.classPath)
+                    if hasattr(main.parser,"parseParams") and hasattr(main.parser,"parseTopology") and hasattr(main.parser,"parse") :
+                        
+                        pass
+                    else:
+                        main.exit()
+
+                except ImportError:
+                    print sys.exc_info()[1]
+                    main.exit()
+            else :
+                print "No Such File Exists !!"+ confighash['config']['parser']['file'] +"using default parser"
+                load_defaultParser() 
+        elif confighash['config']['parser']['file'] == None or confighash['config']['parser']['class'] == None :  
+            load_defaultParser() 
+    else:
+        load_defaultParser()
+
+def load_defaultParser():
+    '''
+    It will load the default parser which is xml parser to parse the params and topology file.
+    '''
+    moduleList = main.parserPath.split("/")
+    newModule = ".".join([moduleList[len(moduleList) - 2],moduleList[len(moduleList) - 1]])
+    try :
+        parsingClass = main.parsingClass 
+        parsingModule = __import__(newModule, globals(), locals(), [parsingClass], -1)
+        parsingClass = getattr(parsingModule, parsingClass)
+        main.parser = parsingClass()
+        if hasattr(main.parser,"parseParams") and hasattr(main.parser,"parseTopology") and hasattr(main.parser,"parse") :
+            pass
+        else:
+            main.exit()
+
+    except ImportError:
+        print sys.exc_info()[1]
+
+
+def load_logger() :
+    '''
+    It facilitates the loading customised parser for topology and params file.
+    It loads parser mentioned in tab named parser of teston.cfg file.
+    It also loads default xmlparser if no parser have specified in teston.cfg file.
+
+    '''
+    confighash = main.configDict
+    if 'file' in confighash['config']['logger'] and 'class' in confighash['config']['logger']:
+        if confighash['config']['logger']['file'] != None or confighash['config']['logger']['class']!= None :
+            if os.path.exists(confighash['config']['logger']['file']) :
+                module = re.sub(r".py\s*$","",confighash['config']['logger']['file'])
+                moduleList = module.split("/")
+                newModule = ".".join([moduleList[len(moduleList) - 2],moduleList[len(moduleList) - 1]])
+                try :
+                    loggerClass = confighash['config']['logger']['class']
+                    loggerModule = __import__(newModule, globals(), locals(), [loggerClass], -1)
+                    loggerClass = getattr(loggerModule, loggerClass)
+                    main.logger = loggerClass()
+                    #hashobj = main.parser.parseParams(main.classPath)
+
+                except ImportError:
+                    print sys.exc_info()[1]
+            else :
+                print "No Such File Exists !!"+confighash['config']['logger']['file']+ "Using default logger"
+                load_defaultlogger()
+        elif confighash['config']['parser']['file'] == None or confighash['config']['parser']['class'] == None :  
+            load_defaultlogger() 
+    else:
+        load_defaultlogger()
+
+def load_defaultlogger():
+    '''
+    It will load the default parser which is xml parser to parse the params and topology file.
+    '''
+    moduleList = main.loggerPath.split("/")
+    newModule = ".".join([moduleList[len(moduleList) - 2],moduleList[len(moduleList) - 1]])
+    try :
+        loggerClass = main.loggerClass 
+        loggerModule = __import__(newModule, globals(), locals(), [loggerClass], -1)
+        loggerClass = getattr(loggerModule, loggerClass)
+        main.logger = loggerClass()
+
+    except ImportError:
+        print sys.exc_info()[1]
+        main.exit()    
+
+def load_defaultlogger():
+    '''
+    It will load the default parser which is xml parser to parse the params and topology file.
+    '''
+    moduleList = main.loggerPath.split("/")
+    newModule = ".".join([moduleList[len(moduleList) - 2],moduleList[len(moduleList) - 1]])
+    try :
+        loggerClass = main.loggerClass 
+        loggerModule = __import__(newModule, globals(), locals(), [loggerClass], -1)
+        loggerClass = getattr(loggerModule, loggerClass)
+        main.logger = loggerClass()
+
+    except ImportError:
+        print sys.exc_info()[1]
+        main.exit()
+
+
+
+
+def _echo(self):
+    print "THIS IS ECHO"