boswatch.processManager.ProcessManager Class Reference

class to manage a extern sub process More...

Public Member Functions
def	__init__ (self, process, textMode=False)
def	addArgument (self, arg)
	add a new argument
def	clearArguments (self)
	clear all arguments
def	start (self)
	start the new process
def	stop (self)
	Stop the process by sending SIGTERM and wait for ending.
def	readline (self)
	Read one line from stdout stream.
def	skipLines (self, lineCount=1)
	Skip given number of lines from the output.
def	skipLinesUntil (self, matchText)
	Skip lines from the output until the given string is in it.
def	setStdin (self, stdin)
	Set the stdin stream instance.
def	setStdout (self, stdout)
	Set the stdout stream instance.
def	setStderr (self, stderr)
	Set the stderr stream instance.
def	stdout (self)
	Property to get the stdout stream.
def	stderr (self)
	Property to get the stderr stream.
def	isRunning (self)
	Property to get process running state.

Protected Attributes
	_args
	_stdin
	_stdout
	_stderr
	_processHandle
	_textMode

Detailed Description

class to manage a extern sub process

Constructor & Destructor Documentation

__init__()

def boswatch.processManager.ProcessManager.__init__	(		self,
			process,
			textMode = False
	)

    def __init__(self, process, textMode=False):
        logging.debug("create process instance %s - textMode: %s", process, textMode)
        self._args = []
        self._args.append(process)
        self._stdin = None
        self._stdout = subprocess.PIPE
        self._stderr = subprocess.STDOUT
        self._processHandle = None
        self._textMode = textMode
 

Member Function Documentation

addArgument()

def boswatch.processManager.ProcessManager.addArgument	(		self,
			arg
	)

add a new argument

    @param arg: argument to add as string

    def addArgument(self, arg):
        r"""!add a new argument
 
        @param arg: argument to add as string"""
        logging.debug("add argument to process: %s -> %s", self._args[0], arg)
        for splitArg in arg.split():
            self._args.append(splitArg)
 

clearArguments()

def boswatch.processManager.ProcessManager.clearArguments

(

self

)

clear all arguments

    def clearArguments(self):
        r"""!clear all arguments"""
        self._args = self._args[0:1]  # kept first element (process name)
 

start()

def boswatch.processManager.ProcessManager.start

(

self

)

start the new process

    @return: True or False

    def start(self):
        r"""!start the new process
 
        @return: True or False"""
        logging.debug("start new process: %s %s", self._args[0], self._args[1:])
        try:
            self._processHandle = subprocess.Popen(self._args,
                                                   stdin=self._stdin,
                                                   stdout=self._stdout,
                                                   stderr=self._stderr,
                                                   universal_newlines=self._textMode,
                                                   shell=False)
            if not self.isRunning:
                logging.error("cannot start process")
                return False
            logging.debug("process started with PID %d", self._processHandle.pid)
            return True
 
        except FileNotFoundError:
            logging.error("File not found: %s", self._args[0])
            return False
 

stop()

def boswatch.processManager.ProcessManager.stop

(

self

)

Stop the process by sending SIGTERM and wait for ending.

    def stop(self):
        r"""!Stop the process by sending SIGTERM and wait for ending"""
        logging.debug("stopping process: %s", self._args[0])
        if self.isRunning:
            self._processHandle.terminate()
            while self.isRunning:
                pass
        logging.debug("process %s returned %d", self._args[0], self._processHandle.returncode)
 

readline()

def boswatch.processManager.ProcessManager.readline

(

self

)

Read one line from stdout stream.

    @return singe line or None

    def readline(self):
        r"""!Read one line from stdout stream
 
        @return singe line or None"""
        if self.isRunning and self._stdout is not None:
            try:
                line = self._processHandle.stdout.readline().strip()
            except UnicodeDecodeError:
                return None
            return line
        return None
 

skipLines()

def boswatch.processManager.ProcessManager.skipLines	(		self,
			lineCount = 1
	)

Skip given number of lines from the output.

    @param lineCount: number of lines to skip

    def skipLines(self, lineCount=1):
        r"""!Skip given number of lines from the output
 
        @param lineCount: number of lines to skip
        """
        logging.debug("skip %d lines from output", lineCount)
        while self.isRunning and lineCount:
            self.readline()
            lineCount -= 1
 

skipLinesUntil()

def boswatch.processManager.ProcessManager.skipLinesUntil	(		self,
			matchText
	)

Skip lines from the output until the given string is in it.

    @param matchText: string to search for in output

    def skipLinesUntil(self, matchText):
        r"""!Skip lines from the output until the given string is in it
 
        @param matchText: string to search for in output
        """
        logging.debug("skip lines till '%s' from output", matchText)
        if not self._textMode:
            matchText = bytes(matchText, "utf-8")
        while self.isRunning and matchText not in self.readline():
            pass
 

setStdin()

def boswatch.processManager.ProcessManager.setStdin	(		self,
			stdin
	)

Set the stdin stream instance.

    def setStdin(self, stdin):
        r"""!Set the stdin stream instance"""
        self._stdin = stdin
 

setStdout()

def boswatch.processManager.ProcessManager.setStdout	(		self,
			stdout
	)

Set the stdout stream instance.

    def setStdout(self, stdout):
        r"""!Set the stdout stream instance"""
        self._stdout = stdout
 

setStderr()

def boswatch.processManager.ProcessManager.setStderr	(		self,
			stderr
	)

Set the stderr stream instance.

    def setStderr(self, stderr):
        r"""!Set the stderr stream instance"""
        self._stderr = stderr
 

stdout()

def boswatch.processManager.ProcessManager.stdout

(

self

)

Property to get the stdout stream.

    def stdout(self):
        r"""!Property to get the stdout stream"""
        return self._processHandle.stdout
 

stderr()

def boswatch.processManager.ProcessManager.stderr

(

self

)

Property to get the stderr stream.

    def stderr(self):
        r"""!Property to get the stderr stream"""
        return self._processHandle.stderr
 

isRunning()

def boswatch.processManager.ProcessManager.isRunning

(

self

)

Property to get process running state.

    @return True or False

    def isRunning(self):
        r"""!Property to get process running state
 
        @return True or False"""
        if self._processHandle:
            if self._processHandle.poll() is None:
                return True
        return False

Field Documentation

_args

boswatch.processManager.ProcessManager._args

protected

_stdin

boswatch.processManager.ProcessManager._stdin

protected

_stdout

boswatch.processManager.ProcessManager._stdout

protected

_stderr

boswatch.processManager.ProcessManager._stderr

protected

_processHandle

boswatch.processManager.ProcessManager._processHandle

protected

_textMode

boswatch.processManager.ProcessManager._textMode

protected