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

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

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

    13

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

    14

# as published by the Free Software Foundation; either version 2

    15

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

    16

#

    17

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

    18

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

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

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

    23

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

    24

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

    25

    26

    27

import os

    28

import sys

    29

import getopt

    30

import threading

    31

import shlex

    32

import traceback

    33

import threading

    34

from threading import Thread, Semaphore, Lock, current_thread

    35

import builtins

    36

from functools import partial

    37

    38

import runtime

    39

from runtime.eRPCServer import eRPCServer as RPCServer

    40

from runtime.xenomai import TryPreloadXenomai

    41

from runtime import LogMessageAndException

    42

from runtime import PlcStatus

    43

from runtime import default_evaluator

    44

from runtime.Stunnel import ensurePSK

    45

import util.paths as paths

    46

    47

# In case system time is ajusted, it is better to use

    48

# monotonic timers for timers and other timeout based operations.

    49

# hot-patch threading module to force using monitonic time for all 

    50

# Thread/Timer/Event/Condition

    51

    52

from runtime.monotonic_time import monotonic

    53

threading._time = monotonic

    54

    55

try:

    56

    from runtime.spawn_subprocess import Popen

    57

except ImportError:

    58

    from subprocess import Popen

    59

    60

def version():

    61

    from version import app_version

    62

    print("Beremiz_service: ", app_version)

    63

    64

    65

def usage():

    66

    version()

    67

    print("""

    68

Usage of Beremiz PLC execution service :\n

    69

%s {[-n servicename] [-i IP] [-p port] [-x enabletaskbar] [-a autostart]|-h|--help} working_dir

    70

  -n  service name (default:None, zeroconf discovery disabled)

    71

  -i  IP address of interface to bind to (default:localhost)

    72

  -p  port number default:3000

    73

  -h  print this help text and quit

    74

  -a  autostart PLC (0:disable 1:enable) (default:0)

    75

  -x  enable/disable wxTaskbarIcon (0:disable 1:enable) (default:1)

    76

  -t  enable/disable Twisted web interface (0:disable 1:enable) (default:1)

    77

  -w  web server port or "off" to disable web server (default:8009)

    78

  -c  WAMP client config file or Configuration directory containing "wamconf.json" (default:Wamp disabled, config dir is working_dir)

    79

      Note: Wamp config is overriden by wampconf.json given in project files.

    80

  -s  PSK secret file or existing KeyStore directory containing "psk.txt" (default:PSK disabled, KeyStore is working_dir)

    81

  -e  python extension (absolute path .py)

    82

    83

           working_dir - directory where are stored PLC files

    84

""" % sys.argv[0])

    85

    86

    87

try:

    88

    opts, argv = getopt.getopt(sys.argv[1:], "i:p:n:x:t:a:w:c:e:s:h", ["help", "version", "status-change=", "on-plc-start=", "on-plc-stop="])

    89

except getopt.GetoptError as err:

    90

    # print help information and exit:

    91

    print(str(err))  # will print something like "option -a not recognized"

    92

    usage()

    93

    sys.exit(2)

    94

    95

# default values

    96

interface = ''

    97

port = 3000

    98

webport = 8009

    99

PSKpath = None

   100

KeyStore = None

   101

ConfDir = None

   102

wampconf = None

   103

servicename = None

   104

autostart = False

   105

enablewx = True

   106

havewx = False

   107

enabletwisted = True

   108

havetwisted = False

   109

   110

extensions = []

   111

statuschange = []

   112

def status_change_call_factory(wanted, args):

   113

    def status_change_call(status):

   114

        if wanted is None or status is wanted:

   115

            cmd = shlex.split(args.format(status))

   116

            Popen(cmd)

   117

    return status_change_call

   118

   119

for o, a in opts:

   120

    if o == "-h" or o == "--help":

   121

        usage()

   122

        sys.exit()

   123

    if o == "--version":

   124

        version()

   125

        sys.exit()

   126

    if o == "--on-plc-start":

   127

        statuschange.append(status_change_call_factory(PlcStatus.Started, a))

   128

    elif o == "--on-plc-stop":

   129

        statuschange.append(status_change_call_factory(PlcStatus.Stopped, a))

   130

    elif o == "--status-change":

   131

        statuschange.append(status_change_call_factory(None, a))

   132

    elif o == "-i":

   133

        if len(a.split(".")) == 4:

   134

            interface = a

   135

        elif a == "localhost":

   136

            interface = '127.0.0.1'

   137

        else:

   138

            usage()

   139

            sys.exit()

   140

    elif o == "-p":

   141

        # port: port that the service runs on

   142

        port = int(a)

   143

    elif o == "-n":

   144

        servicename = a

   145

    elif o == "-x":

   146

        enablewx = int(a)

   147

    elif o == "-t":

   148

        enabletwisted = int(a)

   149

    elif o == "-a":

   150

        autostart = int(a)

   151

    elif o == "-w":

   152

        webport = None if a == "off" else int(a)

   153

    elif o == "-c":

   154

        if a == "off":

   155

            wampconf = None 

   156

        elif os.path.isdir(a):

   157

            ConfDir = a

   158

            _PSKpath = os.path.join(a, "wampconf.json")

   159

            if os.path.isfile(_PSKpath):

   160

                wampconf = _PSKpath

   161

        elif os.path.isfile(a) or os.path.isdir(paths.AbsDir(a)):

   162

            wampconf = a

   163

            ConfDir = paths.AbsDir(a)

   164

    elif o == "-s":

   165

        if a == "off":

   166

            PSKpath = None 

   167

        elif os.path.isdir(a):

   168

            KeyStore = a

   169

            _PSKpath = os.path.join(a, "psk.txt")

   170

            if os.path.isfile(_PSKpath):

   171

                PSKpath = _PSKpath

   172

        elif os.path.isfile(a) or os.path.isdir(paths.AbsDir(a)):

   173

            PSKpath = a

   174

            KeyStore = paths.AbsDir(a)

   175

   176

    elif o == "-e":

   177

        fnameanddirname = list(os.path.split(os.path.realpath(a)))

   178

        fnameanddirname.reverse()

   179

        extensions.append(fnameanddirname)

   180

    else:

   181

        usage()

   182

        sys.exit()

   183

   184

   185

beremiz_dir = paths.AbsDir(__file__)

   186

   187

if len(argv) > 1:

   188

    usage()

   189

    sys.exit()

   190

elif len(argv) == 1:

   191

    WorkingDir = argv[0]

   192

    os.chdir(WorkingDir)

   193

elif len(argv) == 0:

   194

    WorkingDir = os.getcwd()

   195

    argv = [WorkingDir]

   196

   197

builtins.__dict__['_'] = lambda x: x

   198

# TODO: add a cmdline parameter if Trying Preloading Xenomai makes problem

   199

TryPreloadXenomai()

   200

version()

   201

   202

   203

def Bpath(*args):

   204

    return os.path.join(beremiz_dir, *args)

   205

   206

   207

import locale

   208

# Matiec's standard library relies on libC's locale-dependent

   209

# string to/from number convertions, but IEC-61131 counts

   210

# on '.' for decimal point. Therefore locale is reset to "C" */

   211

locale.setlocale(locale.LC_NUMERIC, "C")

   212

   213

def SetupI18n():

   214

    # Get folder containing translation files

   215

    localedir = os.path.join(beremiz_dir, "locale")

   216

    # Get the default language

   217

    langid = wx.LANGUAGE_DEFAULT

   218

    # Define translation domain (name of translation files)

   219

    domain = "Beremiz"

   220

   221

    # Define locale for wx

   222

    loc = builtins.__dict__.get('loc', None)

   223

    if loc is None:

   224

        wx.LogGui.EnableLogging(False)

   225

        loc = wx.Locale(langid)

   226

        wx.LogGui.EnableLogging(True)

   227

        builtins.__dict__['loc'] = loc

   228

        # Define location for searching translation files

   229

    loc.AddCatalogLookupPathPrefix(localedir)

   230

    # Define locale domain

   231

    loc.AddCatalog(domain)

   232

   233

    builtins.__dict__['_'] = wx.GetTranslation

   234

   235

   236

# Life is hard... have a candy.

   237

# pylint: disable=wrong-import-position,wrong-import-order

   238

if enablewx:

   239

    try:

   240

        import wx

   241

        havewx = True

   242

    except ImportError:

   243

        print("Wx unavailable !")

   244

        havewx = False

   245

   246

    if havewx:

   247

        import re

   248

        import wx.adv

   249

   250

        app = wx.App(redirect=False)

   251

        app.GTKSuppressDiagnostics()

   252

        app.SetTopWindow(wx.Frame(None, -1))

   253

   254

        default_locale = None

   255

        SetupI18n()

   256

   257

        defaulticon = wx.Image(Bpath("images", "brz.png"))

   258

        starticon = wx.Image(Bpath("images", "icoplay24.png"))

   259

        stopicon = wx.Image(Bpath("images", "icostop24.png"))

   260

   261

        class ParamsEntryDialog(wx.TextEntryDialog):

   262

   263

            def __init__(self, parent, message, caption=_("Please enter text"), defaultValue="",

   264

                         style=wx.OK | wx.CANCEL | wx.CENTRE, pos=wx.DefaultPosition):

   265

                wx.TextEntryDialog.__init__(self, parent, message, caption, defaultValue, style, pos)

   266

   267

                self.Tests = []

   268

                self.Bind(wx.EVT_BUTTON, self.OnOK, id=self.GetAffirmativeId())

   269

   270

            def OnOK(self, event):

   271

                value = self.GetValue()

   272

                texts = {"value": value}

   273

                for function, message in self.Tests:

   274

                    if not function(value):

   275

                        message = wx.MessageDialog(self, message % texts, _("Error"), wx.OK | wx.ICON_ERROR)

   276

                        message.ShowModal()

   277

                        message.Destroy()

   278

                        return

   279

                self.EndModal(wx.ID_OK)

   280

                event.Skip()

   281

   282

            def GetValue(self):

   283

                return self.GetSizer().GetItem(1).GetWindow().GetValue()

   284

   285

            def SetTests(self, tests):

   286

                self.Tests = tests

   287

   288

        class BeremizTaskBarIcon(wx.adv.TaskBarIcon):

   289

            TBMENU_START = wx.NewIdRef()

   290

            TBMENU_STOP = wx.NewIdRef()

   291

            TBMENU_CHANGE_NAME = wx.NewIdRef()

   292

            TBMENU_CHANGE_PORT = wx.NewIdRef()

   293

            TBMENU_CHANGE_INTERFACE = wx.NewIdRef()

   294

            TBMENU_LIVE_SHELL = wx.NewIdRef()

   295

            TBMENU_WXINSPECTOR = wx.NewIdRef()

   296

            # TBMENU_CHANGE_WD = wx.NewIdRef()

   297

            TBMENU_QUIT = wx.NewIdRef()

   298

   299

            def __init__(self, rpc_server):

   300

                wx.adv.TaskBarIcon.__init__(self)

   301

                self.rpc_server = rpc_server

   302

                # Set the image

   303

                self.UpdateIcon(None)

   304

   305

                # bind some events

   306

                self.Bind(wx.EVT_MENU, self.OnTaskBarStartPLC, id=self.TBMENU_START)

   307

                self.Bind(wx.EVT_MENU, self.OnTaskBarStopPLC, id=self.TBMENU_STOP)

   308

                self.Bind(wx.EVT_MENU, self.OnTaskBarChangeName, id=self.TBMENU_CHANGE_NAME)

   309

                self.Bind(wx.EVT_MENU, self.OnTaskBarChangeInterface, id=self.TBMENU_CHANGE_INTERFACE)

   310

                self.Bind(wx.EVT_MENU, self.OnTaskBarLiveShell, id=self.TBMENU_LIVE_SHELL)

   311

                self.Bind(wx.EVT_MENU, self.OnTaskBarWXInspector, id=self.TBMENU_WXINSPECTOR)

   312

                self.Bind(wx.EVT_MENU, self.OnTaskBarChangePort, id=self.TBMENU_CHANGE_PORT)

   313

                # self.Bind(wx.EVT_MENU, self.OnTaskBarChangeWorkingDir, id=self.TBMENU_CHANGE_WD)

   314

                self.Bind(wx.EVT_MENU, self.OnTaskBarQuit, id=self.TBMENU_QUIT)

   315

   316

            def CreatePopupMenu(self):

   317

                """

   318

                This method is called by the base class when it needs to popup

   319

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   320

                the menu how you want it and return it from this function,

   321

                the base class takes care of the rest.

   322

                """

   323

                menu = wx.Menu()

   324

                menu.Append(self.TBMENU_START, _("Start PLC"))

   325

                menu.Append(self.TBMENU_STOP, _("Stop PLC"))

   326

                menu.AppendSeparator()

   327

                menu.Append(self.TBMENU_CHANGE_NAME, _("Change Name"))

   328

                menu.Append(self.TBMENU_CHANGE_INTERFACE, _("Change IP of interface to bind"))

   329

                menu.Append(self.TBMENU_CHANGE_PORT, _("Change Port Number"))

   330

                # menu.Append(self.TBMENU_CHANGE_WD, _("Change working directory"))

   331

                menu.AppendSeparator()

   332

                menu.Append(self.TBMENU_LIVE_SHELL, _("Launch a live Python shell"))

   333

                menu.Append(self.TBMENU_WXINSPECTOR, _("Launch WX GUI inspector"))

   334

                menu.AppendSeparator()

   335

                menu.Append(self.TBMENU_QUIT, _("Quit"))

   336

                return menu

   337

   338

            def MakeIcon(self, img):

   339

                """

   340

                The various platforms have different requirements for the

   341

                icon size...

   342

                """

   343

                if "wxMSW" in wx.PlatformInfo:

   344

                    img = img.Scale(16, 16)

   345

                elif "wxGTK" in wx.PlatformInfo:

   346

                    img = img.Scale(22, 22)

   347

                # wxMac can be any size upto 128x128, so leave the source img alone....

   348

                icon = wx.Icon(img.ConvertToBitmap())

   349

                return icon

   350

   351

            def OnTaskBarStartPLC(self, evt):

   352

                runtime.GetPLCObjectSingleton().StartPLC()

   353

   354

            def OnTaskBarStopPLC(self, evt):

   355

                runtime.GetPLCObjectSingleton().StopPLC()

   356

   357

            def OnTaskBarChangeInterface(self, evt):

   358

                ip_addr = self.rpc_server.ip_addr

   359

                ip_addr = '' if ip_addr is None else ip_addr

   360

                dlg = ParamsEntryDialog(None, _("Enter the IP of the interface to bind"), defaultValue=ip_addr)

   361

                dlg.SetTests([(re.compile(r'\d{1,3}(?:\.\d{1,3}){3}$').match, _("IP is not valid!")),

   362

                              (lambda x:len([x for x in x.split(".") if 0 <= int(x) <= 255]) == 4,

   363

                               _("IP is not valid!"))])

   364

                if dlg.ShowModal() == wx.ID_OK:

   365

                    self.rpc_server.ip_addr = dlg.GetValue()

   366

                    self.rpc_server.Restart()

   367

   368

            def OnTaskBarChangePort(self, evt):

   369

                dlg = ParamsEntryDialog(None, _("Enter a port number "), defaultValue=str(self.rpc_server.port))

   370

                dlg.SetTests([(str.isdigit, _("Port number must be an integer!")), (lambda port: 0 <= int(port) <= 65535, _("Port number must be 0 <= port <= 65535!"))])

   371

                if dlg.ShowModal() == wx.ID_OK:

   372

                    self.rpc_server.port = int(dlg.GetValue())

   373

                    self.rpc_server.Restart()

   374

   375

            # def OnTaskBarChangeWorkingDir(self, evt):

   376

            #     dlg = wx.DirDialog(None, _("Choose a working directory "), self.rpc_server.workdir, wx.DD_NEW_DIR_BUTTON)

   377

            #     if dlg.ShowModal() == wx.ID_OK:

   378

            #         self.rpc_server.workdir = dlg.GetPath()

   379

            #         self.rpc_server.Restart()

   380

   381

            def OnTaskBarChangeName(self, evt):

   382

                _servicename = self.rpc_server.servicename

   383

                _servicename = '' if _servicename is None else _servicename

   384

                dlg = ParamsEntryDialog(None, _("Enter a name "), defaultValue=_servicename)

   385

                dlg.SetTests([(lambda name: len(name) != 0, _("Name must not be null!"))])

   386

                if dlg.ShowModal() == wx.ID_OK:

   387

                    self.rpc_server.servicename = dlg.GetValue()

   388

                    self.rpc_server.Restart()

   389

   390

            def _LiveShellLocals(self):

   391

                return {"locals": runtime.GetPLCObjectSingleton().python_runtime_vars}

   392

   393

            def OnTaskBarLiveShell(self, evt):

   394

                from wx import py

   395

                frame = py.crust.CrustFrame(**self._LiveShellLocals())

   396

                frame.Show()

   397

   398

            def OnTaskBarWXInspector(self, evt):

   399

                # Activate the widget inspection tool

   400

                from wx.lib.inspection import InspectionTool

   401

                if not InspectionTool().initialized:

   402

                    InspectionTool().Init(**self._LiveShellLocals())

   403

   404

                wnd = wx.GetApp()

   405

                InspectionTool().Show(wnd, True)

   406

   407

            def OnTaskBarQuit(self, evt):

   408

                if wx.Platform == '__WXMSW__':

   409

                    Thread(target=self.rpc_server.Quit).start()

   410

                self.RemoveIcon()

   411

                wx.CallAfter(wx.GetApp().ExitMainLoop)

   412

   413

            def UpdateIcon(self, plcstatus):

   414

                if plcstatus is PlcStatus.Started:

   415

                    currenticon = self.MakeIcon(starticon)

   416

                elif plcstatus is PlcStatus.Stopped:

   417

                    currenticon = self.MakeIcon(stopicon)

   418

                else:

   419

                    currenticon = self.MakeIcon(defaulticon)

   420

                self.SetIcon(currenticon, "Beremiz Service")

   421

   422

   423

if not os.path.isdir(WorkingDir):

   424

    os.mkdir(WorkingDir)

   425

   426

   427

if enabletwisted:

   428

    import warnings

   429

    with warnings.catch_warnings():

   430

        warnings.simplefilter("ignore")

   431

        try:

   432

            if havewx:

   433

                from twisted.internet import wxreactor

   434

                wxreactor.install()

   435

                from twisted.internet import reactor

   436

                reactor.registerWxApp(app)

   437

            else:

   438

                # from twisted.internet import pollreactor

   439

                # pollreactor.install()

   440

                from twisted.internet import reactor

   441

   442

            havetwisted = True

   443

        except ImportError:

   444

            print(_("Twisted unavailable."))

   445

            havetwisted = False

   446

   447

pyruntimevars = {}

   448

   449

if havewx:

   450

    wx_eval_lock = Semaphore(0)

   451

   452

    def statuschangeTskBar(status):

   453

        wx.CallAfter(taskbar_instance.UpdateIcon, status)

   454

   455

    statuschange.append(statuschangeTskBar)

   456

   457

    def wx_evaluator(obj, *args, **kwargs):

   458

        tocall, args, kwargs = obj.call

   459

        obj.res = default_evaluator(tocall, *args, **kwargs)

   460

        wx_eval_lock.release()

   461

   462

    main_thread_id = current_thread().ident

   463

    def evaluator(tocall, *args, **kwargs):

   464

        # To prevent deadlocks, check if current thread is not one already main

   465

        current_id = current_thread().ident

   466

   467

        if main_thread_id != current_id:

   468

            o = type('', (object,), dict(call=(tocall, args, kwargs), res=None))

   469

            wx.CallAfter(wx_evaluator, o)

   470

            wx_eval_lock.acquire()

   471

            return o.res

   472

        else:

   473

            # avoid dead lock if called from main : do job immediately

   474

            return default_evaluator(tocall, *args, **kwargs)

   475

else:

   476

    evaluator = default_evaluator

   477

   478

# Exception hooks

   479

   480