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

from threading import Thread, Semaphore, Lock, currentThread

    34

from builtins import str as text

    35

from past.builtins import execfile

    36

from six.moves import builtins

    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.Stunnel import ensurePSK

    44

import util.paths as paths

    45

    46

    47

def version():

    48

    from version import app_version

    49

    print("Beremiz_service: ", app_version)

    50

    51

    52

def usage():

    53

    version()

    54

    print("""

    55

Usage of Beremiz PLC execution service :\n

    56

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

    57

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

    58

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

    59

  -p  port number default:3000

    60

  -h  print this help text and quit

    61

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

    62

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

    63

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

    64

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

    65

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

    66

  -s  PSK secret path (default:PSK disabled)

    67

  -e  python extension (absolute path .py)

    68

    69

           working_dir - directory where are stored PLC files

    70

""" % sys.argv[0])

    71

    72

    73

try:

    74

    opts, argv = getopt.getopt(sys.argv[1:], "i:p:n:x:t:a:w:c:e:s:h", ["help", "version"])

    75

except getopt.GetoptError as err:

    76

    # print help information and exit:

    77

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

    78

    usage()

    79

    sys.exit(2)

    80

    81

# default values

    82

interface = ''

    83

port = 3000

    84

webport = 8009

    85

PSKpath = None

    86

wampconf = None

    87

servicename = None

    88

autostart = False

    89

enablewx = True

    90

havewx = False

    91

enabletwisted = True

    92

havetwisted = False

    93

    94

extensions = []

    95

    96

for o, a in opts:

    97

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

    98

        usage()

    99

        sys.exit()

   100

    if o == "--version":

   101

        version()

   102

        sys.exit()

   103

    elif o == "-i":

   104

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

   105

            interface = a

   106

        elif a == "localhost":

   107

            interface = '127.0.0.1'

   108

        else:

   109

            usage()

   110

            sys.exit()

   111

    elif o == "-p":

   112

        # port: port that the service runs on

   113

        port = int(a)

   114

    elif o == "-n":

   115

        servicename = a

   116

    elif o == "-x":

   117

        enablewx = int(a)

   118

    elif o == "-t":

   119

        enabletwisted = int(a)

   120

    elif o == "-a":

   121

        autostart = int(a)

   122

    elif o == "-w":

   123

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

   124

    elif o == "-c":

   125

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

   126

    elif o == "-s":

   127

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

   128

    elif o == "-e":

   129

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

   130

        fnameanddirname.reverse()

   131

        extensions.append(fnameanddirname)

   132

    else:

   133

        usage()

   134

        sys.exit()

   135

   136

   137

beremiz_dir = paths.AbsDir(__file__)

   138

   139

if len(argv) > 1:

   140

    usage()

   141

    sys.exit()

   142

elif len(argv) == 1:

   143

    WorkingDir = argv[0]

   144

    os.chdir(WorkingDir)

   145

elif len(argv) == 0:

   146

    WorkingDir = os.getcwd()

   147

    argv = [WorkingDir]

   148

   149

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

   150

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

   151

TryPreloadXenomai()

   152

version()

   153

   154

   155

def Bpath(*args):

   156

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

   157

   158

   159

def SetupI18n():

   160

    # Get folder containing translation files

   161

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

   162

    # Get the default language

   163

    langid = wx.LANGUAGE_DEFAULT

   164

    # Define translation domain (name of translation files)

   165

    domain = "Beremiz"

   166

   167

    # Define locale for wx

   168

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

   169

    if loc is None:

   170

        wx.LogGui.EnableLogging(False)

   171

        loc = wx.Locale(langid)

   172

        wx.LogGui.EnableLogging(True)

   173

        builtins.__dict__['loc'] = loc

   174

        # Define location for searching translation files

   175

    loc.AddCatalogLookupPathPrefix(localedir)

   176

    # Define locale domain

   177

    loc.AddCatalog(domain)

   178

   179

    import locale

   180

    global default_locale

   181

    default_locale = locale.getdefaultlocale()[1]

   182

   183

    # sys.stdout.encoding = default_locale

   184

    # if Beremiz_service is started from Beremiz IDE

   185

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

   186

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

   187

    # automatically converted to 'ascii' string.

   188

    def unicode_translation(message):

   189

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

   190

   191

    builtins.__dict__['_'] = unicode_translation

   192

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

   193

   194

   195

# Life is hard... have a candy.

   196

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

   197

if enablewx:

   198

    try:

   199

        import wx

   200

        havewx = True

   201

    except ImportError:

   202

        print("Wx unavailable !")

   203

        havewx = False

   204

   205

    if havewx:

   206

        import re

   207

   208

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

   209

            app = wx.App(redirect=False)

   210

        else:

   211

            app = wx.PySimpleApp(redirect=False)

   212

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

   213

   214

        default_locale = None

   215

        SetupI18n()

   216

   217

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

   218

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

   219

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

   220

   221

        class ParamsEntryDialog(wx.TextEntryDialog):

   222

   223

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

   224

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

   225

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

   226

   227

                self.Tests = []

   228

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

   229

   230

            def OnOK(self, event):

   231

                value = self.GetValue()

   232

                texts = {"value": value}

   233

                for function, message in self.Tests:

   234

                    if not function(value):

   235

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

   236

                        message.ShowModal()

   237

                        message.Destroy()

   238

                        return

   239

                self.EndModal(wx.ID_OK)

   240

                event.Skip()

   241

   242

            def GetValue(self):

   243

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

   244

   245

            def SetTests(self, tests):

   246

                self.Tests = tests

   247

   248

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   249

            TBMENU_START = wx.NewId()

   250

            TBMENU_STOP = wx.NewId()

   251

            TBMENU_CHANGE_NAME = wx.NewId()

   252

            TBMENU_CHANGE_PORT = wx.NewId()

   253

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   254

            TBMENU_LIVE_SHELL = wx.NewId()

   255

            TBMENU_WXINSPECTOR = wx.NewId()

   256

            TBMENU_CHANGE_WD = wx.NewId()

   257

            TBMENU_QUIT = wx.NewId()

   258

   259

            def __init__(self, pyroserver):

   260

                wx.TaskBarIcon.__init__(self)

   261

                self.pyroserver = pyroserver

   262

                # Set the image

   263

                self.UpdateIcon(None)

   264

   265

                # bind some events

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

   276

            def CreatePopupMenu(self):

   277

                """

   278

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

   279

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   280

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

   281

                the base class takes care of the rest.

   282

                """

   283

                menu = wx.Menu()

   284

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

   285

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

   286

                menu.AppendSeparator()

   287

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

   288

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

   289

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

   290

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

   291

                menu.AppendSeparator()

   292

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

   293

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

   294

                menu.AppendSeparator()

   295

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

   296

                return menu

   297

   298

            def MakeIcon(self, img):

   299

                """

   300

                The various platforms have different requirements for the

   301

                icon size...

   302

                """

   303

                if "wxMSW" in wx.PlatformInfo:

   304

                    img = img.Scale(16, 16)

   305

                elif "wxGTK" in wx.PlatformInfo:

   306

                    img = img.Scale(22, 22)

   307

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

   308

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

   309

                return icon

   310

   311

            def OnTaskBarStartPLC(self, evt):

   312

                runtime.GetPLCObjectSingleton().StartPLC()

   313

   314

            def OnTaskBarStopPLC(self, evt):

   315

                runtime.GetPLCObjectSingleton().StopPLC()

   316

   317

            def OnTaskBarChangeInterface(self, evt):

   318

                ip_addr = self.pyroserver.ip_addr

   319

                ip_addr = '' if ip_addr is None else ip_addr

   320

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

   321

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

   322

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

   323

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

   324

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

   325

                    self.pyroserver.ip_addr = dlg.GetValue()

   326

                    self.pyroserver.Restart()

   327

   328

            def OnTaskBarChangePort(self, evt):

   329

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

   330

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

   331

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

   332

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

   333

                    self.pyroserver.Restart()

   334

   335

            def OnTaskBarChangeWorkingDir(self, evt):

   336

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

   337

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

   338

                    self.pyroserver.workdir = dlg.GetPath()

   339

                    self.pyroserver.Restart()

   340

   341

            def OnTaskBarChangeName(self, evt):

   342

                _servicename = self.pyroserver.servicename

   343

                _servicename = '' if _servicename is None else _servicename

   344

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

   345

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

   346

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

   347

                    self.pyroserver.servicename = dlg.GetValue()

   348

                    self.pyroserver.Restart()

   349

   350

            def _LiveShellLocals(self):

   351

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

   352

   353

            def OnTaskBarLiveShell(self, evt):

   354

                from wx import py

   355

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

   356

                frame.Show()

   357

   358

            def OnTaskBarWXInspector(self, evt):

   359

                # Activate the widget inspection tool

   360

                from wx.lib.inspection import InspectionTool

   361

                if not InspectionTool().initialized:

   362

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

   363

   364

                wnd = wx.GetApp()

   365

                InspectionTool().Show(wnd, True)

   366

   367

            def OnTaskBarQuit(self, evt):

   368

                if wx.Platform == '__WXMSW__':

   369

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

   370

                self.RemoveIcon()

   371

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

   372

   373

            def UpdateIcon(self, plcstatus):

   374

                if plcstatus is PlcStatus.Started:

   375

                    currenticon = self.MakeIcon(starticon)

   376

                elif plcstatus is PlcStatus.Stopped:

   377

                    currenticon = self.MakeIcon(stopicon)

   378

                else:

   379

                    currenticon = self.MakeIcon(defaulticon)

   380

                self.SetIcon(currenticon, "Beremiz Service")

   381

   382

   383

if not os.path.isdir(WorkingDir):

   384

    os.mkdir(WorkingDir)

   385

   386

   387

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

   388

    try:

   389

        res = (tocall(*args, **kwargs), None)

   390

    except Exception:

   391

        res = (None, sys.exc_info())

   392

    return res

   393

   394

   395

if enabletwisted:

   396

    import warnings

   397

    with warnings.catch_warnings():

   398

        warnings.simplefilter("ignore")

   399

        try:

   400

            if havewx:

   401

                from twisted.internet import wxreactor

   402

                wxreactor.install()

   403

            from twisted.internet import reactor

   404

   405

            havetwisted = True

   406

        except ImportError:

   407

            print(_("Twisted unavailable."))

   408

            havetwisted = False

   409

   410

pyruntimevars = {}

   411

statuschange = []

   412

   413

if havetwisted:

   414

    if havewx:

   415

        reactor.registerWxApp(app)

   416

   417

twisted_reactor_thread_id = None

   418

ui_thread = None

   419

   420

if havewx:

   421

    wx_eval_lock = Semaphore(0)

   422

   423

    def statuschangeTskBar(status):

   424

        wx.CallAfter(taskbar_instance.UpdateIcon, status)

   425

   426

    statuschange.append(statuschangeTskBar)

   427

   428

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

   429

        tocall, args, kwargs = obj.call

   430

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

   431

        wx_eval_lock.release()

   432

   433

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

   434

        # To prevent deadlocks, check if current thread is not one of the UI

   435

        # UI threads can be either the one from WX main loop or

   436

        # worker thread from twisted "threadselect" reactor

   437

        current_id = currentThread().ident

   438

   439

        if ui_thread is not None \

   440

            and ui_thread.ident != current_id \

   441

            and (not havetwisted or (

   442

                    twisted_reactor_thread_id is not None

   443

                    and twisted_reactor_thread_id != current_id)):

   444

   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 the wx mainloop

   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