def checkMsg(msg, typeCheck=None): """Checks if the return is an error, if it is, it will handle it. If not then it will check it against the provided type. If is not the valid type it will print it right then and there. If it IS the valid type it will return it. """ msg = strToMessage(msg) if msg is None: print("ERROR: Is the Daemon running?") sys.exit(1) if msg.getType() == ERROR_MSG_TYPE: print("ERROR:",msg.getValue()) sys.exit(1) elif typeCheck is None or typeCheck is type(msg.getValue()): return msg.getValue() else: print(msg.getValue())
def receiver(self): """ Runs the receiving portion of the interface. """ from empbase.comm.messages import strToMessage #LATER: Add security to this portion. Adjust message handling for privilege level? logging.debug("starting interface comm") self._socket.setblocking(True) try: while 1: msg = self._socket.recv() if not msg: break else: self.router.sendMsg(strToMessage(msg)) except Exception as e: logging.error("interface died because: %s"%e) finally: logging.debug("ending interface comm") self.router.rmInterface(self.ID) self.close()
def startRouter(self, triggermethod=lambda:False): """ This is the thread that runs and pushes messages everywhere. """ logging.debug("ComRouter thread has started") while triggermethod(): try: if self._msg_queue.empty():raise queue.Empty msg = self._msg_queue.get() #remove and return a message if isinstance(msg, str): msg = strToMessage(msg) elif msg is None or not isinstance(msg, Message): continue logging.debug("destination: %s"%msg.getDestination()) # if the destination is not "registered" but its a known type if msg.getDestination() == "" or msg.getDestination() == None: # Check if the message type is an alert, if it is, then send it # to all interfaces and alerters. We keep this functionality for # possible use in Chat programs or quick universal relays. But # actual "Alerts" are now called Events and are managed by the # EventManager. if msg.getType() == ALERT_MSG_TYPE: for id in list( self._routees.keys()): logging.debug("sending alert to %s: %s"% (id, msg)) _,ref = self._routees.get(id) if isinstance(ref, Interface): Thread(target=ref.handle_msg, args=(msg,)).start() # Notice, alarms don't get the message. # if not send it to the daemon to handle. else: self.__sendToDaemon(msg) elif self.isRegistered(msg.getDestination()): if msg.getDestination() == "daemon" or msg.getDestination() == None: self.__sendToDaemon(msg) continue # if its registered, it could be a routee or an attachment. if msg.getType() == COMMAND_MSG_TYPE: cmds = self._attachments.getCommands(msg.getDestination()) if cmds is not None:#we can run the command and send the result. found = False for cmd in cmds: if cmd == msg.getValue(): found = True Thread(target=self._cmdrun, args=msg.get("args"), kwargs={"cmd":cmd, "dest":msg.getSource(), "source":msg.getDestination()}).start() if not found: self.sendMsg(makeErrorMsg("Command does not exist.",msg.getDestination(), msg.getSource() )) continue #ok to send since its been registered, but is a routee ref = self._routees.get(msg.getDestination(),None) if ref is not None: logging.debug("sending message: %s" % msg) Thread(target=ref.handle_msg, args=(msg,)).start() else: #send to daemon. self.__sendToDaemon(msg) # if we don't know how to handle the message, log and discard it. oh well. else: logging.warning("I don't know who %s is, msg=%s" % (msg.getDestination(), str(msg.getValue()))) except queue.Empty: pass except Exception as e: logging.exception(e) ## then we sleep for a while. This is randomized because we don't really know ## the speed at which messages are being sent. We could write a method to adapt ## to the internal rate, later. But currently randomizing provides a better ## compensation than a constant time factor. if not self._msg_queue.empty(): continue try: time.sleep(random.random()) except: pass #when closing, it doesn't need to clean anything, just die and #log about it logging.debug("ComRouter thread has died")
def main(): parser = setupParser() args = parser.parse_args() #handle the commands given if len(sys.argv) == 1: print("Usage:",__simple__,"\n\nType 'emp -h' for some help.") return #print(args) if args.help: help() elif args.i: from interface.empcurse import interactiveMode interactiveMode() else: try: # we will be communicating with the daemon commport = EmpDaemon().getComPort() if commport is None: print("Error: Daemon isn't running!");return daemon = DaemonClientSocket(port=commport) daemon.connect() msg = strToMessage(daemon.recv()) if msg is None or msg.getValue() != "proceed": print("Error: Couldn't connect to the daemon.") return myID = msg.getDestination() #what are we communicating if args.list: daemon.send(makeCommandMsg("alarms",myID)) alerters = checkMsg(daemon.recv()) daemon.send(makeCommandMsg("plugs",myID)) plugs = checkMsg(daemon.recv()) #print the list all pretty like: print("Attached targets and their temp IDs:") #TODO: make option to make it nopretty? print(" Plugs:") for k in plugs.keys(): print(" %s" % plugs[k][1]) print(" Name: %s"%plugs[k][0]) print(" ID: %s"%k) print("\n Alarms:") for k in alerters.keys(): print(" %s" % alerters[k][1]) print(" Name: %s"%alerters[k][0]) print(" ID: %s"%k) print() elif args.all: daemon.send(makeCommandMsg("help",myID, args=["all"])) cmds = checkMsg(daemon.recv(), dict) for target in cmds.keys(): if args.pretty: print("%s"%target) if len(cmds[target].keys()) > 0: if args.pretty: print("Commands:") fancyprint(cmds[target]) else: print(str(cmds[target])) else: print("No Commands available!") print() else: # now we can start parsing targets and figuring out what to do with them if args.tcmds: daemon.send(makeCommandMsg("help",myID, args=args.target)) cmds = checkMsg(daemon.recv(), dict) if args.pretty: print("%s Commands: "%args.target[0]) fancyprint(cmds) else: print(str(cmds)) elif args.ask: daemon.send(makeCommandMsg("help",myID, args=args.target)) cmds = checkMsg(daemon.recv(), dict) cmdfound = False for cmd in cmds.keys(): if args.ask[0] == cmd: if args.pretty: print(" %s -%s"%(cmd,cmds[cmd])) else: print("{'%s': '%s'}"%(cmd,cmds[cmd])) cmdfound = True break if not cmdfound: if args.pretty: print("The target does not have that command.") else: print("ERROR: No command") else: if len(args.command) < 1: print("Usage: ",__usage__) daemon.send(makeCommandMsg("help", myID, args=args.target)) cmds = checkMsg(daemon.recv(), dict) print("\n%s Commands: "%args.target[0]) fancyprint(cmds) else: daemon.send(makeCommandMsg(args.command[0], myID, dest=args.target[0], args=args.command[1:])) if not args.nowait: result = checkMsg(daemon.recv()) # since this is a general case interface, we don't really know # how to interpret the result of an argument. But this can # be utilized in a script or a higher level interface. if you # want to call smtg through your program be sure you can # handle JSON if args.pretty: fancyprint(result) # No-pretty is the default, but its an argument just to specify # if the command line is placed in scripts. else: print(result) else: print("success") # now lets close the port to indicate that we are finished. daemon.close() except: if not args.nowait: raise else: print("error") # scripts can check for this.
def main(): parser = OptionParser( usage=__usage__, version="Version: empd "+__version__, description=__description__ ) parser.add_option("--start",action="store_const", const=0, dest="state", help="start the EMP daemon") parser.add_option("--stop", action="store_const", const=1, dest="state", help="stop a running EMP daemon, may take some time to \ close all plug-ins") parser.add_option("--restart", action="store_const", const=2, dest="state", help="restart a running EMP daemon") parser.add_option("--status", action="store_const", const=1, dest="status", help="show the status of the currently running EMP \ daemon") parser.add_option("--startup", action="store_const", const=3, dest="state", help="Use this in your start-up/boot scripts to auto-launch \ empd.") ### the special daemonizer token. see Daemon class for more info ### parser.add_option("-d", nargs=0, dest="daemonize", help=SUPPRESS_HELP) # if there are no command line args, then print usage if len(sys.argv[1:]) == 0: parser.print_usage() print("Use '-h' for more help and a list of options.") return ## parse the command line arguments ## (options, args) = parser.parse_args() if len(args) > 1: print("Invalid argument structure. Use '-h' for help.\n") return try: ## find out what the user wants to do. ## # user wants to run some functions on the daemon. # First we have to construct it to talk to it, # which of course takes some time. if options.state != None: #we want to mess with the daemon, so construct it if len(args) == 1: daemon = EmpDaemon(configfile=args[0]) else: daemon = EmpDaemon() # then call functions on it. if options.state == 0: daemon.start() elif options.state == 1: daemon.stop() elif options.state == 2: daemon.restart() elif options.state == 3: daemon.startup() # all the user wants to do is ask how the daemon is doing # so open up a port and ask it for some information. elif options.status != None: try: daemon = EmpDaemon() p = daemon.getComPort() if p is not None: socket = DaemonClientSocket(port=p) socket.connect() msg = strToMessage(socket.recv()) logging.debug("empd got back: %s"%msg) if msg.getValue() == "proceed":# it connected myId= msg.getDestination() socket.send(makeCommandMsg("status", myId)) print(strToMessage(socket.recv()).getValue(),"\n") socket.close() else: print("ERROR: Daemon rejected connection attempt.") else: print("ERROR: Daemon is not running.") except Exception as e: print("ERROR: couldn't communicate with daemon:", e) # The process has been called via a background thread so # it is ok to just run the daemon, we are one!! # see smtg.daemon.daemon.Daemon for more information. elif options.daemonize != None: #we want to mess with the daemon, so construct it if len(args) == 1: daemon = EmpDaemon(configfile=args[0]) else: daemon = EmpDaemon() daemon._run() except Exception as e: print("ERROR:",e) raise e