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 MainWorker

    38

    39

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

    40

    dlopen = _ctypes.LoadLibrary

    41

    dlclose = _ctypes.FreeLibrary

    42

elif os.name == "posix":

    43

    dlopen = _ctypes.dlopen

    44

    dlclose = _ctypes.dlclose

    45

    46

    47

def get_last_traceback(tb):

    48

    while tb.tb_next:

    49

        tb = tb.tb_next

    50

    return tb

    51

    52

    53

lib_ext = {

    54

    "linux2": ".so",

    55

    "win32":  ".dll",

    56

}.get(sys.platform, "")

    57

    58

    59

def PLCprint(message):

    60

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

    61

    sys.stdout.flush()

    62

    63

    64

def RunInMain(func):

    65

    def func_wrapper(*args, **kwargs):

    66

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

    67

    return func_wrapper

    68

    69

    70

class PLCObject(object):

    71

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

    72

        self.workingdir = WorkingDir

    73

        # FIXME : is argv of any use nowadays ?

    74

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

    75

        self.statuschange = statuschange

    76

        self.evaluator = evaluator

    77

        self.pyruntimevars = pyruntimevars

    78

        self.PLCStatus = "Empty"

    79

        self.PLClibraryHandle = None

    80

        self.PLClibraryLock = Lock()

    81

        # Creates fake C funcs proxies

    82

        self._InitPLCStubCalls()

    83

        self._loading_error = None

    84

        self.python_runtime_vars = None

    85

        self.TraceThread = None

    86

        self.TraceLock = Lock()

    87

        self.Traces = []

    88

    89

    # First task of worker -> no @RunInMain

    90

    def AutoLoad(self, autostart):

    91

        # Get the last transfered PLC

    92

        try:

    93

            self.CurrentPLCFilename = open(

    94

                self._GetMD5FileName(),

    95

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

    96

            if self.LoadPLC():

    97

                self.PLCStatus = "Stopped"

    98

                if autostart:

    99

                    self.StartPLC()

   100

                    return

   101

        except Exception:

   102

            self.PLCStatus = "Empty"

   103

            self.CurrentPLCFilename = None

   104

   105

        self.StatusChange()

   106

   107

    def StatusChange(self):

   108

        if self.statuschange is not None:

   109

            for callee in self.statuschange:

   110

                callee(self.PLCStatus)

   111

   112

    @RunInMain

   113

    def LogMessage(self, *args):

   114

        if len(args) == 2:

   115

            level, msg = args

   116

        else:

   117

            level = LogLevelsDefault

   118

            msg, = args

   119

        PLCprint(msg)

   120

        if self._LogMessage is not None:

   121

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

   122

        return None

   123

   124

    @RunInMain

   125

    def ResetLogCount(self):

   126

        if self._ResetLogCount is not None:

   127

            self._ResetLogCount()

   128

   129

    # used internaly

   130

    def GetLogCount(self, level):

   131

        if self._GetLogCount is not None:

   132

            return int(self._GetLogCount(level))

   133

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

   134

            return 1

   135

   136

    @RunInMain

   137

    def GetLogMessage(self, level, msgid):

   138

        tick = ctypes.c_uint32()

   139

        tv_sec = ctypes.c_uint32()

   140

        tv_nsec = ctypes.c_uint32()

   141

        if self._GetLogMessage is not None:

   142

            maxsz = len(self._log_read_buffer)-1

   143

            sz = self._GetLogMessage(level, msgid,

   144

                                     self._log_read_buffer, maxsz,

   145

                                     ctypes.byref(tick),

   146

                                     ctypes.byref(tv_sec),

   147

                                     ctypes.byref(tv_nsec))

   148

            if sz and sz <= maxsz:

   149

                self._log_read_buffer[sz] = '\x00'

   150

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

   151

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

   152

            return self._loading_error, 0, 0, 0

   153

        return None

   154

   155

    def _GetMD5FileName(self):

   156

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

   157

   158

    def _GetLibFileName(self):

   159

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

   160

   161

    def _LoadPLC(self):

   162

        """

   163

        Load PLC library

   164

        Declare all functions, arguments and return values

   165

        """

   166

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

   167

        self.PLClibraryLock.acquire()

   168

        try:

   169

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

   170

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

   171

   172

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

   173

            if len(md5) == 32:

   174

                self.PLC_ID.value = md5

   175

   176

            self._startPLC = self.PLClibraryHandle.startPLC

   177

            self._startPLC.restype = ctypes.c_int

   178

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

   179

   180

            self._stopPLC_real = self.PLClibraryHandle.stopPLC

   181

            self._stopPLC_real.restype = None

   182

   183

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

   184

            if self._PythonIterator is not None:

   185

                self._PythonIterator.restype = ctypes.c_char_p

   186

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

   187

   188

                self._stopPLC = self._stopPLC_real

   189

            else:

   190

                # If python confnode is not enabled, we reuse _PythonIterator

   191

                # as a call that block pythonthread until StopPLC

   192

                self.PlcStopping = Event()

   193

   194

                def PythonIterator(res, blkid):

   195

                    self.PlcStopping.clear()

   196

                    self.PlcStopping.wait()

   197

                    return None

   198

                self._PythonIterator = PythonIterator

   199

   200

                def __StopPLC():

   201

                    self._stopPLC_real()

   202

                    self.PlcStopping.set()

   203

                self._stopPLC = __StopPLC

   204

   205

            self._ResetDebugVariables = self.PLClibraryHandle.ResetDebugVariables

   206

            self._ResetDebugVariables.restype = None

   207

   208

            self._RegisterDebugVariable = self.PLClibraryHandle.RegisterDebugVariable

   209

            self._RegisterDebugVariable.restype = None

   210

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

   211

   212

            self._FreeDebugData = self.PLClibraryHandle.FreeDebugData

   213

            self._FreeDebugData.restype = None

   214

   215

            self._GetDebugData = self.PLClibraryHandle.GetDebugData

   216

            self._GetDebugData.restype = ctypes.c_int

   217

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

   218

   219

            self._suspendDebug = self.PLClibraryHandle.suspendDebug

   220

            self._suspendDebug.restype = ctypes.c_int

   221

            self._suspendDebug.argtypes = [ctypes.c_int]

   222

   223

            self._resumeDebug = self.PLClibraryHandle.resumeDebug

   224

            self._resumeDebug.restype = None

   225

   226

            self._ResetLogCount = self.PLClibraryHandle.ResetLogCount

   227

            self._ResetLogCount.restype = None

   228

   229

            self._GetLogCount = self.PLClibraryHandle.GetLogCount

   230

            self._GetLogCount.restype = ctypes.c_uint32

   231

            self._GetLogCount.argtypes = [ctypes.c_uint8]

   232

   233

            self._LogMessage = self.PLClibraryHandle.LogMessage

   234

            self._LogMessage.restype = ctypes.c_int

   235

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

   236

   237

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

   238

            self._GetLogMessage = self.PLClibraryHandle.GetLogMessage

   239

            self._GetLogMessage.restype = ctypes.c_uint32

   240

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

   241

   242

            self._loading_error = None

   243

   244

        except Exception:

   245

            self._loading_error = traceback.format_exc()

   246

            PLCprint(self._loading_error)

   247

            return False

   248

        finally:

   249

            self.PLClibraryLock.release()

   250

   251

        return True

   252

   253

    @RunInMain

   254

    def LoadPLC(self):

   255

        res = self._LoadPLC()

   256

        if res:

   257

            self.PythonRuntimeInit()

   258

        else:

   259

            self._FreePLC()

   260

   261

        return res

   262

   263

    @RunInMain

   264

    def UnLoadPLC(self):

   265

        self.PythonRuntimeCleanup()

   266

        self._FreePLC()

   267

   268

    def _InitPLCStubCalls(self):

   269

        """

   270

        create dummy C func proxies

   271

        """

   272

        self._startPLC = lambda x, y: None

   273

        self._stopPLC = lambda: None

   274

        self._ResetDebugVariables = lambda: None

   275

        self._RegisterDebugVariable = lambda x, y: None

   276

        self._IterDebugData = lambda x, y: None

   277

        self._FreeDebugData = lambda: None

   278

        self._GetDebugData = lambda: -1

   279

        self._suspendDebug = lambda x: -1

   280

        self._resumeDebug = lambda: None

   281

        self._PythonIterator = lambda: ""

   282

        self._GetLogCount = None

   283

        self._LogMessage = None

   284

        self._GetLogMessage = None

   285

        self._PLClibraryHandle = None

   286

        self.PLClibraryHandle = None

   287

   288

    def _FreePLC(self):

   289

        """

   290

        Unload PLC library.

   291

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

   292

        """

   293

        self.PLClibraryLock.acquire()

   294

        try:

   295

            # Unload library explicitely

   296

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

   297

                dlclose(self._PLClibraryHandle)

   298

   299

            # Forget all refs to library

   300

            self._InitPLCStubCalls()

   301

   302

        finally:

   303

            self.PLClibraryLock.release()

   304

   305

        return False

   306

   307

    def PythonRuntimeCall(self, methodname):

   308

        """

   309

        Calls init, start, stop or cleanup method provided by

   310

        runtime python files, loaded when new PLC uploaded

   311

        """

   312

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

   313

            _res, exp = self.evaluator(method)

   314

            if exp is not None:

   315

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

   316

   317

    # used internaly

   318

    def PythonRuntimeInit(self):

   319

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

   320

        self.python_runtime_vars = globals().copy()

   321

        self.python_runtime_vars.update(self.pyruntimevars)

   322

        parent = self

   323

   324

        class PLCSafeGlobals(object):

   325

            def __getattr__(self, name):

   326

                try:

   327

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

   328

                except KeyError:

   329

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

   330

                v = t()

   331

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

   332

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

   333

   334

            def __setattr__(self, name, value):

   335

                try:

   336

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

   337

                except KeyError:

   338

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

   339

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

   340

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

   341

   342

        self.python_runtime_vars.update({

   343

            "PLCGlobals":     PLCSafeGlobals(),

   344

            "WorkingDir":     self.workingdir,

   345

            "PLCObject":      self,

   346

            "PLCBinary":      self.PLClibraryHandle,

   347

            "PLCGlobalsDesc": []})

   348

   349

        for methodname in MethodNames:

   350

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

   351

   352

        try:

   353

            filenames = os.listdir(self.workingdir)

   354

            filenames.sort()

   355

            for filename in filenames:

   356

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

   357

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

   358

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

   359

                    for methodname in MethodNames:

   360

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

   361

                        if method is not None:

   362

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

   363

        except Exception:

   364

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

   365

            raise

   366

   367

        self.PythonRuntimeCall("init")

   368

   369

    # used internaly

   370

    def PythonRuntimeCleanup(self):

   371

        if self.python_runtime_vars is not None:

   372

            self.PythonRuntimeCall("cleanup")

   373

   374

        self.python_runtime_vars = None

   375

   376

    def PythonThreadProc(self):

   377

        self.StartSem.release()

   378

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

   379

        compile_cache = {}

   380

        while True:

   381

            cmd = self._PythonIterator(res, blkid)

   382

            FBID = blkid.value

   383

            if cmd is None:

   384

                break

   385

            try:

   386

                self.python_runtime_vars["FBID"] = FBID

   387

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

   388

                if ccmd is None or ccmd != cmd:

   389

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

   390

                    compile_cache[FBID] = (cmd, AST)

   391

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

   392

                if exp is not None:

   393

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

   394

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

   395

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

   396

                else:

   397

                    res = str(result)

   398

                self.python_runtime_vars["FBID"] = None

   399

            except Exception, e:

   400

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

   401

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

   402

   403

    @RunInMain

   404

    def StartPLC(self):

   405

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

   406

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

   407

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

   408

            if res == 0:

   409

                self.PLCStatus = "Started"

   410

                self.StatusChange()

   411

                self.PythonRuntimeCall("start")

   412

                self.StartSem = Semaphore(0)

   413

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

   414

                self.PythonThread.start()

   415

                self.StartSem.acquire()

   416

                self.LogMessage("PLC started")

   417

            else:

   418

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

   419

                self.PLCStatus = "Broken"

   420

                self.StatusChange()

   421

   422

    @RunInMain

   423

    def StopPLC(self):

   424

        if self.PLCStatus == "Started":

   425

            self.LogMessage("PLC stopped")

   426

            self._stopPLC()

   427

            self.PythonThread.join()

   428

            self.PLCStatus = "Stopped"

   429

            self.StatusChange()

   430

            self.PythonRuntimeCall("stop")

   431

            if self.TraceThread is not None:

   432

                self.TraceThread.join()

   433

                self.TraceThread = None

   434

            return True

   435

        return False

   436

   437

    @RunInMain

   438

    def GetPLCstatus(self):

   439

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

   440

   441

    @RunInMain

   442

    def GetPLCID(self):

   443

        return getPSKID()

   444

   445

    @RunInMain

   446

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

   447

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

   448

            NewFileName = md5sum + lib_ext

   449

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

   450

   451

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

   452

                if self.CurrentPLCFilename is not None \

   453

                else None

   454

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

   455

   456

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

   457

            replace_PLC_shared_object = new_PLC_filename != old_PLC_filename

   458

   459

            if replace_PLC_shared_object:

   460

                self.UnLoadPLC()

   461

   462

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

   463

            self.PLCStatus = "Empty"

   464

   465

            try:

   466

                if replace_PLC_shared_object:

   467

                    os.remove(old_PLC_filename)

   468

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

   469

                    try:

   470

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

   471

                    except Exception:

   472

                        pass

   473

            except Exception:

   474

                pass

   475

   476

            try:

   477

                # Create new PLC file

   478

                if replace_PLC_shared_object: