WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/pyCanDaemon/Main.py


#!/bin/env python
 
import os
import sys
import logging as log
import getopt
import atexit
import time
 
from NodeIfBase import NodeIfBase
from NodeIfCanStim import NodeIfCanStim
from NodeIfSerial import NodeIfSerial
from NodeIfTCP import NodeIfTCP
 
from DaemonConfig import DaemonConfig
 
daemonApp = None
 
class CanDaemon():
   
    cfg = None
    ifNotifier = None
    terminated = False
   
    command_list = []
    command_map = {}
    CMDLIST_NAME = 0
    CMDLIST_HANDLER = 1
    CMDLIST_PARAMINFO = 2
    CMDLIST_HELP = 3
 
    logHelp = 'usage:\t log [options]\n\n' \
              '\t options:\n' \
              '\t level <num>, where: 0 < num < 3\n'
    stateHelp = 'usage: state [name/add/rem]'
    filterHelp = 'usage: filter [name/add/rem]'
    addifHelp = 'usage: addif [name] [options]'
    addbridgeHelp = 'usage: addbridge [interface names]'
    tcpdHelp = 'usage: tcpd [start/stop/configure] [options]'
    tlsdHelp = 'usage: tlsd [start/stop/configure] [options]'
    canctldHelp = 'usage: canctld [start/stop/configure] [options]'
    simHelp = 'usage: sim [record/play/add/rem/save/load] [options]'
    help_command_map = {}
   
    logOptions = {}
    ifOptions = {}
    bridgeOptions = {}
    tcpdOptions = {}
    tlsdOptions = {}
    canctldOptions = {}
    simOptions = {}
 
    logValidOptions = {'level' : ['range', 0, 3]}
    ifValidOptions = {'type' : ['alt', 'serial','udp']}
   
    ifSerialOptions = {'' : []}
    ifCanStimOptions = {'' : []}
    ifTelnetOptions = {'' : []}
    ifTcpTlsOptions = {'' : []}
    ifUDPOptions = {'' : []}
   
    bridgeValidOptions = {'' : ['']}
    tcpdValidOptions = {'' : []}
    tlsdValidOptions = {'' : []}
    canctldValidOptions = {'' : []}
    simValidOptions = {'' : []}
 
    def __init__ (self):
       
        self.command_list = [['help', self.helpCmd, '', 'display help'],
                       ['log', self.logCmd, '<options>', 'log control: \"help log\"'],
                       ['exec', self.execCmd, '<filename>', 'run command listing\n'],
                       ['filter', self.filterCmd, '<cmd>', 'filter commands: \"help filter\"'],
                       ['state', self.stateCmd, '<cmd>', 'state commands: \"help state\"\n'],
                       ['addif', self.ifAddCmd, '<options>', 'add interface: \"help addif\"'],
                       ['remif', self.ifRemCmd, '<name>', 'remove interface'],
                       ['ifup', self.ifUpCmd, '<name>', 'bring up interface'],
                       ['ifdown', self.ifDownCmd, '<name>', 'bring down interface\n'],
                       ['addbrigde', self.addBridgeCmd, '<options>', 'add bridge: \"help addbridge\"'],
                       ['rembridge', self.remBridgeCmd, '<id>', 'remove bridge\n'],
                       ['tcpd', self.tcpdCmd, '<cmd>', 'tcpd server control: \"help tcpd\"'],
                       ['tlsd', self.tlsdCmd, '<cmd>', 'tlsd server control: \"help tlsd\"'],
                       ['canctld', self.canCtldCmd, '<cmd>', 'canctld server control: \"help canctld\"\n'],
                       ['status', self.statusCmd, '', 'show daemon status'],
                       ['stats', self.statsCmd, '', 'show statistics'],
                       ['nodelist', self.nodesCmd, '', 'list can nodes\n'],
                       ['sim', self.simCmd, '<cmd>', 'simulator commands: \"help sim\"']]
       
        index = 0
        for cmd in self.command_list:
            self.command_map[cmd[0]] = index
            index += 1
 
        self.help_command_map = {'log' : self.logHelp,
                                'filter' : self.filterHelp,
                                'state' : self.stateHelp,
                                'addif' : self.addifHelp,
                                'addbridge' : self.addbridgeHelp,
                                'tcpd' : self.tcpdHelp,
                                'tlsd' : self.tlsdHelp,
                                'canctld' : self.canctldHelp,
                                'sim' : self.simHelp}
 
        self.cfg = DaemonConfig()
   
    class IfNotifier():
        """ Used by if threads to send messages to the main program thread """
       
        parent = None
        UNDEFINED = 0
        TERMINATE = 1
       
        def __init__(self, parent):
            self.parent = parent
   
        def notify(self, msg):
            if msg == self.TERMINATE:
                print 'Main terminate notify'
            else:
                print 'UNDEFINED NOTIFY'
       
   
    def __rightAdjust(self, refstr, str):
        spcstr = ''
        endpos = 25-len(refstr)
        for i in range(1,endpos):
            if i == endpos-5:
                spcstr += ':'
            else:
                spcstr += ' '
        return (spcstr+str)
   
    def helpCmd(self, *args):
        try:
            args = args[0]
        except:
            args = []
        if len(args) < 1:
            quitStr = 'quit, exit'
            print quitStr, self.__rightAdjust(quitStr, 'shutdown pyCanDaemon')
            for cmd in self.command_list:
                cmdstr = cmd[self.CMDLIST_NAME] + ' ' + cmd[self.CMDLIST_PARAMINFO]
                print cmdstr, \
                      self.__rightAdjust(cmdstr, cmd[self.CMDLIST_HELP])
        elif len(args) < 2:
            subCmd = args[0]
            if self.help_command_map.has_key(subCmd):
                print self.help_command_map[subCmd]
            else:
                print 'no help for ' + subCmd
        else:
            print 'usage: help [topic]'
 
    def filterCmd(self, *args):
        try:
            args = args[0]
        except:
            args = []
        log.debug('filterCmd ' + str(args))
        if len(args) < 2:
            print 'Invalid arguments\n' + self.filterHelp
            return
        cmd = args[0]
        filterName = args[1]
        # FIXME: verify 
        if cmd == 'add':
            print 'Importing filter: ' + filterName
            self.cfg.filterCfg.importFilter(filterName)
        elif cmd == 'rem' or cmd == 'remove':
            print 'Deleting filter: ' + filterName
            # FIXME: actually delete
            raise 'Not implemented'
   
    def stateCmd(self, *args):
        try:
            args = args[0]
        except:
            args = []
        log.debug('stateCmd ' + str(args))
        if len(args) < 2:
            print 'Invalid arguments\n' + self.stateHelp
            return
        cmd = args[0]
        spaceName = args[1]
        # FIXME: verify 
        if cmd == 'add':
            print 'Importing state space: ' + spaceName
            self.cfg.stateSpaceCfg.importSpace(spaceName)
        elif cmd == 'rem' or cmd == 'remove':
            print 'Deleting state space: ' + spaceName
            # FIXME: actually delete statespace
            raise 'Not implemented'
   
    def ifAddCmd(self, *args):
        raise 'not implemented'
   
    def ifRemCmd(self, *args):
        raise 'not implemented'
 
    def ifUpCmd(self, *args):
        raise 'not implemented'
 
    def ifDownCmd(self, *args):
        raise 'not implemented'
   
    def addBridgeCmd(self, *args):
        raise 'not implemented'
 
    def remBridgeCmd(self, *args):
        raise 'not implemented'
   
    def tcpdCmd(self, *args):
        raise 'not implemented'
   
    def tlsdCmd(self, *args):
        raise 'not implemented'
   
    def canCtldCmd(self, *args):
        raise 'not implemented'
   
    def statusCmd(self, *args):
        raise 'not implemented'
   
    def statsCmd(self, *args):
        raise 'not implemented'
   
    def nodesCmd(self, *args):
        raise 'not implemented'
   
    def simCmd(self, *args):
        raise 'not implemented'
   
    def logCmd(self, *args):
        raise 'not implemented'
 
    def execCmd(self, *args):
        raise 'not implemented'
   
    def parseCommand(self, cmdstr):
        incmd = cmdstr.strip()
        cmd = incmd.split(' ')
        if len(cmd[0]) < 2:
            return
        cmd[0] = cmd[0].lower()
        if cmd[0] == 'quit' or cmd[0] == 'exit':
            self.terminated = True
        elif self.command_map.has_key(cmd[0]):
            self.command_list[self.command_map[cmd[0]]][self.CMDLIST_HANDLER](cmd[1:])
        else:
            print 'unknown command: ' + cmd[0]
   
    def exitHelper(self):
        pass
#        if self.nodeIf is not None and self.nodeIf.running():
#            self.nodeIf.stop()
           
    def exceptHelper(self, type, value, tb):
        import traceback
        traceback.print_exception(type, value, tb)
        print '\nException in main program, shutting down threads'
        self.terminated = True
        self.exitHelper()
 
 
    def run(self):
        try:
            myPath = os.path.dirname(__file__)
            os.chdir(myPath)
        except:
            return
       
        print 'INIT: Start logging'
        log.basicConfig(level=log.DEBUG)
       
        """command parameters only dictate verbosity and use of config file"""
        print 'INIT: Get config options from command line / config file'
        try:
            opts, args = getopt.getopt(sys.argv[1:], "ho:v", ["help", "output="])
        except getopt.GetoptError:
            print 'Invalid usage'
            usage()
            sys.exit(2)
     #   output = None
     #   verbose = False
        for o, a in opts:
            if o == "-v":
                pass
     #           verbose = True
            if o in ("-h", "--help"):
                usage()
                sys.exit()
            if o in ("-o", "--output"):
                pass
    #            output = a
 
        """load config defaults, or last config if exists"""
        """run startup.cfg"""
        print 'INIT: Loading daemon configuration'
        self.cfg = DaemonConfig()
        self.cfg.load()
       
        # create interface for debugging purpose
        self.cfg.addInterface('tcp', None)
 
        self.ifNotifier = self.IfNotifier(self)        
        for nodeIf in self.cfg.nodeInterfaces:
            nodeIf.setIfNotifier(self.ifNotifier)
           
        atexit.register(self.exitHelper)
        sys.excepthook = self.exceptHelper
 
        print 'INIT: Starting configured node interfaces'
        for nodeIf in self.cfg.nodeInterfaces:
            if not nodeIf.start():
                print 'FATAL: Failed to initialize node interface.'
                print 'This may indicate that the interface is unavailable, ' \
                      'or that you do not have permission to access it.'
                sys.exit(-1)
 
        print 'INIT: Initialize/gather info on connected can nodes and load associated state'
        print 'INIT: Starting configured servers'
       
        print 'CanDaemon v1 ready'
        print 'Enter command or type \"help\" for a list of commands'
        while not self.terminated:
            input = raw_input('> ')
            self.parseCommand(input)
       
        print 'Shutdown'
        self.cfg.save()
       
        for nodeIf in self.cfg.nodeInterfaces:
            if nodeIf.running():
                print 'Stopping If thread'
                nodeIf.stop()
       
        print 'Waiting 0.1..'
        time.sleep(0.1) # wait for threads
        print 'Terminating'
        sys.exit(0) # will except if there are threads remaining
 
#---------------------------------------------------------------------------
 
def main():
    daemonApp = CanDaemon()
#    install_thread_excepthook()
    daemonApp.run()
 
#---------------------------------------------------------------------------
 
if __name__ == '__main__':
    __name__ = 'Main'
    main()
 

Rev 749	Rev 750
1	#!/bin/env python	1	#!/bin/env python
2		2
3	import os	3	import os
4	import sys	4	import sys
5	import logging as log	5	import logging as log
6	import getopt	6	import getopt
7	import atexit	7	import atexit
8	import time	8	import time
9		9
10	from NodeIfBase import NodeIfBase	10	from NodeIfBase import NodeIfBase
11	from NodeIfCanStim import NodeIfCanStim	11	from NodeIfCanStim import NodeIfCanStim
12	from NodeIfSerial import NodeIfSerial	12	from NodeIfSerial import NodeIfSerial
13	from NodeIfTCP import NodeIfTCP	13	from NodeIfTCP import NodeIfTCP
14		14
15	from DaemonConfig import DaemonConfig	15	from DaemonConfig import DaemonConfig
16		16
17	daemonApp = None	17	daemonApp = None
18		18
19	class CanDaemon():	19	class CanDaemon():
20		20
21	cfg = None	21	cfg = None
22	ifNotifier = None	22	ifNotifier = None
23	terminated = False	23	terminated = False
24		24
25	command_list = []	25	command_list = []
26	command_map = {}	26	command_map = {}
27	CMDLIST_NAME = 0	27	CMDLIST_NAME = 0
28	CMDLIST_HANDLER = 1	28	CMDLIST_HANDLER = 1
29	CMDLIST_PARAMINFO = 2	29	CMDLIST_PARAMINFO = 2
30	CMDLIST_HELP = 3	30	CMDLIST_HELP = 3
31		31
32	logHelp = 'usage:\t log [options]\n\n' \	32	logHelp = 'usage:\t log [options]\n\n' \
33	'\t options:\n' \	33	'\t options:\n' \
34	'\t level <num>, where: 0 < num < 3\n'	34	'\t level <num>, where: 0 < num < 3\n'
35	stateHelp = 'usage: state [name/add/rem]'	35	stateHelp = 'usage: state [name/add/rem]'
36	filterHelp = 'usage: filter [name/add/rem]'	36	filterHelp = 'usage: filter [name/add/rem]'
37	addifHelp = 'usage: addif [name] [options]'	37	addifHelp = 'usage: addif [name] [options]'
38	addbridgeHelp = 'usage: addbridge [interface names]'	38	addbridgeHelp = 'usage: addbridge [interface names]'
39	tcpdHelp = 'usage: tcpd [start/stop/configure] [options]'	39	tcpdHelp = 'usage: tcpd [start/stop/configure] [options]'
40	tlsdHelp = 'usage: tlsd [start/stop/configure] [options]'	40	tlsdHelp = 'usage: tlsd [start/stop/configure] [options]'
41	canctldHelp = 'usage: canctld [start/stop/configure] [options]'	41	canctldHelp = 'usage: canctld [start/stop/configure] [options]'
42	simHelp = 'usage: sim [record/play/add/rem/save/load] [options]'	42	simHelp = 'usage: sim [record/play/add/rem/save/load] [options]'
43	help_command_map = {}	43	help_command_map = {}
44		44
45	logOptions = {}	45	logOptions = {}
46	ifOptions = {}	46	ifOptions = {}
47	bridgeOptions = {}	47	bridgeOptions = {}
48	tcpdOptions = {}	48	tcpdOptions = {}
49	tlsdOptions = {}	49	tlsdOptions = {}
50	canctldOptions = {}	50	canctldOptions = {}
51	simOptions = {}	51	simOptions = {}
52		52
53	logValidOptions = {'level' : ['range', 0, 3]}	53	logValidOptions = {'level' : ['range', 0, 3]}
54	ifValidOptions = {'type' : ['alt', 'serial','udp']}	54	ifValidOptions = {'type' : ['alt', 'serial','udp']}
55		55
56	ifSerialOptions = {'' : []}	56	ifSerialOptions = {'' : []}
57	ifCanStimOptions = {'' : []}	57	ifCanStimOptions = {'' : []}
58	ifTelnetOptions = {'' : []}	58	ifTelnetOptions = {'' : []}
59	ifTcpTlsOptions = {'' : []}	59	ifTcpTlsOptions = {'' : []}
60	ifUDPOptions = {'' : []}	60	ifUDPOptions = {'' : []}
61		61
62	bridgeValidOptions = {'' : ['']}	62	bridgeValidOptions = {'' : ['']}
63	tcpdValidOptions = {'' : []}	63	tcpdValidOptions = {'' : []}
64	tlsdValidOptions = {'' : []}	64	tlsdValidOptions = {'' : []}
65	canctldValidOptions = {'' : []}	65	canctldValidOptions = {'' : []}
66	simValidOptions = {'' : []}	66	simValidOptions = {'' : []}
67		67
68	def __init__ (self):	68	def __init__ (self):
69		69
70	self.command_list = [['help', self.helpCmd, '', 'display help'],	70	self.command_list = [['help', self.helpCmd, '', 'display help'],
71	['log', self.logCmd, '<options>', 'log control: \"help log\"'],	71	['log', self.logCmd, '<options>', 'log control: \"help log\"'],
72	['exec', self.execCmd, '<filename>', 'run command listing\n'],	72	['exec', self.execCmd, '<filename>', 'run command listing\n'],
73	['filter', self.filterCmd, '<cmd>', 'filter commands: \"help filter\"'],	73	['filter', self.filterCmd, '<cmd>', 'filter commands: \"help filter\"'],
74	['state', self.stateCmd, '<cmd>', 'state commands: \"help state\"\n'],	74	['state', self.stateCmd, '<cmd>', 'state commands: \"help state\"\n'],
75	['addif', self.ifAddCmd, '<options>', 'add interface: \"help addif\"'],	75	['addif', self.ifAddCmd, '<options>', 'add interface: \"help addif\"'],
76	['remif', self.ifRemCmd, '<name>', 'remove interface'],	76	['remif', self.ifRemCmd, '<name>', 'remove interface'],
77	['ifup', self.ifUpCmd, '<name>', 'bring up interface'],	77	['ifup', self.ifUpCmd, '<name>', 'bring up interface'],
78	['ifdown', self.ifDownCmd, '<name>', 'bring down interface\n'],	78	['ifdown', self.ifDownCmd, '<name>', 'bring down interface\n'],
79	['addbrigde', self.addBridgeCmd, '<options>', 'add bridge: \"help addbridge\"'],	79	['addbrigde', self.addBridgeCmd, '<options>', 'add bridge: \"help addbridge\"'],
80	['rembridge', self.remBridgeCmd, '<id>', 'remove bridge\n'],	80	['rembridge', self.remBridgeCmd, '<id>', 'remove bridge\n'],
81	['tcpd', self.tcpdCmd, '<cmd>', 'tcpd server control: \"help tcpd\"'],	81	['tcpd', self.tcpdCmd, '<cmd>', 'tcpd server control: \"help tcpd\"'],
82	['tlsd', self.tlsdCmd, '<cmd>', 'tlsd server control: \"help tlsd\"'],	82	['tlsd', self.tlsdCmd, '<cmd>', 'tlsd server control: \"help tlsd\"'],
83	['canctld', self.canCtldCmd, '<cmd>', 'canctld server control: \"help canctld\"\n'],	83	['canctld', self.canCtldCmd, '<cmd>', 'canctld server control: \"help canctld\"\n'],
84	['status', self.statusCmd, '', 'show daemon status'],	84	['status', self.statusCmd, '', 'show daemon status'],
85	['stats', self.statsCmd, '', 'show statistics'],	85	['stats', self.statsCmd, '', 'show statistics'],
86	['nodelist', self.nodesCmd, '', 'list can nodes\n'],	86	['nodelist', self.nodesCmd, '', 'list can nodes\n'],
87	['sim', self.simCmd, '<cmd>', 'simulator commands: \"help sim\"']]	87	['sim', self.simCmd, '<cmd>', 'simulator commands: \"help sim\"']]
88		88
89	index = 0	89	index = 0
90	for cmd in self.command_list:	90	for cmd in self.command_list:
91	self.command_map[cmd[0]] = index	91	self.command_map[cmd[0]] = index
92	index += 1	92	index += 1
93		93
94	self.help_command_map = {'log' : self.logHelp,	94	self.help_command_map = {'log' : self.logHelp,
95	'filter' : self.filterHelp,	95	'filter' : self.filterHelp,
96	'state' : self.stateHelp,	96	'state' : self.stateHelp,
97	'addif' : self.addifHelp,	97	'addif' : self.addifHelp,
98	'addbridge' : self.addbridgeHelp,	98	'addbridge' : self.addbridgeHelp,
99	'tcpd' : self.tcpdHelp,	99	'tcpd' : self.tcpdHelp,
100	'tlsd' : self.tlsdHelp,	100	'tlsd' : self.tlsdHelp,
101	'canctld' : self.canctldHelp,	101	'canctld' : self.canctldHelp,
102	'sim' : self.simHelp}	102	'sim' : self.simHelp}
103		103
104	self.cfg = DaemonConfig()	104	self.cfg = DaemonConfig()
105		105
106	class IfNotifier():	106	class IfNotifier():
107	""" Used by if threads to send messages to the main program thread """	107	""" Used by if threads to send messages to the main program thread """
108		108
109	parent = None	109	parent = None
110	UNDEFINED = 0	110	UNDEFINED = 0
111	TERMINATE = 1	111	TERMINATE = 1
112		112
113	def __init__(self, parent):	113	def __init__(self, parent):
114	self.parent = parent	114	self.parent = parent
115		115
116	def notify(self, msg):	116	def notify(self, msg):
117	if msg == self.TERMINATE:	117	if msg == self.TERMINATE:
118	print 'Main terminate notify'	118	print 'Main terminate notify'
119	else:	119	else:
120	print 'UNDEFINED NOTIFY'	120	print 'UNDEFINED NOTIFY'
121		121
122		122
123	def __rightAdjust(self, refstr, str):	123	def __rightAdjust(self, refstr, str):
124	spcstr = ''	124	spcstr = ''
125	endpos = 25-len(refstr)	125	endpos = 25-len(refstr)
126	for i in range(1,endpos):	126	for i in range(1,endpos):
127	if i == endpos-5:	127	if i == endpos-5:
128	spcstr += ':'	128	spcstr += ':'
129	else:	129	else:
130	spcstr += ' '	130	spcstr += ' '
131	return (spcstr+str)	131	return (spcstr+str)
132		132
133	def helpCmd(self, *args):	133	def helpCmd(self, *args):
134	try:	134	try:
135	args = args[0]	135	args = args[0]
136	except:	136	except:
137	args = []	137	args = []
138	if len(args) < 1:	138	if len(args) < 1:
139	quitStr = 'quit, exit'	139	quitStr = 'quit, exit'
140	print quitStr, self.__rightAdjust(quitStr, 'shutdown pyCanDaemon')	140	print quitStr, self.__rightAdjust(quitStr, 'shutdown pyCanDaemon')
141	for cmd in self.command_list:	141	for cmd in self.command_list:
142	cmdstr = cmd[self.CMDLIST_NAME] + ' ' + cmd[self.CMDLIST_PARAMINFO]	142	cmdstr = cmd[self.CMDLIST_NAME] + ' ' + cmd[self.CMDLIST_PARAMINFO]
143	print cmdstr, \	143	print cmdstr, \
144	self.__rightAdjust(cmdstr, cmd[self.CMDLIST_HELP])	144	self.__rightAdjust(cmdstr, cmd[self.CMDLIST_HELP])
145	elif len(args) < 2:	145	elif len(args) < 2:
146	subCmd = args[0]	146	subCmd = args[0]
147	if self.help_command_map.has_key(subCmd):	147	if self.help_command_map.has_key(subCmd):
148	print self.help_command_map[subCmd]	148	print self.help_command_map[subCmd]
149	else:	149	else:
150	print 'no help for ' + subCmd	150	print 'no help for ' + subCmd
151	else:	151	else:
152	print 'usage: help [topic]'	152	print 'usage: help [topic]'
153		153
154	def filterCmd(self, *args):	154	def filterCmd(self, *args):
155	try:	155	try:
156	args = args[0]	156	args = args[0]
157	except:	157	except:
158	args = []	158	args = []
159	log.debug('filterCmd ' + str(args))	159	log.debug('filterCmd ' + str(args))
160	if len(args) < 2:	160	if len(args) < 2:
161	print 'Invalid arguments\n' + self.filterHelp	161	print 'Invalid arguments\n' + self.filterHelp
162	return	162	return
163	cmd = args[0]	163	cmd = args[0]
164	filterName = args[1]	164	filterName = args[1]
165	# FIXME: verify	165	# FIXME: verify
166	if cmd == 'add':	166	if cmd == 'add':
167	print 'Importing filter: ' + filterName	167	print 'Importing filter: ' + filterName
168	self.cfg.filterCfg.importFilter(filterName)	168	self.cfg.filterCfg.importFilter(filterName)
169	elif cmd == 'rem' or cmd == 'remove':	169	elif cmd == 'rem' or cmd == 'remove':
170	print 'Deleting filter: ' + filterName	170	print 'Deleting filter: ' + filterName
171	# FIXME: actually delete	171	# FIXME: actually delete
172	raise 'Not implemented'	172	raise 'Not implemented'
173		173
174	def stateCmd(self, *args):	174	def stateCmd(self, *args):
175	try:	175	try:
176	args = args[0]	176	args = args[0]
177	except:	177	except:
178	args = []	178	args = []
179	log.debug('stateCmd ' + str(args))	179	log.debug('stateCmd ' + str(args))
180	if len(args) < 2:	180	if len(args) < 2:
181	print 'Invalid arguments\n' + self.stateHelp	181	print 'Invalid arguments\n' + self.stateHelp
182	return	182	return
183	cmd = args[0]	183	cmd = args[0]
184	spaceName = args[1]	184	spaceName = args[1]
185	# FIXME: verify	185	# FIXME: verify
186	if cmd == 'add':	186	if cmd == 'add':
187	print 'Importing state space: ' + spaceName	187	print 'Importing state space: ' + spaceName
188	self.cfg.stateSpaceCfg.importSpace(spaceName)	188	self.cfg.stateSpaceCfg.importSpace(spaceName)
189	elif cmd == 'rem' or cmd == 'remove':	189	elif cmd == 'rem' or cmd == 'remove':
190	print 'Deleting state space: ' + spaceName	190	print 'Deleting state space: ' + spaceName
191	# FIXME: actually delete statespace	191	# FIXME: actually delete statespace
192	raise 'Not implemented'	192	raise 'Not implemented'
193		193
194	def ifAddCmd(self, *args):	194	def ifAddCmd(self, *args):
195	raise 'not implemented'	195	raise 'not implemented'
196		196
197	def ifRemCmd(self, *args):	197	def ifRemCmd(self, *args):
198	raise 'not implemented'	198	raise 'not implemented'
199		199
200	def ifUpCmd(self, *args):	200	def ifUpCmd(self, *args):
201	raise 'not implemented'	201	raise 'not implemented'
202		202
203	def ifDownCmd(self, *args):	203	def ifDownCmd(self, *args):
204	raise 'not implemented'	204	raise 'not implemented'
205		205
206	def addBridgeCmd(self, *args):	206	def addBridgeCmd(self, *args):
207	raise 'not implemented'	207	raise 'not implemented'
208		208
209	def remBridgeCmd(self, *args):	209	def remBridgeCmd(self, *args):
210	raise 'not implemented'	210	raise 'not implemented'
211		211
212	def tcpdCmd(self, *args):	212	def tcpdCmd(self, *args):
213	raise 'not implemented'	213	raise 'not implemented'
214		214
215	def tlsdCmd(self, *args):	215	def tlsdCmd(self, *args):
216	raise 'not implemented'	216	raise 'not implemented'
217		217
218	def canCtldCmd(self, *args):	218	def canCtldCmd(self, *args):
219	raise 'not implemented'	219	raise 'not implemented'
220		220
221	def statusCmd(self, *args):	221	def statusCmd(self, *args):
222	raise 'not implemented'	222	raise 'not implemented'
223		223
224	def statsCmd(self, *args):	224	def statsCmd(self, *args):
225	raise 'not implemented'	225	raise 'not implemented'
226		226
227	def nodesCmd(self, *args):	227	def nodesCmd(self, *args):
228	raise 'not implemented'	228	raise 'not implemented'
229		229
230	def simCmd(self, *args):	230	def simCmd(self, *args):
231	raise 'not implemented'	231	raise 'not implemented'
232		232
233	def logCmd(self, *args):	233	def logCmd(self, *args):
234	raise 'not implemented'	234	raise 'not implemented'
235		235
236	def execCmd(self, *args):	236	def execCmd(self, *args):
237	raise 'not implemented'	237	raise 'not implemented'
238		238
239	def parseCommand(self, cmdstr):	239	def parseCommand(self, cmdstr):
240	incmd = cmdstr.strip()	240	incmd = cmdstr.strip()
241	cmd = incmd.split(' ')	241	cmd = incmd.split(' ')
242	if len(cmd[0]) < 2:	242	if len(cmd[0]) < 2:
243	return	243	return
244	cmd[0] = cmd[0].lower()	244	cmd[0] = cmd[0].lower()
245	if cmd[0] == 'quit' or cmd[0] == 'exit':	245	if cmd[0] == 'quit' or cmd[0] == 'exit':
246	self.terminated = True	246	self.terminated = True
247	elif self.command_map.has_key(cmd[0]):	247	elif self.command_map.has_key(cmd[0]):
248	self.command_list[self.command_map[cmd[0]]][self.CMDLIST_HANDLER](cmd[1:])	248	self.command_list[self.command_map[cmd[0]]][self.CMDLIST_HANDLER](cmd[1:])
249	else:	249	else:
250	print 'unknown command: ' + cmd[0]	250	print 'unknown command: ' + cmd[0]
251		251
252	def exitHelper(self):	252	def exitHelper(self):
253	pass	253	pass
254	# if self.nodeIf is not None and self.nodeIf.running():	254	# if self.nodeIf is not None and self.nodeIf.running():
255	# self.nodeIf.stop()	255	# self.nodeIf.stop()
256		256
257	def exceptHelper(self, type, value, tb):	257	def exceptHelper(self, type, value, tb):
258	import traceback	258	import traceback
259	traceback.print_exception(type, value, tb)	259	traceback.print_exception(type, value, tb)
260	print '\nException in main program, shutting down threads'	260	print '\nException in main program, shutting down threads'
261	self.terminated = True	261	self.terminated = True
262	self.exitHelper()	262	self.exitHelper()
263		263
264		264
265	def run(self):	265	def run(self):
266	try:	266	try:
267	myPath = os.path.dirname(__file__)	267	myPath = os.path.dirname(__file__)
268	os.chdir(myPath)	268	os.chdir(myPath)
269	except:	269	except:
270	return	270	return
271		271
272	print 'INIT: Start logging'	272	print 'INIT: Start logging'
273	log.basicConfig(level=log.DEBUG)	273	log.basicConfig(level=log.DEBUG)
274		274
275	"""command parameters only dictate verbosity and use of config file"""	275	"""command parameters only dictate verbosity and use of config file"""
276	print 'INIT: Get config options from command line / config file'	276	print 'INIT: Get config options from command line / config file'
277	try:	277	try:
278	opts, args = getopt.getopt(sys.argv[1:], "ho:v", ["help", "output="])	278	opts, args = getopt.getopt(sys.argv[1:], "ho:v", ["help", "output="])
279	except getopt.GetoptError:	279	except getopt.GetoptError:
280	print 'Invalid usage'	280	print 'Invalid usage'
281	usage()	281	usage()
282	sys.exit(2)	282	sys.exit(2)
283	# output = None	283	# output = None
284	# verbose = False	284	# verbose = False
285	for o, a in opts:	285	for o, a in opts:
286	if o == "-v":	286	if o == "-v":
287	pass	287	pass
288	# verbose = True	288	# verbose = True
289	if o in ("-h", "--help"):	289	if o in ("-h", "--help"):
290	usage()	290	usage()
291	sys.exit()	291	sys.exit()
292	if o in ("-o", "--output"):	292	if o in ("-o", "--output"):
293	pass	293	pass
294	# output = a	294	# output = a
295		295
296	"""load config defaults, or last config if exists"""	296	"""load config defaults, or last config if exists"""
297	"""run startup.cfg"""	297	"""run startup.cfg"""
298	print 'INIT: Loading daemon configuration'	298	print 'INIT: Loading daemon configuration'
299	self.cfg = DaemonConfig()	299	self.cfg = DaemonConfig()
300	self.cfg.load()	300	self.cfg.load()
-		301
-		302	# create interface for debugging purpose
-		303	self.cfg.addInterface('tcp', None)
301		304
302	self.ifNotifier = self.IfNotifier(self)	305	self.ifNotifier = self.IfNotifier(self)
303	for nodeIf in self.cfg.nodeInterfaces:	306	for nodeIf in self.cfg.nodeInterfaces:
304	nodeIf.setIfNotifier(self.ifNotifier)	307	nodeIf.setIfNotifier(self.ifNotifier)
305		308
306	atexit.register(self.exitHelper)	309	atexit.register(self.exitHelper)
307	sys.excepthook = self.exceptHelper	310	sys.excepthook = self.exceptHelper
308		311
309	print 'INIT: Starting configured node interfaces'	312	print 'INIT: Starting configured node interfaces'
310	for nodeIf in self.cfg.nodeInterfaces:	313	for nodeIf in self.cfg.nodeInterfaces:
311	if not nodeIf.start():	314	if not nodeIf.start():
312	print 'FATAL: Failed to initialize node interface.'	315	print 'FATAL: Failed to initialize node interface.'
313	print 'This may indicate that the interface is unavailable, ' \	316	print 'This may indicate that the interface is unavailable, ' \
314	'or that you do not have permission to access it.'	317	'or that you do not have permission to access it.'
315	sys.exit(-1)	318	sys.exit(-1)
316		319
317	print 'INIT: Initialize/gather info on connected can nodes and load associated state'	320	print 'INIT: Initialize/gather info on connected can nodes and load associated state'
318	print 'INIT: Starting configured servers'	321	print 'INIT: Starting configured servers'
319		322
320	print 'CanDaemon v1 ready'	323	print 'CanDaemon v1 ready'
321	print 'Enter command or type \"help\" for a list of commands'	324	print 'Enter command or type \"help\" for a list of commands'
322	while not self.terminated:	325	while not self.terminated:
323	input = raw_input('> ')	326	input = raw_input('> ')
324	self.parseCommand(input)	327	self.parseCommand(input)
325		328
326	print 'Shutdown'	329	print 'Shutdown'
327	self.cfg.save()	330	self.cfg.save()
328		331
329	for nodeIf in self.cfg.nodeInterfaces:	332	for nodeIf in self.cfg.nodeInterfaces:
330	if ~~self.~~nodeIf.running():	333	if nodeIf.running():
331	print 'Stopping If thread'	334	print 'Stopping If thread'
332	~~self.~~nodeIf.stop()	335	nodeIf.stop()
333		336
334	print 'Waiting 0.1..'	337	print 'Waiting 0.1..'
335	time.sleep(0.1) # wait for threads	338	time.sleep(0.1) # wait for threads
336	print 'Terminating'	339	print 'Terminating'
337	sys.exit(0) # will except if there are threads remaining	340	sys.exit(0) # will except if there are threads remaining
338		341
339	#---------------------------------------------------------------------------	342	#---------------------------------------------------------------------------
340		343
341	def main():	344	def main():
342	daemonApp = CanDaemon()	345	daemonApp = CanDaemon()
343	# install_thread_excepthook()	346	# install_thread_excepthook()
344	daemonApp.run()	347	daemonApp.run()
345		348
346	#---------------------------------------------------------------------------	349	#---------------------------------------------------------------------------
347		350
348	if __name__ == '__main__':	351	if __name__ == '__main__':
349	__name__ = 'Main'	352	__name__ = 'Main'
350	main()	353	main()
351		354

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/pyCanDaemon/Main.py @ 750 – Rev 749 → 750