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

        if _debug and self.logger:

   143

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

   144

   145

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

   146

   147

        self.outt = outputThread(

   148

            self.Proc,

   149

            self.Proc.stdout,

   150

            self.output,

   151

            self.finish)

   152

        self.outt.start()

   153

   154

        self.errt = outputThread(

   155

            self.Proc,

   156

            self.Proc.stderr,

   157

            self.errors)

   158

        self.errt.start()

   159

        self.startsem.release()

   160

   161

        self.spinwakeuplock = Lock()

   162

        self.spinwakeupcond = Condition(self.spinwakeuplock)

   163

        self.spinwakeuptimer = None

   164

   165

    def output(self, v):

   166

        if v and self.output_encoding:

   167

            v = v.decode(self.output_encoding)

   168

        self.outdata.append(v)

   169

        self.outlen += 1

   170

        if self.logger and not self.no_stdout:

   171

            self.logger.write(v)

   172

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

   173

            self.endlog()

   174

   175

    def errors(self, v):

   176

        if v and self.output_encoding:

   177

            v = v.decode(self.output_encoding)

   178

        self.errdata.append(v)

   179

        self.errlen += 1

   180

        if self.logger and not self.no_stderr:

   181

            self.logger.write_warning(v)

   182

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

   183

            self.endlog()

   184

   185

    def log_the_end(self, ecode, pid):

   186

        if self.logger is not None:

   187

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

   188

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

   189

   190

    def finish(self, pid, ecode):

   191

        # avoid running function before start is finished

   192

        self.startsem.acquire()

   193

        self.startsem.release()

   194

        if self.timeout:

   195

            self.timeout.cancel()

   196

        self.exitcode = ecode

   197

        if self.exitcode != 0:

   198

            self.log_the_end(ecode, pid)

   199

        if self.finish_callback is not None:

   200

            self.finish_callback(self, ecode, pid)

   201

        self.errt.join()

   202

        self.finishsem.release()

   203

        self.spinwakeup()

   204

   205

    def kill(self, gently=True):

   206

        # avoid running kill before start is finished

   207

        self.startsem.acquire()

   208

        self.startsem.release()

   209

   210

        self.outt.killed = True

   211

        self.errt.killed = True

   212

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

   213

            PROCESS_TERMINATE = 1

   214

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

   215

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

   216

            ctypes.windll.kernel32.CloseHandle(handle)

   217

        else:

   218

            if gently:

   219

                sig = signal.SIGTERM

   220

            else:

   221

                sig = signal.SIGKILL

   222

            try:

   223

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

   224

            except Exception:

   225

                pass

   226

        self.outt.join()

   227

        self.errt.join()

   228

   229

    def endlog(self):

   230

        if self.endlock.acquire(False):

   231

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

   232

                self.kill()

   233

            self.finishsem.release()

   234

            self.spinwakeup()

   235

   236

    def spinwakeup(self):

   237

        with self.spinwakeuplock:

   238

            if self.spinwakeuptimer is not None:

   239

                self.spinwakeuptimer.cancel()

   240

            self.spinwakeuptimer = None

   241

            self.spinwakeupcond.notify()

   242

   243

    def spin(self):

   244

        start = time.time()

   245

        if self.logger:

   246

            while not self.finishsem.acquire(0):

   247

                with self.spinwakeuplock:

   248

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

   249

                    self.spinwakeuptimer.start()

   250

                    self.spinwakeupcond.wait()

   251

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

   252

        else:

   253

            self.finishsem.acquire()

   254

   255

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