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