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

import os

    26

import sys

    27

import time

    28

import wx

    29

import subprocess

    30

import ctypes

    31

from threading import Timer, Lock, Thread, Semaphore

    32

if os.name == 'posix':

    33

    from signal import SIGTERM, SIGKILL

    34

    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:

    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):

    81

        self.logger = logger

    82

        if not isinstance(Command, list):

    83

            self.Command_str = Command

    84

            self.Command = []

    85

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

    86

                if i % 2 == 0:

    87

                    word = word.strip()

    88

                    if len(word) > 0:

    89

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

    90

                else:

    91

                    self.Command.append(word)

    92

        else:

    93

            self.Command = Command

    94

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

    95

    96

        fsencoding = sys.getfilesystemencoding()

    97

    98

        if encoding is None:

    99

            encoding = fsencoding

   100

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

   101

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

   102

   103

        self.finish_callback = finish_callback

   104

        self.no_stdout = no_stdout

   105

        self.no_stderr = no_stderr

   106

        self.startupinfo = None

   107

        self.errlen = 0

   108

        self.outlen = 0

   109

        self.errlimit = errlimit

   110

        self.outlimit = outlimit

   111

        self.exitcode = None

   112

        self.outdata = []

   113

        self.errdata = []

   114

        self.keyword = keyword

   115

        self.kill_it = kill_it

   116

        self.startsem = Semaphore(0)

   117

        self.finishsem = Semaphore(0)

   118

        self.endlock = Lock()

   119

   120

        popenargs = {

   121

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

   122

               "stdin":  subprocess.PIPE,

   123

               "stdout": subprocess.PIPE,

   124

               "stderr": subprocess.PIPE

   125

        }

   126

   127

        if no_gui and wx.Platform == '__WXMSW__':

   128

            self.startupinfo = subprocess.STARTUPINFO()

   129

            self.startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

   130

            popenargs["startupinfo"] = self.startupinfo

   131

        elif wx.Platform == '__WXGTK__':

   132

            popenargs["shell"] = False

   133

   134

        if timeout:

   135

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

   136

            self.timeout.start()

   137

        else:

   138

            self.timeout = None

   139

   140

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

   141

   142

        self.outt = outputThread(

   143

                      self.Proc,

   144

                      self.Proc.stdout,

   145

                      self.output,

   146

                      self.finish)

   147

        self.outt.start()

   148

   149

        self.errt = outputThread(

   150

                      self.Proc,

   151

                      self.Proc.stderr,

   152

                      self.errors)

   153

        self.errt.start()

   154

        self.startsem.release()

   155

   156

    def output(self, v):

   157

        self.outdata.append(v)

   158

        self.outlen += 1

   159

        if not self.no_stdout:

   160

            self.logger.write(v)

   161

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

   162

            self.endlog()

   163

   164

    def errors(self, v):

   165

        self.errdata.append(v)

   166

        self.errlen += 1

   167

        if not self.no_stderr:

   168

            self.logger.write_warning(v)

   169

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

   170

            self.endlog()

   171

   172

    def log_the_end(self, ecode, pid):

   173

        self.logger.write(self.Command_str + "\n")

   174

        self.logger.write_warning(_("exited with status {a1} (pid {a2})\n").format(a1=str(ecode), a2=str(pid)))

   175

   176

    def finish(self, pid, ecode):

   177

        # avoid running function before start is finished

   178

        self.startsem.acquire()

   179

        if self.timeout:

   180

            self.timeout.cancel()

   181

        self.exitcode = ecode

   182

        if self.exitcode != 0:

   183

            self.log_the_end(ecode, pid)

   184

        if self.finish_callback is not None:

   185

            self.finish_callback(self, ecode, pid)

   186

        self.errt.join()

   187

        self.finishsem.release()

   188

   189

    def kill(self, gently=True):

   190

        # avoid running kill before start is finished

   191

        self.startsem.acquire()

   192

        self.startsem.release()

   193

   194

        self.outt.killed = True

   195

        self.errt.killed = True

   196

        if wx.Platform == '__WXMSW__':

   197

            PROCESS_TERMINATE = 1

   198

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

   199

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

   200

            ctypes.windll.kernel32.CloseHandle(handle)

   201

        else:

   202

            if gently:

   203

                sig = SIGTERM

   204

            else:

   205

                sig = SIGKILL

   206

            try:

   207

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

   208

            except Exception:

   209

                pass

   210

        self.outt.join()

   211

        self.errt.join()

   212

   213

    def endlog(self):

   214

        if self.endlock.acquire(False):

   215

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

   216

                self.kill()

   217

            self.finishsem.release()

   218

   219

    def spin(self):

   220

        self.finishsem.acquire()

   221

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