1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

    26

from __future__ import absolute_import

    27

import os

    28

import sys

    29

import subprocess

    30

import ctypes

    31

from threading import Timer, Lock, Thread, Semaphore

    32

import signal

    33

    35

    36

class outputThread(Thread):

    37

    """

    38

    Thread is used to print the output of a command to the stdout

    39

    """

    40

    def __init__(self, Proc, fd, callback=None, endcallback=None):

    41

        Thread.__init__(self)

    42

        self.killed = False

    43

        self.finished = False

    44

        self.retval = None

    45

        self.Proc = Proc

    46

        self.callback = callback

    47

        self.endcallback = endcallback

    48

        self.fd = fd

    49

    50

    def run(self):

    51

        outchunk = None

    52

        self.retval = None

    53

        while self.retval is None and not self.killed:

    54

            if self.endcallback:

    55

                self.retval = self.Proc.poll()

    56

            else:

    57

                self.retval = self.Proc.returncode

    58

    59

            outchunk = self.fd.readline()

    60

            if self.callback:

    61

                self.callback(outchunk)

    62

        while outchunk != '' and not self.killed:

    63

            outchunk = self.fd.readline()

    64

            if self.callback:

    65

                self.callback(outchunk)

    66

        if self.endcallback:

    67

            try:

    68

                err = self.Proc.wait()

    69

            except Exception:

    70

                err = self.retval

    71

            self.finished = True

    72

            self.endcallback(self.Proc.pid, err)

    73

    74

    75

class ProcessLogger(object):

    76

    def __init__(self, logger, Command, finish_callback=None,

    77

                 no_stdout=False, no_stderr=False, no_gui=True,

    78

                 timeout=None, outlimit=None, errlimit=None,

    79

                 endlog=None, keyword=None, kill_it=False, cwd=None,

    80

                 encoding=None, output_encoding=None):

    82

        self.logger = logger

    83

        if not isinstance(Command, list):

    84

            self.Command_str = Command

    85

            self.Command = []

    86

            for i, word in enumerate(Command.replace("'", '"').split('"')):

    87

                if i % 2 == 0:

    88

                    word = word.strip()

    89

                    if len(word) > 0:

    90

                        self.Command.extend(word.split())

    91

                else:

    92

                    self.Command.append(word)

    93

        else:

    94

            self.Command = Command

    95

            self.Command_str = subprocess.list2cmdline(self.Command)

    96

    97

        fsencoding = sys.getfilesystemencoding()

    98

        self.output_encoding = output_encoding

    99

   100

        if encoding is None:

   101

            encoding = fsencoding

   102

        self.Command = [self.Command[0].encode(fsencoding)]+map(

   103

            lambda x: x.encode(encoding), self.Command[1:])

   104

   105

        self.finish_callback = finish_callback

   106

        self.no_stdout = no_stdout

   107

        self.no_stderr = no_stderr

   108

        self.startupinfo = None

   109

        self.errlen = 0

   110

        self.outlen = 0

   111

        self.errlimit = errlimit

   112

        self.outlimit = outlimit

   113

        self.exitcode = None

   114

        self.outdata = []

   115

        self.errdata = []

   116

        self.keyword = keyword

   117

        self.kill_it = kill_it

   118

        self.startsem = Semaphore(0)

   119

        self.finishsem = Semaphore(0)

   120

        self.endlock = Lock()

   121

   122

        popenargs = {

   123

            "cwd":    os.getcwd() if cwd is None else cwd,

   124

            "stdin":  subprocess.PIPE,

   125

            "stdout": subprocess.PIPE,

   126

            "stderr": subprocess.PIPE

   127

        }

   128

   129

        if no_gui and os.name in ("nt", "ce"):

   130

            self.startupinfo = subprocess.STARTUPINFO()

   131

            self.startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

   132

            popenargs["startupinfo"] = self.startupinfo

   133

        elif os.name == 'posix':

   134

            popenargs["shell"] = False

   135

   136

        if timeout:

   137

            self.timeout = Timer(timeout, self.endlog)

   138

            self.timeout.start()

   139

        else:

   140

            self.timeout = None

   141

   142

        self.Proc = subprocess.Popen(self.Command, **popenargs)

   143

   144

        self.outt = outputThread(

   145

            self.Proc,

   146

            self.Proc.stdout,

   147

            self.output,

   148

            self.finish)

   149

        self.outt.start()

   150

   151

        self.errt = outputThread(

   152

            self.Proc,

   153

            self.Proc.stderr,

   154

            self.errors)

   155

        self.errt.start()

   156

        self.startsem.release()

   157

   158

    def output(self, v):

   159

        if v and self.output_encoding:

   160

            v = v.decode(self.output_encoding)

   161

        self.outdata.append(v)

   162

        self.outlen += 1

   163

        if not self.no_stdout:

   164

            self.logger.write(v)

   165

        if (self.keyword and v.find(self.keyword) != -1) or (self.outlimit and self.outlen > self.outlimit):

   166

            self.endlog()

   167

   168

    def errors(self, v):

   169

        if v and self.output_encoding:

   170

            v = v.decode(self.output_encoding)

   171

        self.errdata.append(v)

   172

        self.errlen += 1

   173

        if not self.no_stderr:

   174

            self.logger.write_warning(v)

   175

        if self.errlimit and self.errlen > self.errlimit:

   176

            self.endlog()

   177

   178

    def log_the_end(self, ecode, pid):

   182

   183

    def finish(self, pid, ecode):

   184

        # avoid running function before start is finished

   185

        self.startsem.acquire()

   186

        self.startsem.release()

   187

        if self.timeout:

   188

            self.timeout.cancel()

   189

        self.exitcode = ecode

   191

            self.log_the_end(ecode, pid)

   192

        if self.finish_callback is not None:

   193

            self.finish_callback(self, ecode, pid)

   194

        self.errt.join()

   195

        self.finishsem.release()

   196

   197

    def kill(self, gently=True):

   198

        # avoid running kill before start is finished

   199

        self.startsem.acquire()

   200

        self.startsem.release()

   201

   202

        self.outt.killed = True

   203

        self.errt.killed = True

   204

        if os.name in ("nt", "ce"):

   205

            PROCESS_TERMINATE = 1

   206

            handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False, self.Proc.pid)

   207

            ctypes.windll.kernel32.TerminateProcess(handle, -1)

   208

            ctypes.windll.kernel32.CloseHandle(handle)

   209

        else:

   210

            if gently:

   211

                sig = signal.SIGTERM

   212

            else:

   213

                sig = signal.SIGKILL

   214

            try:

   215

                os.kill(self.Proc.pid, sig)

   216

            except Exception:

   217

                pass

   218

        self.outt.join()

   219

        self.errt.join()

   220

   221

    def endlog(self):

   222

        if self.endlock.acquire(False):

   223

            if not self.outt.finished and self.kill_it:

   224

                self.kill()

   225

            self.finishsem.release()

   226

   227

    def spin(self):

   228

        self.finishsem.acquire()

   229

        return [self.exitcode, "".join(self.outdata), "".join(self.errdata)]