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

from past.builtins import execfile

    34

import Pyro.core as pyro

    35

import six

    36

from six.moves import _thread, xrange

    37

    38

from runtime.typemapping import TypeTranslator

    39

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

    40

from runtime.Stunnel import getPSKID

    41

from runtime import PlcStatus

    42

from runtime import MainWorker

    43

    44

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

    45

    dlopen = _ctypes.LoadLibrary

    46

    dlclose = _ctypes.FreeLibrary

    47

elif os.name == "posix":

    48

    dlopen = _ctypes.dlopen

    49

    dlclose = _ctypes.dlclose

    50

    51

    52

def get_last_traceback(tb):

    53

    while tb.tb_next:

    54

        tb = tb.tb_next

    55

    return tb

    56

    57

    58

lib_ext = {

    59

    "linux2": ".so",

    60

    "win32":  ".dll",

    61

}.get(sys.platform, "")

    62

    63

    64

def PLCprint(message):

    65

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

    66

    sys.stdout.flush()

    67

    68

    69

def RunInMain(func):

    70

    def func_wrapper(*args, **kwargs):

    71

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

    72

    return func_wrapper

    73

    74

    75

class PLCObject(object):

    76

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

    77

        self.workingdir = WorkingDir

    78

        # FIXME : is argv of any use nowadays ?

    79

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

    80

        self.statuschange = statuschange

    81

        self.evaluator = evaluator

    82

        self.pyruntimevars = pyruntimevars

    83

        self.PLCStatus = PlcStatus.Empty

    84

        self.PLClibraryHandle = None

    85

        self.PLClibraryLock = Lock()

    86

        # Creates fake C funcs proxies

    87

        self._InitPLCStubCalls()

    88

        self._loading_error = None

    89

        self.python_runtime_vars = None

    90

        self.TraceThread = None

    91

        self.TraceLock = Lock()

    92

        self.Traces = []

    93

    94

    # First task of worker -> no @RunInMain

    95

    def AutoLoad(self, autostart):

    96

        # Get the last transfered PLC

    97

        try:

    98

            self.CurrentPLCFilename = open(

    99

                self._GetMD5FileName(),

   100

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

   101

            if self.LoadPLC():

   102

                self.PLCStatus = PlcStatus.Stopped

   103

                if autostart:

   104

                    self.StartPLC()

   105

                    return

   106

        except Exception:

   107

            self.PLCStatus = PlcStatus.Empty

   108

            self.CurrentPLCFilename = None

   109

   110

        self.StatusChange()

   111

   112

    def StatusChange(self):

   113

        if self.statuschange is not None:

   114

            for callee in self.statuschange:

   115

                callee(self.PLCStatus)

   116

   117

    @RunInMain

   118

    def LogMessage(self, *args):

   119

        if len(args) == 2:

   120

            level, msg = args

   121

        else:

   122

            level = LogLevelsDefault

   123

            msg, = args

   124

        PLCprint(msg)

   125

        if self._LogMessage is not None:

   126

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

   127

        return None

   128

   129

    @RunInMain

   130

    def ResetLogCount(self):

   131

        if self._ResetLogCount is not None:

   132

            self._ResetLogCount()

   133

   134

    # used internaly

   135

    def GetLogCount(self, level):

   136

        if self._GetLogCount is not None:

   137

            return int(self._GetLogCount(level))

   138

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

   139

            return 1

   140

   141

    @RunInMain

   142

    def GetLogMessage(self, level, msgid):

   143

        tick = ctypes.c_uint32()

   144

        tv_sec = ctypes.c_uint32()

   145

        tv_nsec = ctypes.c_uint32()

   146

        if self._GetLogMessage is not None:

   147

            maxsz = len(self._log_read_buffer)-1

   148

            sz = self._GetLogMessage(level, msgid,

   149

                                     self._log_read_buffer, maxsz,

   150

                                     ctypes.byref(tick),

   151

                                     ctypes.byref(tv_sec),

   152

                                     ctypes.byref(tv_nsec))

   153

            if sz and sz <= maxsz:

   154

                self._log_read_buffer[sz] = '\x00'

   155

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

   156

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

   157

            return self._loading_error, 0, 0, 0

   158

        return None

   159

   160

    def _GetMD5FileName(self):

   161

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

   162

   163

    def _GetLibFileName(self):

   164

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

   165

   166

    def _LoadPLC(self):

   167

        """

   168

        Load PLC library

   169

        Declare all functions, arguments and return values

   170

        """

   171

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

   172

        self.PLClibraryLock.acquire()

   173

        try:

   174

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

   175

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

   176

   177

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

   178

            if len(md5) == 32:

   179

                self.PLC_ID.value = md5

   180

   181

            self._startPLC = self.PLClibraryHandle.startPLC

   182

            self._startPLC.restype = ctypes.c_int

   183

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

   184

   185

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   186

            self._stopPLC_real.restype = None

   187

   188

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

   189

            if self._PythonIterator is not None:

   190

                self._PythonIterator.restype = ctypes.c_char_p

   191

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

   192

   193

                self._stopPLC = self._stopPLC_real

   194

            else:

   195

                # If python confnode is not enabled, we reuse _PythonIterator

   196

                # as a call that block pythonthread until StopPLC

   197

                self.PlcStopping = Event()

   198

   199

                def PythonIterator(res, blkid):

   200

                    self.PlcStopping.clear()

   201

                    self.PlcStopping.wait()

   202

                    return None

   203

                self._PythonIterator = PythonIterator

   204

   205

                def __StopPLC():

   206

                    self._stopPLC_real()

   207

                    self.PlcStopping.set()

   208

                self._stopPLC = __StopPLC

   209

   210

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   211

            self._ResetDebugVariables.restype = None

   212

   213

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   214

            self._RegisterDebugVariable.restype = None

   215

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

   216

   217

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   218

            self._FreeDebugData.restype = None

   219

   220

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   221

            self._GetDebugData.restype = ctypes.c_int

   222

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

   223

   224

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   225

            self._suspendDebug.restype = ctypes.c_int

   226

            self._suspendDebug.argtypes = [ctypes.c_int]

   227

   228

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   229

            self._resumeDebug.restype = None

   230

   231

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   232

            self._ResetLogCount.restype = None

   233

   234

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   235

            self._GetLogCount.restype = ctypes.c_uint32

   236

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   237

   238

            self._LogMessage = self.PLClibraryHandle.LogMessage

   239

            self._LogMessage.restype = ctypes.c_int

   240

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

   241

   242

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

   243

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   244

            self._GetLogMessage.restype = ctypes.c_uint32

   245

            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)]

   246

   247

            self._loading_error = None

   248

   249

        except Exception:

   250

            self._loading_error = traceback.format_exc()

   251

            PLCprint(self._loading_error)

   252

            return False

   253

        finally:

   254

            self.PLClibraryLock.release()

   255

   256

        return True

   257

   258

    @RunInMain

   259

    def LoadPLC(self):

   260

        res = self._LoadPLC()

   261

        if res:

   262

            self.PythonRuntimeInit()

   263

        else:

   264

            self._FreePLC()

   265

   266

        return res

   267

   268

    @RunInMain

   269

    def UnLoadPLC(self):

   270

        self.PythonRuntimeCleanup()

   271

        self._FreePLC()

   272

   273

    def _InitPLCStubCalls(self):

   274

        """

   275

        create dummy C func proxies

   276

        """

   277

        self._startPLC = lambda x, y: None

   278

        self._stopPLC = lambda: None

   279

        self._ResetDebugVariables = lambda: None

   280

        self._RegisterDebugVariable = lambda x, y: None

   281

        self._IterDebugData = lambda x, y: None

   282

        self._FreeDebugData = lambda: None

   283

        self._GetDebugData = lambda: -1

   284

        self._suspendDebug = lambda x: -1

   285

        self._resumeDebug = lambda: None

   286

        self._PythonIterator = lambda: ""

   287

        self._GetLogCount = None

   288

        self._LogMessage = None

   289

        self._GetLogMessage = None

   290

        self._PLClibraryHandle = None

   291

        self.PLClibraryHandle = None

   292

   293

    def _FreePLC(self):

   294

        """

   295

        Unload PLC library.

   296

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

   297

        """

   298

        self.PLClibraryLock.acquire()

   299

        try:

   300

            # Unload library explicitely

   301

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

   302

                dlclose(self._PLClibraryHandle)

   303

   304

            # Forget all refs to library

   305

            self._InitPLCStubCalls()

   306

   307

        finally:

   308

            self.PLClibraryLock.release()

   309

   310

        return False

   311

   312

    def PythonRuntimeCall(self, methodname):

   313

        """

   314

        Calls init, start, stop or cleanup method provided by

   315

        runtime python files, loaded when new PLC uploaded

   316

        """

   317

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

   318

            _res, exp = self.evaluator(method)

   319

            if exp is not None:

   320

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

   321

   322

    # used internaly

   323

    def PythonRuntimeInit(self):

   324

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

   325

        self.python_runtime_vars = globals().copy()

   326

        self.python_runtime_vars.update(self.pyruntimevars)

   327

        parent = self

   328

   329

        class PLCSafeGlobals(object):

   330

            def __getattr__(self, name):

   331

                try:

   332

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

   333

                except KeyError:

   334

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

   335

                v = t()

   336

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

   337

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

   338

   339

            def __setattr__(self, name, value):

   340

                try:

   341

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

   342

                except KeyError:

   343

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

   344

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

   345

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

   346

   347

        self.python_runtime_vars.update({

   348

            "PLCGlobals":     PLCSafeGlobals(),

   349

            "WorkingDir":     self.workingdir,

   350

            "PLCObject":      self,

   351

            "PLCBinary":      self.PLClibraryHandle,

   352

            "PLCGlobalsDesc": []})

   353

   354

        for methodname in MethodNames:

   355

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

   356

   357

        try:

   358

            filenames = os.listdir(self.workingdir)

   359

            filenames.sort()

   360

            for filename in filenames:

   361

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

   362

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

   363

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

   364

                    for methodname in MethodNames:

   365

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

   366

                        if method is not None:

   367

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

   368

        except Exception:

   369

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

   370

            raise

   371

   372

        self.PythonRuntimeCall("init")

   373

   374

    # used internaly

   375

    def PythonRuntimeCleanup(self):

   376

        if self.python_runtime_vars is not None:

   377

            self.PythonRuntimeCall("cleanup")

   378

   379

        self.python_runtime_vars = None

   380

   381

    def PythonThreadProc(self):

   382

        self.StartSem.release()

   383

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

   384

        compile_cache = {}

   385

        while True:

   386

            cmd = self._PythonIterator(res, blkid)

   387

            FBID = blkid.value

   388

            if cmd is None:

   389

                break

   390

            try:

   391

                self.python_runtime_vars["FBID"] = FBID

   392

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

   393

                if ccmd is None or ccmd != cmd:

   394

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

   395

                    compile_cache[FBID] = (cmd, AST)

   396

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

   397

                if exp is not None:

   398

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

   399

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

   400

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

   401

                else:

   402

                    res = str(result)

   403

                self.python_runtime_vars["FBID"] = None

   404

            except Exception as e:

   405

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

   406

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

   407

   408

    @RunInMain

   409

    def StartPLC(self):

   410

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

   411

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

   412

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

   413

            if res == 0:

   414

                self.PLCStatus = PlcStatus.Started

   415

                self.StatusChange()

   416

                self.PythonRuntimeCall("start")

   417

                self.StartSem = Semaphore(0)

   418

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

   419

                self.PythonThread.start()

   420

                self.StartSem.acquire()

   421

                self.LogMessage("PLC started")

   422

            else:

   423

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

   424

                self.PLCStatus = PlcStatus.Broken

   425

                self.StatusChange()

   426

   427

    @RunInMain

   428

    def StopPLC(self):

   429

        if self.PLCStatus == PlcStatus.Started:

   430

            self.LogMessage("PLC stopped")

   431

            self._stopPLC()

   432

            self.PythonThread.join()

   433

            self.PLCStatus = PlcStatus.Stopped

   434

            self.StatusChange()

   435

            self.PythonRuntimeCall("stop")

   436

            if self.TraceThread is not None:

   437

                self.TraceThread.join()

   438

                self.TraceThread = None

   439

            return True

   440

        return False

   441

   442

    @RunInMain

   443

    def GetPLCstatus(self):

   444

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

   445

   446

    @RunInMain

   447

    def GetPLCID(self):

   448

        return getPSKID()

   449

   450

    @RunInMain

   451

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

   452

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

   453

            NewFileName = md5sum + lib_ext

   454

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

   455

   456

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

   457

                if self.CurrentPLCFilename is not None \

   458

                else None

   459

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

   460

   461

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

   462

            replace_PLC_shared_object = new_PLC_filename != old_PLC_filename

   463

   464

            if replace_PLC_shared_object:

   465

                self.UnLoadPLC()

   466

   467

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

   468

            self.PLCStatus = PlcStatus.Empty

   469

   470

            try:

   471

                if replace_PLC_shared_object:

   472

                    os.remove(old_PLC_filename)

   473

                for filename in open(extra_files_log, "rt").readlines() + [extra_files_log]:

   474

                    try:

   475

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

   476

                    except Exception:

   477

                        pass