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

import os

    27

import sys

    28

import subprocess

    29

import ctypes

    30

import time

    31

import shlex

    32

from threading import Timer, Lock, Thread, Semaphore, Condition

    33

import signal

    34

    35

_debug = os.path.exists("BEREMIZ_DEBUG")

    36

    37

class outputThread(Thread):

    38

    """

    39

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

    40

    """

    41

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

    42

        Thread.__init__(self)

    43

        self.killed = False

    44

        self.finished = False

    45

        self.retval = None

    46

        self.Proc = Proc

    47

        self.callback = callback

    48

        self.endcallback = endcallback

    49

        self.fd = fd

    50

        self.daemon = True

    51

    52

    def run(self):

    53

        outchunk = None

    54

        self.retval = None

    55

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

    56

            if self.endcallback:

    57

                self.retval = self.Proc.poll()

    58

            else:

    59

                self.retval = self.Proc.returncode

    60

    61

            outchunk = self.fd.readline()

    62

            if self.callback:

    63

                self.callback(outchunk)

    64

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

    65

            outchunk = self.fd.readline()

    66

            if self.callback:

    67

                self.callback(outchunk)

    68

        if self.endcallback:

    69

            try:

    70

                err = self.Proc.wait()

    71

            except Exception:

    72

                err = self.retval

    73

            self.finished = True

    74

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

    75

    76

    77

class ProcessLogger(object):

    78

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

    79

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

    80

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

    81

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

    82

                 encoding=None, output_encoding=None, env=None):

    83

        self.logger = logger

    84

        if not isinstance(Command, list):

    85

            self.Command_str = Command

    86

            self.Command = shlex.split(Command)

    87

        else:

    88

            self.Command = Command

    89

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

    90

    91

        fsencoding = sys.getfilesystemencoding()

    92

        self.output_encoding = output_encoding

    93

    94

        if encoding is None:

    95

            encoding = fsencoding

    96

        self.Command = [self.Command[0].encode(fsencoding)]+[x.encode(encoding) for x in self.Command[1:]]

    97

    98

        self.finish_callback = finish_callback

    99

        self.no_stdout = no_stdout

   100

        self.no_stderr = no_stderr

   101

        self.startupinfo = None

   102

        self.errlen = 0

   103

        self.outlen = 0

   104

        self.errlimit = errlimit

   105

        self.outlimit = outlimit

   106

        self.exitcode = None

   107

        self.outdata = []

   108

        self.errdata = []

   109

        self.keyword = keyword

   110

        self.kill_it = kill_it

   111

        self.startsem = Semaphore(0)

   112

        self.finishsem = Semaphore(0)

   113

        self.endlock = Lock()

   114

   115

        popenargs = {

   116

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

   117

            "stdin":  subprocess.PIPE,

   118

            "stdout": subprocess.PIPE,

   119

            "stderr": subprocess.PIPE,

   120

            "env":    env

   121

        }

   122

   123

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

   124

            self.startupinfo = subprocess.STARTUPINFO()

   125

            self.startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW

   126

            popenargs["startupinfo"] = self.startupinfo

   127

        elif os.name == 'posix':

   128

            popenargs["shell"] = False

   129

   130

        if timeout:

   131

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

   132

            self.timeout.start()

   133

        else:

   134

            self.timeout = None

   135

   136

        if _debug and self.logger:

   137

            self.logger.write("(DEBUG) launching:\n" + self.Command_str + "\n")

   138

   139

        self.Proc = subprocess.Popen(self.Command, encoding="utf-8", errors="backslashreplace", **popenargs)

   140

   141

        self.outt = outputThread(

   142

            self.Proc,

   143

            self.Proc.stdout,

   144

            self.output,

   145

            self.finish)

   146

        self.outt.start()

   147

   148

        self.errt = outputThread(

   149

            self.Proc,

   150

            self.Proc.stderr,

   151

            self.errors)

   152

        self.errt.start()

   153

        self.startsem.release()

   154

   155

        self.spinwakeuplock = Lock()

   156

        self.spinwakeupcond = Condition(self.spinwakeuplock)

   157

        self.spinwakeuptimer = None

   158

   159

    def output(self, v):

   160

        if v and self.output_encoding:

   161

            v = v.decode(self.output_encoding)

   162

        self.outdata.append(v)

   163

        self.outlen += 1

   164

        if self.logger and not self.no_stdout:

   165

            self.logger.write(v)

   166

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

   167

            self.endlog()

   168

   169

    def errors(self, v):

   170

        if v and self.output_encoding:

   171

            v = v.decode(self.output_encoding)

   172

        self.errdata.append(v)

   173

        self.errlen += 1

   174

        if self.logger and not self.no_stderr:

   175

            self.logger.write_warning(v)

   176

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

   177

            self.endlog()

   178

   179

    def log_the_end(self, ecode, pid):

   180

        if self.logger is not None:

   181

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

   182

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

   183

   184

    def finish(self, pid, ecode):

   185

        # avoid running function before start is finished

   186

        self.startsem.acquire()

   187

        self.startsem.release()

   188

        if self.timeout:

   189

            self.timeout.cancel()

   190

        self.exitcode = ecode

   191

        if self.exitcode != 0:

   192

            self.log_the_end(ecode, pid)

   193

        if self.finish_callback is not None:

   194

            self.finish_callback(self, ecode, pid)

   195

        self.errt.join()

   196

        self.finishsem.release()

   197

        self.spinwakeup()

   198

   199

    def kill(self, gently=True):

   200

        # avoid running kill before start is finished

   201

        self.startsem.acquire()

   202

        self.startsem.release()

   203

   204

        self.outt.killed = True

   205

        self.errt.killed = True

   206

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

   207

            PROCESS_TERMINATE = 1

   208

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

   209

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

   210

            ctypes.windll.kernel32.CloseHandle(handle)

   211

        else:

   212

            if gently:

   213

                sig = signal.SIGTERM

   214

            else:

   215

                sig = signal.SIGKILL

   216

            try:

   217

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

   218

            except Exception:

   219

                pass

   220

        self.outt.join()

   221

        self.errt.join()

   222

   223

    def endlog(self):

   224

        if self.endlock.acquire(False):

   225

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

   226

                self.kill()

   227

            self.finishsem.release()

   228

            self.spinwakeup()

   229

   230

    def spinwakeup(self):

   231

        with self.spinwakeuplock:

   232

            if self.spinwakeuptimer is not None:

   233

                self.spinwakeuptimer.cancel()

   234

            self.spinwakeuptimer = None

   235

            self.spinwakeupcond.notify()

   236

   237

    def spin(self):

   238

        start = time.time()

   239

        if self.logger:

   240

            while not self.finishsem.acquire(0):

   241

                with self.spinwakeuplock:

   242

                    self.spinwakeuptimer = Timer(0.1, self.spinwakeup)

   243

                    self.spinwakeuptimer.start()

   244

                    self.spinwakeupcond.wait()

   245

                    self.logger.progress("%.3fs"%(time.time() - start))

   246

        else:

   247

            self.finishsem.acquire()

   248

   249

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