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, currentThread

    35

import builtins

    36

from functools import partial

    37

    38

import runtime

    39

from runtime.PyroServer import PyroServer

    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

    global default_locale

   212

    default_locale = locale.getdefaultlocale()[1]

   213

   214

    # sys.stdout.encoding = default_locale

   215

    # if Beremiz_service is started from Beremiz IDE

   216

    # sys.stdout.encoding is None (that means 'ascii' encoding').

   217

    # And unicode string returned by wx.GetTranslation() are

   218

    # automatically converted to 'ascii' string.

   219

    def unicode_translation(message):

   220

        return wx.GetTranslation(message).encode(default_locale)

   221

   222

    builtins.__dict__['_'] = unicode_translation

   223

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

   224

   225

   226

# Life is hard... have a candy.

   227

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

   228

if enablewx:

   229

    try:

   230

        import wx

   231

        havewx = True

   232

    except ImportError:

   233

        print("Wx unavailable !")

   234

        havewx = False

   235

   236

    if havewx:

   237

        import re

   238

        import wx.adv

   239

   240

        if wx.VERSION >= (3, 0, 0):

   241

            app = wx.App(redirect=False)

   242

        else:

   243

            app = wx.PySimpleApp(redirect=False)

   244

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

   245

   246

        default_locale = None

   247

        SetupI18n()

   248

   249

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

   250

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

   251

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

   252

   253

        class ParamsEntryDialog(wx.TextEntryDialog):

   254

   255

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

   256

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

   257

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

   258

   259

                self.Tests = []

   260

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

   261

   262

            def OnOK(self, event):

   263

                value = self.GetValue()

   264

                texts = {"value": value}

   265

                for function, message in self.Tests:

   266

                    if not function(value):

   267

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

   268

                        message.ShowModal()

   269

                        message.Destroy()

   270

                        return

   271

                self.EndModal(wx.ID_OK)

   272

                event.Skip()

   273

   274

            def GetValue(self):

   275

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

   276

   277

            def SetTests(self, tests):

   278

                self.Tests = tests

   279

   280

        class BeremizTaskBarIcon(wx.adv.TaskBarIcon):

   290

   291

            def __init__(self, pyroserver):

   292

                wx.adv.TaskBarIcon.__init__(self)

   293

                self.pyroserver = pyroserver

   294

                # Set the image

   295

                self.UpdateIcon(None)

   296

   297

                # bind some events

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

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

   307

   308

            def CreatePopupMenu(self):

   309

                """

   310

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

   311

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   312

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

   313

                the base class takes care of the rest.

   314

                """

   315

                menu = wx.Menu()

   316

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

   317

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

   318

                menu.AppendSeparator()

   319

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

   320

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

   321

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

   322

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

   323

                menu.AppendSeparator()

   324

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

   325

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

   326

                menu.AppendSeparator()

   327

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

   328

                return menu

   329

   330

            def MakeIcon(self, img):

   331

                """

   332

                The various platforms have different requirements for the

   333

                icon size...

   334

                """

   335

                if "wxMSW" in wx.PlatformInfo:

   336

                    img = img.Scale(16, 16)

   337

                elif "wxGTK" in wx.PlatformInfo:

   338

                    img = img.Scale(22, 22)

   339

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

   340

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

   341

                return icon

   342

   343

            def OnTaskBarStartPLC(self, evt):

   344

                runtime.GetPLCObjectSingleton().StartPLC()

   345

   346

            def OnTaskBarStopPLC(self, evt):

   347

                runtime.GetPLCObjectSingleton().StopPLC()

   348

   349

            def OnTaskBarChangeInterface(self, evt):

   350

                ip_addr = self.pyroserver.ip_addr

   351

                ip_addr = '' if ip_addr is None else ip_addr

   352

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

   353

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

   354

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

   355

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

   356

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

   357

                    self.pyroserver.ip_addr = dlg.GetValue()

   358

                    self.pyroserver.Restart()

   359

   360

            def OnTaskBarChangePort(self, evt):

   361

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

   362

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

   363

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

   364

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

   365

                    self.pyroserver.Restart()

   366

   367

            def OnTaskBarChangeWorkingDir(self, evt):

   368

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

   369

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

   370

                    self.pyroserver.workdir = dlg.GetPath()

   371

                    self.pyroserver.Restart()

   372

   373

            def OnTaskBarChangeName(self, evt):

   374

                _servicename = self.pyroserver.servicename

   375

                _servicename = '' if _servicename is None else _servicename

   376

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

   377

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

   378

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

   379

                    self.pyroserver.servicename = dlg.GetValue()

   380

                    self.pyroserver.Restart()

   381

   382

            def _LiveShellLocals(self):

   383

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

   384

   385

            def OnTaskBarLiveShell(self, evt):

   386

                from wx import py

   387

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

   388

                frame.Show()

   389

   390

            def OnTaskBarWXInspector(self, evt):

   391

                # Activate the widget inspection tool

   392

                from wx.lib.inspection import InspectionTool

   393

                if not InspectionTool().initialized:

   394

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

   395

   396

                wnd = wx.GetApp()

   397

                InspectionTool().Show(wnd, True)

   398

   399

            def OnTaskBarQuit(self, evt):

   400

                if wx.Platform == '__WXMSW__':

   401

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

   402

                self.RemoveIcon()

   403

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

   404

   405

            def UpdateIcon(self, plcstatus):

   406

                if plcstatus is PlcStatus.Started:

   407

                    currenticon = self.MakeIcon(starticon)

   408

                elif plcstatus is PlcStatus.Stopped:

   409

                    currenticon = self.MakeIcon(stopicon)

   410

                else:

   411

                    currenticon = self.MakeIcon(defaulticon)

   412

                self.SetIcon(currenticon, "Beremiz Service")

   413

   414

   415

if not os.path.isdir(WorkingDir):

   416

    os.mkdir(WorkingDir)

   417

   418

   419

if enabletwisted:

   420

    import warnings

   421

    with warnings.catch_warnings():

   422

        warnings.simplefilter("ignore")

   423

        try:

   424

            if havewx:

   425

                from twisted.internet import wxreactor

   426

                wxreactor.install()

   427

                from twisted.internet import reactor

   428

                reactor.registerWxApp(app)

   429

            else:

   430

                # from twisted.internet import pollreactor

   431

                # pollreactor.install()

   432

                from twisted.internet import reactor

   433

   434

            havetwisted = True

   435

        except ImportError:

   436

            print(_("Twisted unavailable."))

   437

            havetwisted = False

   438

   439

pyruntimevars = {}

   440

   441

if havewx:

   442

    wx_eval_lock = Semaphore(0)

   443

   444

    def statuschangeTskBar(status):

   445

        wx.CallAfter(taskbar_instance.UpdateIcon, status)

   446

   447

    statuschange.append(statuschangeTskBar)

   448

   449

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

   450

        tocall, args, kwargs = obj.call

   451

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

   452

        wx_eval_lock.release()

   453

   454

    main_thread_id = currentThread().ident

   455

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

   456

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

   457

        current_id = currentThread().ident

   458

   459

        if main_thread_id != current_id:

   460

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

   461

            wx.CallAfter(wx_evaluator, o)

   462

            wx_eval_lock.acquire()

   463

            return o.res

   464

        else:

   465

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

   466

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

   467

else:

   468

    evaluator = default_evaluator

   469

   470

# Exception hooks

   471

   472

   473

def LogException(*exp):

   474

    LogMessageAndException("", exp)

   475

   476

   477

sys.excepthook = LogException

   478

   479

   480

def installThreadExcepthook():