Subversion Repositories HomeAutomation

#!/bin/env python

import os
import sys
import logging as log
import getopt
import atexit
import time

from CanPktHandlerBase import CanPktHandlerBase
from CanPktHandler1 import CanPktHandler1

from NodeIfBase import NodeIfBase
from NodeIfCanStim import NodeIfCanStim
from NodeIfSerial import NodeIfSerial

from DaemonConfig import DaemonConfig

daemonApp = None

class CanDaemon():
    
    nodeIf = None
    ifNotifier = None
    terminated = False
    command_list = []

    def __init__ (self):
        pass
    
    class IfNotifier():
        """ Used by if threads to send messages to the main program thread """
        UNDEFINED = 0
        TERMINATE = 1
    
        def notify(self, msg):
            if msg == self.TERMINATE:
                print 'Main terminate notify'
                self.terminated = True
            else:
                print 'UNDEFINED NOTIFY'
        
    
    def __rightAdjust(self, refstr, str):
        spcstr = ''
        endpos = 20-len(refstr)
        for i in range(1,endpos):
            if i == endpos-5:
                spcstr += ':'
            else:
                spcstr += ' '
        return (spcstr+str)
    
    def helpCmd(self, *args):
        quitStr = 'quit, exit'
#        print quitStr, self.__rightAdjust(quitStr, 'shutdown pyCanDaemon')
#        for cmd in cmdNames:
#            print cmd, self.__rightAdjust(cmd, command_map[cmd][1])
        
    def filterCmd(self, *args):
        pass
    
    def stateCmd(self, *args):
        pass
    
    def ifAddCmd(self, *args):
        pass
    
    def ifRemCmd(self, *args):
        pass
    
    def ifUpCmd(self, *args):
        pass
    
    def ifDownCmd(self, *args):
        pass
    
    def addBridgeCmd(self, *args):
        pass
    
    def remBridgeCmd(self, *args):
        pass
    
    def tcpdCmd(self, *args):
        pass
    
    def tlsdCmd(self, *args):
        pass
    
    def canCtldCmd(self, *args):
        pass
    
    def statusCmd(self, *args):
        pass
    
    def statsCmd(self, *args):
        pass
    
    def nodesCmd(self, *args):
        pass
    
    def filterlistCmd(self, *args):
        pass
    
    def simCmd(self, *args):
        pass
    
    def logCmd(self, *args):
        pass
    
    def execCmd(self, *args):
        pass
    
    def exitHelper(self):
        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()
 #       sys.exit(-1)

    def run(self):
        try:
            demoPath = os.path.dirname(__file__)
            os.chdir(demoPath)
        except:
            return
        
        print 'INIT: Start logging'
        log.basicConfig(level=log.DEBUG)
        
        print 'INIT: Get config options from command line / config file'
        cfg = DaemonConfig()
        
        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
    
        print 'INIT: Loading filters and spaces'
  #      cfg.filterCfg.importFilter('DefaultFilter')
  #      cfg.stateSpaceCfg.importSpace('DefaultStateSpace')
        cfg.stateSpaceCfg.loadSpaces()
        cfg.filterCfg.loadFilters()
        cfg.setupFilterBindings()
        cfg.setupFilterChain()
        
        print 'INIT: Starting selected can interface'
        ''' nodeif thread launch '''
        self.ifNotifier = self.IfNotifier()
        pktHandler = CanPktHandler1(cfg)
        
        ifConfig = NodeIfCanStim.DEFAULT_CONFIG
        self.nodeIf = NodeIfCanStim(ifConfig, pktHandler, self.ifNotifier)
 #       ifConfig = NodeIfSerial.DEFAULT_CONFIG
    
        atexit.register(self.exitHelper)
        sys.excepthook = self.exceptHelper
 #       self.nodeIf = NodeIfSerial(pktHandler, ifConfig)
        
        if not self.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 'Initialize/gather info on connected can nodes and load associated state'
        print 'Start selected TCP and UDP server(s)'
        # server threads launch
        
        print 'CanDaemon v1 ready'
        print 'Enter command or type \"help\" for a list of commands'
        
        global command_map
        command_map = {'help' : (self.helpCmd, 'display help'),
                       'filter' : (self.filterCmd, 'filter commands: \"help filter\"'),
                       'state' : (self.stateCmd, 'state commands: \"help state\"'),
                       'addif' : (self.ifAddCmd, 'add interface: \"help addif\"'),
                       'remif' : (self.ifRemCmd, 'remove interface <name>'),
                       'ifup' : (self.ifUpCmd, 'bring up interface <name>'),
                       'ifdown' : (self.ifDownCmd, 'bring down interface <name>'),
#                       'addbrigde' : (self.addBridgeCmd, 'add bridge: \"help addbridge\"'),
#                       'rembridge' : (self.remBridgeCmd, 'remove bridge <name>'),
                       'tcpd' : (self.tcpdCmd, 'tcpd server control: \"help tcpd\"'),
#                       'tlsd' : (self.tlsdCmd, 'tlsd server control: \"help tlsd\"'),
#                       'canctld' : (self.canCtldCmd, 'canctld server control: \"help canctld\"'),
#                       'status' : (self.statusCmd, 'show daemon status'),
#                       'stats' : (self.statsCmd, 'show statistics'),
#                       'nodelist' : (self.nodesCmd, 'list can nodes'),
#                       'filterlist' : (self.filterlistCmd, 'list active filters'),
#                       'sim' : (self.simCmd, 'simulator commands: \"help sim\"'),
#                       'log' : (self.logCmd, 'log control: \"help log\"'),
#                       'exec' : (self.execCmd,  'run command listing <filename>')}

        while not self.terminated:
            input = raw_input('> ').strip().lower()
            cmd = input.split(' ')
            if cmd[0] == 'quit' or cmd[0] == 'exit':
                self.terminated = True
            elif command_map.has_key(cmd[0]):
                command_map[cmd[0]][0](cmd[1:])
            else:
                print 'Unknown command: ' + cmd[0]

        """ -- suggested commands -- p n = priority to implement (1 is highest)
            base: (p 1)
            filter add <name>
            filter rem <name>
            state add <name>
            state rem <name>
            state reset <name>
            
                node interfaces:  (p 1)
            addif <serial/sim/udp/telnet> <options> (help protocol gives options)
            remif <name> - delete an interface
            ifup <name> - bring up an interface
            ifdown <name> - bring down an interface
            
                bridging: (p 2)
            addbridge <name> <ifname1> <ifname2> <ifname3> ... - create if bridge
            rembridge <name>
            
                servers:
            tcpd start [port] - raw tcp (telnet, compat) server, all pkts  (p 1)
            tcpd stop
            tlsd start [port] - tcp+tls server, all pkts  (p 2)
            tlsd stop
            canctld start [port] - pyCanGUI server (tcp/tls)  (p 2)
            canctld stop
            
            info commands: (p 3)
            status - shows active settings, interfaces, servers
            stats - shows some traffic statistics
            nodes - shows active nodes 
            filters - shows active filters
            state [name] - shows active states, opt specific state info\
            log - log control (TBD)
            
            simulator commands: (p 2)
            simrecord <file> - record incoming packets
            simplay <file> [timescale] - play recorded stream, opt accel time:
            simadd <nodeid> (nodetype) 
            simrem <nodeid>
            simsave <config>
            simload <config>
        """
 
        """ -- other features --
            startup.cfg - script to run at startup (command listing)
            ie: ifup 0
                tlsd start
                canguid start
            config.cfg - last daemon config (param override)
            default.cfg - default daemon config (only read if config.cfg does not exist)
        """

        print 'Shutdown'
        if self.nodeIf.running():
            print 'Stopping If thread'
            self.nodeIf.stop()

        cfg.stateSpaceCfg.saveSpaces()
        cfg.filterCfg.saveFilters()
        
        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()