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

from __future__ import absolute_import

    28

from __future__ import print_function

    29

import os

    30

import sys

    31

import getopt

    32

import threading

    33

import shlex

    34

import traceback

    35

import threading

    36

from threading import Thread, Semaphore, Lock, currentThread

    37

from builtins import str as text

    38

from past.builtins import execfile

    39

from six.moves import builtins

    40

from functools import partial

    41

    42

import runtime

    43

from runtime.PyroServer import PyroServer

    44

from runtime.xenomai import TryPreloadXenomai

    45

from runtime import LogMessageAndException

    46

from runtime import PlcStatus

    47

from runtime import default_evaluator

    48

from runtime.Stunnel import ensurePSK

    49

import util.paths as paths

    50

    51

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

    52

# monotonic timers for timers and other timeout based operations.

    53

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

    54

# Thread/Timer/Event/Condition

    55

    56

from runtime.monotonic_time import monotonic

    57

threading._time = monotonic

    58

    59

try:

    60

    from runtime.spawn_subprocess import Popen

    61

except ImportError:

    62

    from subprocess import Popen

    63

    64

def version():

    65

    from version import app_version

    66

    print("Beremiz_service: ", app_version)

    67

    68

    69

def usage():

    70

    version()

    71

    print("""

    72

Usage of Beremiz PLC execution service :\n

    73

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

    74

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

    75

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

    76

  -p  port number default:3000

    77

  -h  print this help text and quit

    78

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

    79

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

    80

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

    81

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

    82

  -c  WAMP client config file (can be overriden by wampconf.json in project)

    83

  -s  PSK secret path (default:PSK disabled)

    84

  -e  python extension (absolute path .py)

    85

    86

           working_dir - directory where are stored PLC files

    87

""" % sys.argv[0])

    88

    89

    90

try:

    91

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

    92

except getopt.GetoptError as err:

    93

    # print help information and exit:

    94

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

    95

    usage()

    96

    sys.exit(2)

    97

    98

# default values

    99

interface = ''

   100

port = 3000

   101

webport = 8009

   102

PSKpath = None

   103

wampconf = None

   104

servicename = None

   105

autostart = False

   106

enablewx = True

   107

havewx = False

   108

enabletwisted = True

   109

havetwisted = False

   110

   111

extensions = []

   112

statuschange = []

   113

def status_change_call_factory(wanted, args):

   114

    def status_change_call(status):

   115

        if wanted is None or status is wanted:

   116

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

   117

            Popen(cmd)

   118

    return status_change_call

   119

   120

for o, a in opts:

   121

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

   122

        usage()

   123

        sys.exit()

   124

    if o == "--version":

   125

        version()

   126

        sys.exit()

   127

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

   128

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

   129

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

   130

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

   131

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

   132

        statuschange.append(status_change_call_factory(None, a))

   133

    elif o == "-i":

   134

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

   135

            interface = a

   136

        elif a == "localhost":

   137

            interface = '127.0.0.1'

   138

        else:

   139

            usage()

   140

            sys.exit()

   141

    elif o == "-p":

   142

        # port: port that the service runs on

   143

        port = int(a)

   144

    elif o == "-n":

   145

        servicename = a

   146

    elif o == "-x":

   147

        enablewx = int(a)

   148

    elif o == "-t":

   149

        enabletwisted = int(a)

   150

    elif o == "-a":

   151

        autostart = int(a)

   152

    elif o == "-w":

   153

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

   154

    elif o == "-c":

   155

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

   156

    elif o == "-s":

   157

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

   158

    elif o == "-e":

   159

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

   160

        fnameanddirname.reverse()

   161

        extensions.append(fnameanddirname)

   162

    else:

   163

        usage()

   164

        sys.exit()

   165

   166

   167

beremiz_dir = paths.AbsDir(__file__)

   168

   169

if len(argv) > 1:

   170

    usage()

   171

    sys.exit()

   172

elif len(argv) == 1:

   173

    WorkingDir = argv[0]

   174

    os.chdir(WorkingDir)

   175

elif len(argv) == 0:

   176

    WorkingDir = os.getcwd()

   177

    argv = [WorkingDir]

   178

   179

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

   180

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

   181

TryPreloadXenomai()

   182

version()

   183

   184

   185

def Bpath(*args):

   186

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

   187

   188

   189

def SetupI18n():

   190

    # Get folder containing translation files

   191

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

   192

    # Get the default language

   193

    langid = wx.LANGUAGE_DEFAULT

   194

    # Define translation domain (name of translation files)

   195

    domain = "Beremiz"

   196

   197

    # Define locale for wx

   198

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

   199

    if loc is None:

   200

        wx.LogGui.EnableLogging(False)

   201

        loc = wx.Locale(langid)

   202

        wx.LogGui.EnableLogging(True)

   203

        builtins.__dict__['loc'] = loc

   204

        # Define location for searching translation files

   205

    loc.AddCatalogLookupPathPrefix(localedir)

   206

    # Define locale domain

   207

    loc.AddCatalog(domain)

   208

   209

    import locale

   210

    global default_locale

   211

    default_locale = locale.getdefaultlocale()[1]

   212

   213

    # sys.stdout.encoding = default_locale

   214

    # if Beremiz_service is started from Beremiz IDE

   215

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

   216

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

   217

    # automatically converted to 'ascii' string.

   218

    def unicode_translation(message):

   219

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

   220

   221

    builtins.__dict__['_'] = unicode_translation

   222

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

   223

   224

   225

# Life is hard... have a candy.

   226

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

   227

if enablewx:

   228

    try:

   229

        import wx

   230

        havewx = True

   231

    except ImportError:

   232

        print("Wx unavailable !")

   233

        havewx = False

   234

   235

    if havewx:

   236

        import re

   237

        import wx.adv

   238

   239

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

   240

            app = wx.App(redirect=False)

   241

        else:

   242

            app = wx.PySimpleApp(redirect=False)

   243

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

   244

   245

        default_locale = None

   246

        SetupI18n()

   247

   248

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

   249

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

   250

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

   251

   252

        class ParamsEntryDialog(wx.TextEntryDialog):

   253

   254

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

   255

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

   256

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

   257

   258

                self.Tests = []

   259

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

   260

   261

            def OnOK(self, event):

   262

                value = self.GetValue()

   263

                texts = {"value": value}

   264

                for function, message in self.Tests:

   265

                    if not function(value):

   266

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

   267

                        message.ShowModal()

   268

                        message.Destroy()

   269

                        return

   270

                self.EndModal(wx.ID_OK)

   271

                event.Skip()

   272

   273

            def GetValue(self):

   274

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

   275

   276

            def SetTests(self, tests):

   277

                self.Tests = tests

   278

   279

        class BeremizTaskBarIcon(wx.adv.TaskBarIcon):

   280

            TBMENU_START = wx.NewId()

   281

            TBMENU_STOP = wx.NewId()

   282

            TBMENU_CHANGE_NAME = wx.NewId()

   283

            TBMENU_CHANGE_PORT = wx.NewId()

   284

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   285

            TBMENU_LIVE_SHELL = wx.NewId()

   286

            TBMENU_WXINSPECTOR = wx.NewId()

   287

            TBMENU_CHANGE_WD = wx.NewId()

   288

            TBMENU_QUIT = wx.NewId()

   289

   290

            def __init__(self, pyroserver):

   291

                wx.adv.TaskBarIcon.__init__(self)

   292

                self.pyroserver = pyroserver

   293

                # Set the image

   294

                self.UpdateIcon(None)

   295

   296

                # bind some events

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

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

   306

   307

            def CreatePopupMenu(self):

   308

                """

   309

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

   310

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   311

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

   312

                the base class takes care of the rest.

   313

                """

   314

                menu = wx.Menu()

   315

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

   316

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

   317

                menu.AppendSeparator()

   318

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

   319

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

   320

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

   321

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

   322

                menu.AppendSeparator()

   323

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

   324

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

   325

                menu.AppendSeparator()

   326

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

   327

                return menu

   328

   329

            def MakeIcon(self, img):

   330

                """

   331

                The various platforms have different requirements for the

   332

                icon size...

   333

                """

   334

                if "wxMSW" in wx.PlatformInfo:

   335

                    img = img.Scale(16, 16)

   336

                elif "wxGTK" in wx.PlatformInfo:

   337

                    img = img.Scale(22, 22)

   338

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

   339

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

   340

                return icon

   341

   342

            def OnTaskBarStartPLC(self, evt):

   343

                runtime.GetPLCObjectSingleton().StartPLC()

   344

   345

            def OnTaskBarStopPLC(self, evt):

   346

                runtime.GetPLCObjectSingleton().StopPLC()

   347

   348

            def OnTaskBarChangeInterface(self, evt):

   349

                ip_addr = self.pyroserver.ip_addr

   350

                ip_addr = '' if ip_addr is None else ip_addr

   351

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

   352

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

   353

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

   354

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

   355

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

   356

                    self.pyroserver.ip_addr = dlg.GetValue()

   357

                    self.pyroserver.Restart()

   358

   359

            def OnTaskBarChangePort(self, evt):

   360

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

   361

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

   362

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

   363

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

   364

                    self.pyroserver.Restart()

   365

   366

            def OnTaskBarChangeWorkingDir(self, evt):

   367

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

   368

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

   369

                    self.pyroserver.workdir = dlg.GetPath()

   370

                    self.pyroserver.Restart()

   371

   372

            def OnTaskBarChangeName(self, evt):

   373

                _servicename = self.pyroserver.servicename

   374

                _servicename = '' if _servicename is None else _servicename

   375

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

   376

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

   377

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

   378

                    self.pyroserver.servicename = dlg.GetValue()

   379

                    self.pyroserver.Restart()

   380

   381

            def _LiveShellLocals(self):

   382

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

   383

   384

            def OnTaskBarLiveShell(self, evt):

   385

                from wx import py

   386

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

   387

                frame.Show()

   388

   389

            def OnTaskBarWXInspector(self, evt):

   390

                # Activate the widget inspection tool

   391

                from wx.lib.inspection import InspectionTool

   392

                if not InspectionTool().initialized:

   393

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

   394

   395

                wnd = wx.GetApp()

   396

                InspectionTool().Show(wnd, True)

   397

   398

            def OnTaskBarQuit(self, evt):

   399

                if wx.Platform == '__WXMSW__':

   400

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

   401

                self.RemoveIcon()

   402

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

   403

   404

            def UpdateIcon(self, plcstatus):

   405

                if plcstatus is PlcStatus.Started:

   406

                    currenticon = self.MakeIcon(starticon)

   407

                elif plcstatus is PlcStatus.Stopped:

   408

                    currenticon = self.MakeIcon(stopicon)

   409

                else:

   410

                    currenticon = self.MakeIcon(defaulticon)

   411

                self.SetIcon(currenticon, "Beremiz Service")

   412

   413

   414

if not os.path.isdir(WorkingDir):

   415

    os.mkdir(WorkingDir)

   416

   417

   418

if enabletwisted:

   419

    import warnings

   420

    with warnings.catch_warnings():

   421

        warnings.simplefilter("ignore")

   422

        try:

   423

            if havewx:

   424

                from twisted.internet import wxreactor

   425

                wxreactor.install()

   426

                from twisted.internet import reactor

   427

                reactor.registerWxApp(app)

   428

            else:

   429

                # from twisted.internet import pollreactor

   430

                # pollreactor.install()

   431

                from twisted.internet import reactor

   432

   433

            havetwisted = True

   434

        except ImportError:

   435

            print(_("Twisted unavailable."))

   436

            havetwisted = False

   437

   438

pyruntimevars = {}

   439

   440

if havewx:

   441

    wx_eval_lock = Semaphore(0)

   442

   443

    def statuschangeTskBar(status):

   444

        wx.CallAfter(taskbar_instance.UpdateIcon, status)

   445

   446

    statuschange.append(statuschangeTskBar)

   447

   448

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

   449

        tocall, args, kwargs = obj.call

   450

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

   451

        wx_eval_lock.release()

   452

   453

    main_thread_id = currentThread().ident

   454

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

   455

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

   456

        current_id = currentThread().ident

   457

   458

        if main_thread_id != current_id:

   459

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

   460

            wx.CallAfter(wx_evaluator, o)

   461

            wx_eval_lock.acquire()

   462

            return o.res

   463

        else:

   464

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

   465

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

   466

else:

   467

    evaluator = default_evaluator

   468

   469

# Exception hooks

   470

   471

   472

def LogException(*exp):

   473

    LogMessageAndException("", exp)

   474

   475

   476

sys.excepthook = LogException

   477

   478

   479

def installThreadExcepthook():

   480

    init_old = threading.Thread.__init__