1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz runtime.

     5

#

     6

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     7

#

     8

# See COPYING.Runtime file for copyrights details.

     9

#

    10

# This library is free software; you can redistribute it and/or

    11

# modify it under the terms of the GNU Lesser General Public

    12

# License as published by the Free Software Foundation; either

    13

# version 2.1 of the License, or (at your option) any later version.

    14

    15

# This library is distributed in the hope that it will be useful,

    16

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    17

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18

# Lesser General Public License for more details.

    19

    20

# You should have received a copy of the GNU Lesser General Public

    21

# License along with this library; if not, write to the Free Software

    22

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

    23

    24

    25

from __future__ import absolute_import

    26

from threading import Thread, Lock, Semaphore, Event

    27

import ctypes

    28

import os

    29

import sys

    30

import traceback

    31

from time import time

    32

import _ctypes  # pylint: disable=wrong-import-order

    33

    34

from runtime.typemapping import TypeTranslator

    35

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    36

from runtime.Stunnel import getPSKID

    37

from runtime import PlcStatus

    38

from runtime import MainWorker

    39

    40

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

    41

    dlopen = _ctypes.LoadLibrary

    42

    dlclose = _ctypes.FreeLibrary

    43

elif os.name == "posix":

    44

    dlopen = _ctypes.dlopen

    45

    dlclose = _ctypes.dlclose

    46

    47

    48

def get_last_traceback(tb):

    49

    while tb.tb_next:

    50

        tb = tb.tb_next

    51

    return tb

    52

    53

    54

lib_ext = {

    55

    "linux2": ".so",

    56

    "win32":  ".dll",

    57

}.get(sys.platform, "")

    58

    59

    60

def PLCprint(message):

    61

    sys.stdout.write("PLCobject : "+message+"\n")

    62

    sys.stdout.flush()

    63

    64

    65

def RunInMain(func):

    66

    def func_wrapper(*args, **kwargs):

    67

        return MainWorker.call(func, *args, **kwargs)

    68

    return func_wrapper

    69

    70

    71

class PLCObject(object):

    72

    def __init__(self, WorkingDir, argv, statuschange, evaluator, pyruntimevars):

    73

        self.workingdir = WorkingDir

    74

        # FIXME : is argv of any use nowadays ?

    75

        self.argv = [WorkingDir] + argv  # force argv[0] to be "path" to exec...

    76

        self.statuschange = statuschange

    77

        self.evaluator = evaluator

    78

        self.pyruntimevars = pyruntimevars

    79

        self.PLCStatus = PlcStatus.Empty

    80

        self.PLClibraryHandle = None

    81

        self.PLClibraryLock = Lock()

    82

        # Creates fake C funcs proxies

    83

        self._InitPLCStubCalls()

    84

        self._loading_error = None

    85

        self.python_runtime_vars = None

    86

        self.TraceThread = None

    87

        self.TraceLock = Lock()

    88

        self.Traces = []

    89

    90

    # First task of worker -> no @RunInMain

    91

    def AutoLoad(self, autostart):

    92

        # Get the last transfered PLC

    93

        try:

    94

            self.CurrentPLCFilename = open(

    95

                self._GetMD5FileName(),

    96

                "r").read().strip() + lib_ext

    97

            if self.LoadPLC():

    98

                self.PLCStatus = "Stopped"

    99

                if autostart:

   100

                    self.StartPLC()

   101

                    return

   102

        except Exception:

   103

            self.PLCStatus = "Empty"

   104

            self.CurrentPLCFilename = None

   105

   106

        self.StatusChange()

   107

   108

    def StatusChange(self):

   109

        if self.statuschange is not None:

   110

            for callee in self.statuschange:

   111

                callee(self.PLCStatus)

   112

   113

    @RunInMain

   114

    def LogMessage(self, *args):

   115

        if len(args) == 2:

   116

            level, msg = args

   117

        else:

   118

            level = LogLevelsDefault

   119

            msg, = args

   120

        PLCprint(msg)

   121

        if self._LogMessage is not None:

   122

            return self._LogMessage(level, msg, len(msg))

   123

        return None

   124

   125

    @RunInMain

   126

    def ResetLogCount(self):

   127

        if self._ResetLogCount is not None:

   128

            self._ResetLogCount()

   129

   130

    # used internaly

   131

    def GetLogCount(self, level):

   132

        if self._GetLogCount is not None:

   133

            return int(self._GetLogCount(level))

   134

        elif self._loading_error is not None and level == 0:

   135

            return 1

   136

   137

    @RunInMain

   138

    def GetLogMessage(self, level, msgid):

   139

        tick = ctypes.c_uint32()

   140

        tv_sec = ctypes.c_uint32()

   141

        tv_nsec = ctypes.c_uint32()

   142

        if self._GetLogMessage is not None:

   143

            maxsz = len(self._log_read_buffer)-1

   144

            sz = self._GetLogMessage(level, msgid,

   145

                                     self._log_read_buffer, maxsz,

   146

                                     ctypes.byref(tick),

   147

                                     ctypes.byref(tv_sec),

   148

                                     ctypes.byref(tv_nsec))

   149

            if sz and sz <= maxsz:

   150

                self._log_read_buffer[sz] = '\x00'

   151

                return self._log_read_buffer.value, tick.value, tv_sec.value, tv_nsec.value

   152

        elif self._loading_error is not None and level == 0:

   153

            return self._loading_error, 0, 0, 0

   154

        return None

   155

   156

    def _GetMD5FileName(self):

   157

        return os.path.join(self.workingdir, "lasttransferedPLC.md5")

   158

   159

    def _GetLibFileName(self):

   160

        return os.path.join(self.workingdir, self.CurrentPLCFilename)

   161

   162

    def _LoadPLC(self):

   163

        """

   164

        Load PLC library

   165

        Declare all functions, arguments and return values

   166

        """

   167

        md5 = open(self._GetMD5FileName(), "r").read()

   168

        self.PLClibraryLock.acquire()

   169

        try:

   170

            self._PLClibraryHandle = dlopen(self._GetLibFileName())

   171

            self.PLClibraryHandle = ctypes.CDLL(self.CurrentPLCFilename, handle=self._PLClibraryHandle)

   172

   173

            self.PLC_ID = ctypes.c_char_p.in_dll(self.PLClibraryHandle, "PLC_ID")

   174

            if len(md5) == 32:

   175

                self.PLC_ID.value = md5

   176

   177

            self._startPLC = self.PLClibraryHandle.startPLC

   178

            self._startPLC.restype = ctypes.c_int

   179

            self._startPLC.argtypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_char_p)]

   180

   181

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   182

            self._stopPLC_real.restype = None

   183

   184

            self._PythonIterator = getattr(self.PLClibraryHandle, "PythonIterator", None)

   185

            if self._PythonIterator is not None:

   186

                self._PythonIterator.restype = ctypes.c_char_p

   187

                self._PythonIterator.argtypes = [ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]

   188

   189

                self._stopPLC = self._stopPLC_real

   190

            else:

   191

                # If python confnode is not enabled, we reuse _PythonIterator

   192

                # as a call that block pythonthread until StopPLC

   193

                self.PlcStopping = Event()

   194

   195

                def PythonIterator(res, blkid):

   196

                    self.PlcStopping.clear()

   197

                    self.PlcStopping.wait()

   198

                    return None

   199

                self._PythonIterator = PythonIterator

   200

   201

                def __StopPLC():

   202

                    self._stopPLC_real()

   203

                    self.PlcStopping.set()

   204

                self._stopPLC = __StopPLC

   205

   206

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   207

            self._ResetDebugVariables.restype = None

   208

   209

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   210

            self._RegisterDebugVariable.restype = None

   211

            self._RegisterDebugVariable.argtypes = [ctypes.c_int, ctypes.c_void_p]

   212

   213

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   214

            self._FreeDebugData.restype = None

   215

   216

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   217

            self._GetDebugData.restype = ctypes.c_int

   218

            self._GetDebugData.argtypes = [ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_void_p)]

   219

   220

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   221

            self._suspendDebug.restype = ctypes.c_int

   222

            self._suspendDebug.argtypes = [ctypes.c_int]

   223

   224

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   225

            self._resumeDebug.restype = None

   226

   227

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   228

            self._ResetLogCount.restype = None

   229

   230

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   231

            self._GetLogCount.restype = ctypes.c_uint32

   232

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   233

   234

            self._LogMessage = self.PLClibraryHandle.LogMessage

   235

            self._LogMessage.restype = ctypes.c_int

   236

            self._LogMessage.argtypes = [ctypes.c_uint8, ctypes.c_char_p, ctypes.c_uint32]

   237

   238

            self._log_read_buffer = ctypes.create_string_buffer(1 << 14)  # 16K

   239

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   240

            self._GetLogMessage.restype = ctypes.c_uint32

   241

            self._GetLogMessage.argtypes = [ctypes.c_uint8, ctypes.c_uint32, ctypes.c_char_p, ctypes.c_uint32, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_uint32)]

   242

   243

            self._loading_error = None

   244

   245

        except Exception:

   246

            self._loading_error = traceback.format_exc()

   247

            PLCprint(self._loading_error)

   248

            return False

   249

        finally:

   250

            self.PLClibraryLock.release()

   251

   252

        return True

   253

   254

    @RunInMain

   255

    def LoadPLC(self):

   256

        res = self._LoadPLC()

   257

        if res:

   258

            self.PythonRuntimeInit()

   259

        else:

   260

            self._FreePLC()

   261

   262

        return res

   263

   264

    @RunInMain

   265

    def UnLoadPLC(self):

   266

        self.PythonRuntimeCleanup()

   267

        self._FreePLC()

   268

   269

    def _InitPLCStubCalls(self):

   270

        """

   271

        create dummy C func proxies

   272

        """

   273

        self._startPLC = lambda x, y: None

   274

        self._stopPLC = lambda: None

   275

        self._ResetDebugVariables = lambda: None

   276

        self._RegisterDebugVariable = lambda x, y: None

   277

        self._IterDebugData = lambda x, y: None

   278

        self._FreeDebugData = lambda: None

   279

        self._GetDebugData = lambda: -1

   280

        self._suspendDebug = lambda x: -1

   281

        self._resumeDebug = lambda: None

   282

        self._PythonIterator = lambda: ""

   283

        self._GetLogCount = None

   284

        self._LogMessage = None

   285

        self._GetLogMessage = None

   286

        self._PLClibraryHandle = None

   287

        self.PLClibraryHandle = None

   288

   289

    def _FreePLC(self):

   290

        """

   291

        Unload PLC library.

   292

        This is also called by __init__ to create dummy C func proxies

   293

        """

   294

        self.PLClibraryLock.acquire()

   295

        try:

   296

            # Unload library explicitely

   297

            if getattr(self, "_PLClibraryHandle", None) is not None:

   298

                dlclose(self._PLClibraryHandle)

   299

   300

            # Forget all refs to library

   301

            self._InitPLCStubCalls()

   302

   303

        finally:

   304

            self.PLClibraryLock.release()

   305

   306

        return False

   307

   308

    def PythonRuntimeCall(self, methodname):

   309

        """

   310

        Calls init, start, stop or cleanup method provided by

   311

        runtime python files, loaded when new PLC uploaded

   312

        """

   313

        for method in self.python_runtime_vars.get("_runtime_%s" % methodname, []):

   314

            _res, exp = self.evaluator(method)

   315

            if exp is not None:

   316

                self.LogMessage(0, '\n'.join(traceback.format_exception(*exp)))

   317

   318

    # used internaly

   319

    def PythonRuntimeInit(self):

   320

        MethodNames = ["init", "start", "stop", "cleanup"]

   321

        self.python_runtime_vars = globals().copy()

   322

        self.python_runtime_vars.update(self.pyruntimevars)

   323

        parent = self

   324

   325

        class PLCSafeGlobals(object):

   326

            def __getattr__(self, name):

   327

                try:

   328

                    t = parent.python_runtime_vars["_"+name+"_ctype"]

   329

                except KeyError:

   330

                    raise KeyError("Try to get unknown shared global variable : %s" % name)

   331

                v = t()

   332

                parent.python_runtime_vars["_PySafeGetPLCGlob_"+name](ctypes.byref(v))

   333

                return parent.python_runtime_vars["_"+name+"_unpack"](v)

   334

   335

            def __setattr__(self, name, value):

   336

                try:

   337

                    t = parent.python_runtime_vars["_"+name+"_ctype"]

   338

                except KeyError:

   339

                    raise KeyError("Try to set unknown shared global variable : %s" % name)

   340

                v = parent.python_runtime_vars["_"+name+"_pack"](t, value)

   341

                parent.python_runtime_vars["_PySafeSetPLCGlob_"+name](ctypes.byref(v))

   342

   343

        self.python_runtime_vars.update({

   344

            "PLCGlobals":     PLCSafeGlobals(),

   345

            "WorkingDir":     self.workingdir,

   346

            "PLCObject":      self,

   347

            "PLCBinary":      self.PLClibraryHandle,

   348

            "PLCGlobalsDesc": []})

   349

   350

        for methodname in MethodNames:

   351

            self.python_runtime_vars["_runtime_%s" % methodname] = []

   352

   353

        try:

   354

            filenames = os.listdir(self.workingdir)

   355

            filenames.sort()

   356

            for filename in filenames:

   357

                name, ext = os.path.splitext(filename)

   358

                if name.upper().startswith("RUNTIME") and ext.upper() == ".PY":

   359

                    execfile(os.path.join(self.workingdir, filename), self.python_runtime_vars)

   360

                    for methodname in MethodNames:

   361

                        method = self.python_runtime_vars.get("_%s_%s" % (name, methodname), None)

   362

                        if method is not None:

   363

                            self.python_runtime_vars["_runtime_%s" % methodname].append(method)

   364

        except Exception:

   365

            self.LogMessage(0, traceback.format_exc())

   366

            raise

   367

   368

        self.PythonRuntimeCall("init")

   369

   370

    # used internaly

   371

    def PythonRuntimeCleanup(self):

   372

        if self.python_runtime_vars is not None:

   373

            self.PythonRuntimeCall("cleanup")

   374

   375

        self.python_runtime_vars = None

   376

   377

    def PythonThreadProc(self):

   378

        self.StartSem.release()

   379

        res, cmd, blkid = "None", "None", ctypes.c_void_p()

   380

        compile_cache = {}

   381

        while True:

   382

            cmd = self._PythonIterator(res, blkid)

   383

            FBID = blkid.value

   384

            if cmd is None:

   385

                break

   386

            try:

   387

                self.python_runtime_vars["FBID"] = FBID

   388

                ccmd, AST = compile_cache.get(FBID, (None, None))

   389

                if ccmd is None or ccmd != cmd:

   390

                    AST = compile(cmd, '<plc>', 'eval')

   391

                    compile_cache[FBID] = (cmd, AST)

   392

                result, exp = self.evaluator(eval, AST, self.python_runtime_vars)

   393

                if exp is not None:

   394

                    res = "#EXCEPTION : "+str(exp[1])

   395

                    self.LogMessage(1, ('PyEval@0x%x(Code="%s") Exception "%s"') % (

   396

                        FBID, cmd, '\n'.join(traceback.format_exception(*exp))))

   397

                else:

   398

                    res = str(result)

   399

                self.python_runtime_vars["FBID"] = None

   400

            except Exception as e:

   401

                res = "#EXCEPTION : "+str(e)

   402

                self.LogMessage(1, ('PyEval@0x%x(Code="%s") Exception "%s"') % (FBID, cmd, str(e)))

   403

   404

    @RunInMain

   405

    def StartPLC(self):

   406

        if self.CurrentPLCFilename is not None and self.PLCStatus == PlcStatus.Stopped:

   407

            c_argv = ctypes.c_char_p * len(self.argv)

   408

            res = self._startPLC(len(self.argv), c_argv(*self.argv))

   409

            if res == 0:

   410

                self.PLCStatus = PlcStatus.Started

   411

                self.StatusChange()

   412

                self.PythonRuntimeCall("start")

   413

                self.StartSem = Semaphore(0)

   414

                self.PythonThread = Thread(target=self.PythonThreadProc)

   415

                self.PythonThread.start()

   416

                self.StartSem.acquire()

   417

                self.LogMessage("PLC started")

   418

            else:

   419

                self.LogMessage(0, _("Problem starting PLC : error %d" % res))

   420

                self.PLCStatus = PlcStatus.Broken

   421

                self.StatusChange()

   422

   423

    @RunInMain

   424

    def StopPLC(self):

   425

        if self.PLCStatus == PlcStatus.Started:

   426

            self.LogMessage("PLC stopped")

   427

            self._stopPLC()

   428

            self.PythonThread.join()

   429

            self.PLCStatus = PlcStatus.Stopped

   430

            self.StatusChange()

   431

            self.PythonRuntimeCall("stop")

   432

            if self.TraceThread is not None:

   433

                self.TraceThread.join()

   434

                self.TraceThread = None

   435

            return True

   436

        return False

   437

   438

    @RunInMain

   439

    def GetPLCstatus(self):

   440

        return self.PLCStatus, map(self.GetLogCount, xrange(LogLevelsCount))

   441

   442

    @RunInMain

   443

    def GetPLCID(self):

   444

        return getPSKID()

   445

   446

    @RunInMain

   447

    def NewPLC(self, md5sum, data, extrafiles):

   448

        if self.PLCStatus in [PlcStatus.Stopped, PlcStatus.Empty, PlcStatus.Broken]:

   449

            NewFileName = md5sum + lib_ext

   450

            extra_files_log = os.path.join(self.workingdir, "extra_files.txt")

   451

   452

            old_PLC_filename = os.path.join(self.workingdir, self.CurrentPLCFilename) \

   453

                if self.CurrentPLCFilename is not None \

   454

                else None

   455

            new_PLC_filename = os.path.join(self.workingdir, NewFileName)

   456

   457

            # Some platform (i.e. Xenomai) don't like reloading same .so file

   458

            replace_PLC_shared_object = new_PLC_filename != old_PLC_filename

   459

   460

            if replace_PLC_shared_object:

   461

                self.UnLoadPLC()

   462

   463

            self.LogMessage("NewPLC (%s)" % md5sum)

   464

            self.PLCStatus = PlcStatus.Empty

   465

   466

            try:

   467

                if replace_PLC_shared_object:

   468

                    os.remove(old_PLC_filename)

   469

                for filename in file(extra_files_log, "r").readlines() + [extra_files_log]:

   470

                    try:

   471

                        os.remove(os.path.join(self.workingdir, filename.strip()))

   472

                    except Exception:

   473

                        pass

   474

            except Exception:

   475

                pass

   476

   477

            try: