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

    34

    35

class outputThread(Thread):

    36

    """

    37

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

    38

    """

    39

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

    40

        Thread.__init__(self)

    41

        self.killed = False

    42

        self.finished = False

    43

        self.retval = None

    44

        self.Proc = Proc

    45

        self.callback = callback

    46

        self.endcallback = endcallback

    47

        self.fd = fd

    48

    49

    def run(self):

    50

        outchunk = None

    51

        self.retval = None

    52

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

    53

            if self.endcallback:

    54

                self.retval = self.Proc.poll()

    55

            else:

    56

                self.retval = self.Proc.returncode

    57

    58

            outchunk = self.fd.readline()

    59

            if self.callback:

    60

                self.callback(outchunk)

    61

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

    62

            outchunk = self.fd.readline()

    63

            if self.callback:

    64

                self.callback(outchunk)

    65

        if self.endcallback:

    66

            try:

    67

                err = self.Proc.wait()

    68

            except Exception:

    69

                err = self.retval

    70

            self.finished = True

    71

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

    72

    73

    74

class ProcessLogger(object):

    75

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

    76

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

    77

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

    78

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

    79

                 encoding=None, output_encoding=None):

    80

        self.logger = logger

    81

        if not isinstance(Command, list):

    82

            self.Command_str = Command

    83

            self.Command = []

    84

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

    85

                if i % 2 == 0:

    86

                    word = word.strip()

    87

                    if len(word) > 0:

    88

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

    89

                else:

    90

                    self.Command.append(word)

    91

        else:

    92

            self.Command = Command

    93

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

    94

    95

        fsencoding = sys.getfilesystemencoding()

    96

        self.output_encoding = output_encoding

    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 os.name in ("nt", "ce"):

   128

            self.startupinfo = subprocess.STARTUPINFO()

   129

            self.startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

   130

            popenargs["startupinfo"] = self.startupinfo

   131

        elif os.name == 'posix':

   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

        if v and self.output_encoding:

   158

            v = v.decode(self.output_encoding)

   159

        self.outdata.append(v)

   160

        self.outlen += 1

   161

        if not self.no_stdout:

   162

            self.logger.write(v)

   163

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

   164

            self.endlog()

   165

   166

    def errors(self, v):

   167

        if v and self.output_encoding:

   168

            v = v.decode(self.output_encoding)

   169

        self.errdata.append(v)

   170

        self.errlen += 1

   171

        if not self.no_stderr:

   172

            self.logger.write_warning(v)

   173

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

   174

            self.endlog()

   175

   176

    def log_the_end(self, ecode, pid):

   177

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

   178

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

   179

   180

    def finish(self, pid, ecode):

   181

        # avoid running function before start is finished

   182

        self.startsem.acquire()

   183

        self.startsem.release()

   184

        if self.timeout:

   185

            self.timeout.cancel()

   186

        self.exitcode = ecode

   187

        if self.exitcode != 0:

   188

            self.log_the_end(ecode, pid)

   189

        if self.finish_callback is not None:

   190

            self.finish_callback(self, ecode, pid)

   191

        self.errt.join()

   192

        self.finishsem.release()

   193

   194

    def kill(self, gently=True):

   195

        # avoid running kill before start is finished

   196

        self.startsem.acquire()

   197

        self.startsem.release()

   198

   199

        self.outt.killed = True

   200

        self.errt.killed = True

   201

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

   202

            PROCESS_TERMINATE = 1

   203

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

   204

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

   205

            ctypes.windll.kernel32.CloseHandle(handle)

   206

        else:

   207

            if gently:

   208

                sig = signal.SIGTERM

   209

            else:

   210

                sig = signal.SIGKILL

   211

            try:

   212

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

   213

            except Exception:

   214

                pass

   215

        self.outt.join()

   216

        self.errt.join()

   217

   218

    def endlog(self):

   219

        if self.endlock.acquire(False):

   220

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

   221

                self.kill()

   222

            self.finishsem.release()

   223

   224

    def spin(self):

   225

        self.finishsem.acquire()

   226

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