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 (can be overriden by wampconf.json in project)

    79

  -s  PSK secret path (default:PSK disabled)

    80

  -e  python extension (absolute path .py)

    81

    82

           working_dir - directory where are stored PLC files

    83

""" % sys.argv[0])

    84

    85

    86

try:

    87

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

    88

except getopt.GetoptError as err:

    89

    # print help information and exit:

    90

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

    91

    usage()

    92

    sys.exit(2)

    93

    94

# default values

    95

interface = ''

    96

port = 3000

    97

webport = 8009

    98

PSKpath = None

    99

wampconf = None

   100

servicename = None

   101

autostart = False

   102

enablewx = True

   103

havewx = False

   104

enabletwisted = True

   105

havetwisted = False

   106

   107

extensions = []

   108

statuschange = []

   109

def status_change_call_factory(wanted, args):

   110

    def status_change_call(status):

   111

        if wanted is None or status is wanted:

   112

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

   113

            Popen(cmd)

   114

    return status_change_call

   115

   116

for o, a in opts:

   117

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

   118

        usage()

   119

        sys.exit()

   120

    if o == "--version":

   121

        version()

   122

        sys.exit()

   123

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

   124

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

   125

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

   126

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

   127

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

   128

        statuschange.append(status_change_call_factory(None, a))

   129

    elif o == "-i":

   130

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

   131

            interface = a

   132

        elif a == "localhost":

   133

            interface = '127.0.0.1'

   134

        else:

   135

            usage()

   136

            sys.exit()

   137

    elif o == "-p":

   138

        # port: port that the service runs on

   139

        port = int(a)

   140

    elif o == "-n":

   141

        servicename = a

   142

    elif o == "-x":

   143

        enablewx = int(a)

   144

    elif o == "-t":

   145

        enabletwisted = int(a)

   146

    elif o == "-a":

   147

        autostart = int(a)

   148

    elif o == "-w":

   149

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

   150

    elif o == "-c":

   151

        wampconf = None if a == "off" else a

   152

    elif o == "-s":

   153

        PSKpath = None if a == "off" else a

   154

    elif o == "-e":

   155

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

   156

        fnameanddirname.reverse()

   157

        extensions.append(fnameanddirname)

   158

    else:

   159

        usage()

   160

        sys.exit()

   161

   162

   163

beremiz_dir = paths.AbsDir(__file__)

   164

   165

if len(argv) > 1:

   166

    usage()

   167

    sys.exit()

   168

elif len(argv) == 1:

   169

    WorkingDir = argv[0]

   170

    os.chdir(WorkingDir)

   171

elif len(argv) == 0:

   172

    WorkingDir = os.getcwd()

   173

    argv = [WorkingDir]

   174

   175

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

   176

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

   177

TryPreloadXenomai()

   178

version()

   179

   180

   181

def Bpath(*args):

   182

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

   183

   184

   185

import locale

   186

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

   187

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

   188

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

   189

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

   190

   191

def SetupI18n():

   192

    # Get folder containing translation files

   193

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

   194

    # Get the default language

   195

    langid = wx.LANGUAGE_DEFAULT

   196

    # Define translation domain (name of translation files)

   197

    domain = "Beremiz"

   198

   199

    # Define locale for wx

   200

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

   201

    if loc is None:

   202

        wx.LogGui.EnableLogging(False)

   203

        loc = wx.Locale(langid)

   204

        wx.LogGui.EnableLogging(True)

   205

        builtins.__dict__['loc'] = loc

   206

        # Define location for searching translation files

   207

    loc.AddCatalogLookupPathPrefix(localedir)

   208

    # Define locale domain

   209

    loc.AddCatalog(domain)

   210

   211

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

   212

   213

   214

# Life is hard... have a candy.

   215

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

   216

if enablewx:

   217

    try:

   218

        import wx

   219

        havewx = True

   220

    except ImportError:

   221

        print("Wx unavailable !")

   222

        havewx = False

   223

   224

    if havewx:

   225

        import re

   226

        import wx.adv

   227

   228

        app = wx.App(redirect=False)

   229

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

   230

   231

        default_locale = None

   232

        SetupI18n()

   233

   234

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

   235

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

   236

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

   237

   238

        class ParamsEntryDialog(wx.TextEntryDialog):

   239

   240

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

   241

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

   242

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

   243

   244

                self.Tests = []

   245

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

   246

   247

            def OnOK(self, event):

   248

                value = self.GetValue()

   249

                texts = {"value": value}

   250

                for function, message in self.Tests:

   251

                    if not function(value):

   252

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

   253

                        message.ShowModal()

   254

                        message.Destroy()

   255

                        return

   256

                self.EndModal(wx.ID_OK)

   257

                event.Skip()

   258

   259

            def GetValue(self):

   260

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

   261

   262

            def SetTests(self, tests):

   263

                self.Tests = tests

   264

   265

        class BeremizTaskBarIcon(wx.adv.TaskBarIcon):

   266

            TBMENU_START = wx.NewIdRef()

   267

            TBMENU_STOP = wx.NewIdRef()

   268

            TBMENU_CHANGE_NAME = wx.NewIdRef()

   269

            TBMENU_CHANGE_PORT = wx.NewIdRef()

   270

            TBMENU_CHANGE_INTERFACE = wx.NewIdRef()

   271

            TBMENU_LIVE_SHELL = wx.NewIdRef()

   272

            TBMENU_WXINSPECTOR = wx.NewIdRef()

   273

            # TBMENU_CHANGE_WD = wx.NewIdRef()

   274

            TBMENU_QUIT = wx.NewIdRef()

   275

   276

            def __init__(self, rpc_server):

   277

                wx.adv.TaskBarIcon.__init__(self)

   278

                self.rpc_server = rpc_server

   279

                # Set the image

   280

                self.UpdateIcon(None)

   281

   282

                # bind some events

   283

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

   284

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

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

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

   292

   293

            def CreatePopupMenu(self):

   294

                """

   295

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

   296

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   297

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

   298

                the base class takes care of the rest.

   299

                """

   300

                menu = wx.Menu()

   301

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

   302

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

   303

                menu.AppendSeparator()

   304

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

   305

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

   306

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

   307

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

   308

                menu.AppendSeparator()

   309

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

   310

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

   311

                menu.AppendSeparator()

   312

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

   313

                return menu

   314

   315

            def MakeIcon(self, img):

   316

                """

   317

                The various platforms have different requirements for the

   318

                icon size...

   319

                """

   320

                if "wxMSW" in wx.PlatformInfo:

   321

                    img = img.Scale(16, 16)

   322

                elif "wxGTK" in wx.PlatformInfo:

   323

                    img = img.Scale(22, 22)

   324

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

   325

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

   326

                return icon

   327

   328

            def OnTaskBarStartPLC(self, evt):

   329

                runtime.GetPLCObjectSingleton().StartPLC()

   330

   331

            def OnTaskBarStopPLC(self, evt):

   332

                runtime.GetPLCObjectSingleton().StopPLC()

   333

   334

            def OnTaskBarChangeInterface(self, evt):

   335

                ip_addr = self.rpc_server.ip_addr

   336

                ip_addr = '' if ip_addr is None else ip_addr

   337

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

   338

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

   339

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

   340

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

   341

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

   342

                    self.rpc_server.ip_addr = dlg.GetValue()

   343

                    self.rpc_server.Restart()

   344

   345

            def OnTaskBarChangePort(self, evt):

   346

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

   347

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

   348

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

   349

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

   350

                    self.rpc_server.Restart()

   351

   352

            # def OnTaskBarChangeWorkingDir(self, evt):

   353

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

   354

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

   355

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

   356

            #         self.rpc_server.Restart()

   357

   358

            def OnTaskBarChangeName(self, evt):

   359

                _servicename = self.rpc_server.servicename

   360

                _servicename = '' if _servicename is None else _servicename

   361

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

   362

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

   363

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

   364

                    self.rpc_server.servicename = dlg.GetValue()

   365

                    self.rpc_server.Restart()

   366

   367

            def _LiveShellLocals(self):

   368

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

   369

   370

            def OnTaskBarLiveShell(self, evt):

   371

                from wx import py

   372

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

   373

                frame.Show()

   374

   375

            def OnTaskBarWXInspector(self, evt):

   376

                # Activate the widget inspection tool

   377

                from wx.lib.inspection import InspectionTool

   378

                if not InspectionTool().initialized:

   379

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

   380

   381

                wnd = wx.GetApp()

   382

                InspectionTool().Show(wnd, True)

   383

   384

            def OnTaskBarQuit(self, evt):

   385

                if wx.Platform == '__WXMSW__':

   386

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

   387

                self.RemoveIcon()

   388

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

   389

   390

            def UpdateIcon(self, plcstatus):

   391

                if plcstatus is PlcStatus.Started:

   392

                    currenticon = self.MakeIcon(starticon)

   393

                elif plcstatus is PlcStatus.Stopped:

   394

                    currenticon = self.MakeIcon(stopicon)

   395

                else:

   396

                    currenticon = self.MakeIcon(defaulticon)

   397

                self.SetIcon(currenticon, "Beremiz Service")

   398

   399

   400

if not os.path.isdir(WorkingDir):

   401

    os.mkdir(WorkingDir)

   402

   403

   404

if enabletwisted:

   405

    import warnings

   406

    with warnings.catch_warnings():

   407

        warnings.simplefilter("ignore")

   408

        try:

   409

            if havewx:

   410

                from twisted.internet import wxreactor

   411

                wxreactor.install()

   412

                from twisted.internet import reactor

   413

                reactor.registerWxApp(app)

   414

            else:

   415

                # from twisted.internet import pollreactor

   416

                # pollreactor.install()

   417

                from twisted.internet import reactor

   418

   419

            havetwisted = True

   420

        except ImportError:

   421

            print(_("Twisted unavailable."))

   422

            havetwisted = False

   423

   424

pyruntimevars = {}

   425

   426

if havewx:

   427

    wx_eval_lock = Semaphore(0)

   428

   429

    def statuschangeTskBar(status):

   430

        wx.CallAfter(taskbar_instance.UpdateIcon, status)

   431

   432

    statuschange.append(statuschangeTskBar)

   433

   434

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

   435

        tocall, args, kwargs = obj.call

   436

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

   437

        wx_eval_lock.release()

   438

   439

    main_thread_id = current_thread().ident

   440

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

   441

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

   442

        current_id = current_thread().ident

   443

   444

        if main_thread_id != current_id:

   445

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

   446

            wx.CallAfter(wx_evaluator, o)

   447

            wx_eval_lock.acquire()

   448

            return o.res

   449

        else:

   450

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

   451

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

   452

else:

   453

    evaluator = default_evaluator

   454

   455

# Exception hooks

   456

   457

   458

def LogException(*exp):

   459

    LogMessageAndException("", exp)

   460

   461

   462

sys.excepthook = LogException

   463

   464

   465

def installThreadExcepthook():

   466

    init_old = threading.Thread.__init__

   467

   468

    def init(self, *args, **kwargs):

   469

        init_old(self, *args, **kwargs)

   470

        run_old = self.run

   471

   472

        def run_with_except_hook(*args, **kw):

   473

            try:

   474

                run_old(*args, **kw)

   475

            except (KeyboardInterrupt, SystemExit):

   476

                raise

   477

            except Exception:

   478

                sys.excepthook(*sys.exc_info())

   479

        self.run = run_with_except_hook

   480

    threading.Thread.__init__ = init