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

import time

    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

    51

    def run(self):

    52

        outchunk = None

    53

        self.retval = None

    54

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

    55

            if self.endcallback:

    56

                self.retval = self.Proc.poll()

    57

            else:

    58

                self.retval = self.Proc.returncode

    59

    60

            outchunk = self.fd.readline()

    61

            if self.callback:

    62

                self.callback(outchunk)

    63

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

    64

            outchunk = self.fd.readline()

    65

            if self.callback:

    66

                self.callback(outchunk)

    67

        if self.endcallback:

    68

            try:

    69

                err = self.Proc.wait()

    70

            except Exception:

    71

                err = self.retval

    72

            self.finished = True

    73

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

    74

    75

    76

class ProcessLogger(object):

    77

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

    78

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

    79

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

    80

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

    81

                 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

        self.spinwakeuplock = Lock()

   159

        self.spinwakeupcond = Condition(self.spinwakeuplock)

   160

        self.spinwakeuptimer = None

   161

   162

    def output(self, v):

   163

        if v and self.output_encoding:

   164

            v = v.decode(self.output_encoding)

   165

        self.outdata.append(v)

   166

        self.outlen += 1

   167

        if self.logger and not self.no_stdout:

   168

            self.logger.write(v)

   169

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

   170

            self.endlog()

   171

   172

    def errors(self, v):

   173

        if v and self.output_encoding:

   174

            v = v.decode(self.output_encoding)

   175

        self.errdata.append(v)

   176

        self.errlen += 1

   177

        if self.logger and not self.no_stderr:

   178

            self.logger.write_warning(v)

   179

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

   180

            self.endlog()

   181

   182

    def log_the_end(self, ecode, pid):

   183

        if self.logger is not None:

   184

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

   185

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

   186

   187

    def finish(self, pid, ecode):

   188

        # avoid running function before start is finished

   189

        self.startsem.acquire()

   190

        self.startsem.release()

   191

        if self.timeout:

   192

            self.timeout.cancel()

   193

        self.exitcode = ecode

   194

        if _debug or self.exitcode != 0:

   195

            self.log_the_end(ecode, pid)

   196

        if self.finish_callback is not None:

   197

            self.finish_callback(self, ecode, pid)

   198

        self.errt.join()

   199

        self.finishsem.release()

   200

        self.spinwakeup()

   201

   202

    def kill(self, gently=True):

   203

        # avoid running kill before start is finished

   204

        self.startsem.acquire()

   205

        self.startsem.release()

   206

   207

        self.outt.killed = True

   208

        self.errt.killed = True

   209

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

   210

            PROCESS_TERMINATE = 1

   211

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

   212

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

   213

            ctypes.windll.kernel32.CloseHandle(handle)

   214

        else:

   215

            if gently:

   216

                sig = signal.SIGTERM

   217

            else:

   218

                sig = signal.SIGKILL

   219

            try:

   220

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

   221

            except Exception:

   222

                pass

   223

        self.outt.join()

   224

        self.errt.join()

   225

   226

    def endlog(self):

   227

        if self.endlock.acquire(False):

   228

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

   229

                self.kill()

   230

            self.finishsem.release()

   231

            self.spinwakeup()

   232

   233

    def spinwakeup(self):

   234

        with self.spinwakeuplock:

   235

            if self.spinwakeuptimer is not None:

   236

                self.spinwakeuptimer.cancel()

   237

            self.spinwakeuptimer = None

   238

            self.spinwakeupcond.notify()

   239

   240

    def spin(self):

   241

        start = time.time()

   242

        if self.logger:

   243

            while not self.finishsem.acquire(0):

   244

                with self.spinwakeuplock:

   245

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

   246

                    self.spinwakeuptimer.start()

   247

                    self.spinwakeupcond.wait()

   248

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

   249

        else:

   250

            self.finishsem.acquire()

   251

   252

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