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 import default_evaluator

    44

from runtime.Stunnel import ensurePSK

    45

import util.paths as paths

    46

    47

    48

def version():

    49

    from version import app_version

    50

    print("Beremiz_service: ", app_version)

    51

    52

    53

def usage():

    54

    version()

    55

    print("""

    56

Usage of Beremiz PLC execution service :\n

    57

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

    58

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

    59

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

    60

  -p  port number default:3000

    61

  -h  print this help text and quit

    62

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

    63

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

    64

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

    65

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

    66

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

    67

  -s  PSK secret path (default:PSK disabled)

    68

  -e  python extension (absolute path .py)

    69

    70

           working_dir - directory where are stored PLC files

    71

""" % sys.argv[0])

    72

    73

    74

try:

    75

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

    76

except getopt.GetoptError as err:

    77

    # print help information and exit:

    78

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

    79

    usage()

    80

    sys.exit(2)

    81

    82

# default values

    83

interface = ''

    84

port = 3000

    85

webport = 8009

    86

PSKpath = None

    87

wampconf = None

    88

servicename = None

    89

autostart = False

    90

enablewx = True

    91

havewx = False

    92

enabletwisted = True

    93

havetwisted = False

    94

    95

extensions = []

    96

    97

for o, a in opts:

    98

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

    99

        usage()

   100

        sys.exit()

   101

    if o == "--version":

   102

        version()

   103

        sys.exit()

   104

    elif o == "-i":

   105

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

   106

            interface = a

   107

        elif a == "localhost":

   108

            interface = '127.0.0.1'

   109

        else:

   110

            usage()

   111

            sys.exit()

   112

    elif o == "-p":

   113

        # port: port that the service runs on

   114

        port = int(a)

   115

    elif o == "-n":

   116

        servicename = a

   117

    elif o == "-x":

   118

        enablewx = int(a)

   119

    elif o == "-t":

   120

        enabletwisted = int(a)

   121

    elif o == "-a":

   122

        autostart = int(a)

   123

    elif o == "-w":

   124

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

   125

    elif o == "-c":

   126

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

   127

    elif o == "-s":

   128

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

   129

    elif o == "-e":

   130

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

   131

        fnameanddirname.reverse()

   132

        extensions.append(fnameanddirname)

   133

    else:

   134

        usage()

   135

        sys.exit()

   136

   137

   138

beremiz_dir = paths.AbsDir(__file__)

   139

   140

if len(argv) > 1:

   141

    usage()

   142

    sys.exit()

   143

elif len(argv) == 1:

   144

    WorkingDir = argv[0]

   145

    os.chdir(WorkingDir)

   146

elif len(argv) == 0:

   147

    WorkingDir = os.getcwd()

   148

    argv = [WorkingDir]

   149

   150

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

   151

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

   152

TryPreloadXenomai()

   153

version()

   154

   155

   156

def Bpath(*args):

   157

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

   158

   159

   160

def SetupI18n():

   161

    # Get folder containing translation files

   162

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

   163

    # Get the default language

   164

    langid = wx.LANGUAGE_DEFAULT

   165

    # Define translation domain (name of translation files)

   166

    domain = "Beremiz"

   167

   168

    # Define locale for wx

   169

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

   170

    if loc is None:

   171

        wx.LogGui.EnableLogging(False)

   172

        loc = wx.Locale(langid)

   173

        wx.LogGui.EnableLogging(True)

   174

        builtins.__dict__['loc'] = loc

   175

        # Define location for searching translation files

   176

    loc.AddCatalogLookupPathPrefix(localedir)

   177

    # Define locale domain

   178

    loc.AddCatalog(domain)

   179

   180

    import locale

   181

    global default_locale

   182

    default_locale = locale.getdefaultlocale()[1]

   183

   184

    # sys.stdout.encoding = default_locale

   185

    # if Beremiz_service is started from Beremiz IDE

   186

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

   187

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

   188

    # automatically converted to 'ascii' string.

   189

    def unicode_translation(message):

   190

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

   191

   192

    builtins.__dict__['_'] = unicode_translation

   193

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

   194

   195

   196

# Life is hard... have a candy.

   197

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

   198

if enablewx:

   199

    try:

   200

        import wx

   201

        havewx = True

   202

    except ImportError:

   203

        print("Wx unavailable !")

   204

        havewx = False

   205

   206

    if havewx:

   207

        import re

   208

   209

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

   210

            app = wx.App(redirect=False)

   211

        else:

   212

            app = wx.PySimpleApp(redirect=False)

   213

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

   214

   215

        default_locale = None

   216

        SetupI18n()

   217

   218

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

   219

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

   220

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

   221

   222

        class ParamsEntryDialog(wx.TextEntryDialog):

   223

   224

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

   225

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

   226

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

   227

   228

                self.Tests = []

   229

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

   230

   231

            def OnOK(self, event):

   232

                value = self.GetValue()

   233

                texts = {"value": value}

   234

                for function, message in self.Tests:

   235

                    if not function(value):

   236

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

   237

                        message.ShowModal()

   238

                        message.Destroy()

   239

                        return

   240

                self.EndModal(wx.ID_OK)

   241

                event.Skip()

   242

   243

            def GetValue(self):

   244

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

   245

   246

            def SetTests(self, tests):

   247

                self.Tests = tests

   248

   249

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   250

            TBMENU_START = wx.NewId()

   251

            TBMENU_STOP = wx.NewId()

   252

            TBMENU_CHANGE_NAME = wx.NewId()

   253

            TBMENU_CHANGE_PORT = wx.NewId()

   254

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   255

            TBMENU_LIVE_SHELL = wx.NewId()

   256

            TBMENU_WXINSPECTOR = wx.NewId()

   257

            TBMENU_CHANGE_WD = wx.NewId()

   258

            TBMENU_QUIT = wx.NewId()

   259

   260

            def __init__(self, pyroserver):

   261

                wx.TaskBarIcon.__init__(self)

   262

                self.pyroserver = pyroserver

   263

                # Set the image

   264

                self.UpdateIcon(None)

   265

   266

                # bind some events

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

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

   276

   277

            def CreatePopupMenu(self):

   278

                """

   279

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

   280

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   281

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

   282

                the base class takes care of the rest.

   283

                """

   284

                menu = wx.Menu()

   285

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

   286

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

   287

                menu.AppendSeparator()

   288

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

   289

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

   290

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

   291

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

   292

                menu.AppendSeparator()

   293

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

   294

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

   295

                menu.AppendSeparator()

   296

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

   297

                return menu

   298

   299

            def MakeIcon(self, img):

   300

                """

   301

                The various platforms have different requirements for the

   302

                icon size...

   303

                """

   304

                if "wxMSW" in wx.PlatformInfo:

   305

                    img = img.Scale(16, 16)

   306

                elif "wxGTK" in wx.PlatformInfo:

   307

                    img = img.Scale(22, 22)

   308

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

   309

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

   310

                return icon

   311

   312

            def OnTaskBarStartPLC(self, evt):

   313

                runtime.GetPLCObjectSingleton().StartPLC()

   314

   315

            def OnTaskBarStopPLC(self, evt):

   316

                runtime.GetPLCObjectSingleton().StopPLC()

   317

   318

            def OnTaskBarChangeInterface(self, evt):

   319

                ip_addr = self.pyroserver.ip_addr

   320

                ip_addr = '' if ip_addr is None else ip_addr

   321

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

   322

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

   323

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

   324

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

   325

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

   326

                    self.pyroserver.ip_addr = dlg.GetValue()

   327

                    self.pyroserver.Restart()

   328

   329

            def OnTaskBarChangePort(self, evt):

   330

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

   331

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

   332

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

   333

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

   334

                    self.pyroserver.Restart()

   335

   336

            def OnTaskBarChangeWorkingDir(self, evt):

   337

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

   338

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

   339

                    self.pyroserver.workdir = dlg.GetPath()

   340

                    self.pyroserver.Restart()

   341

   342

            def OnTaskBarChangeName(self, evt):

   343

                _servicename = self.pyroserver.servicename

   344

                _servicename = '' if _servicename is None else _servicename

   345

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

   346

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

   347

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

   348

                    self.pyroserver.servicename = dlg.GetValue()

   349

                    self.pyroserver.Restart()

   350

   351

            def _LiveShellLocals(self):

   352

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

   353

   354

            def OnTaskBarLiveShell(self, evt):

   355

                from wx import py

   356

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

   357

                frame.Show()

   358

   359

            def OnTaskBarWXInspector(self, evt):

   360

                # Activate the widget inspection tool

   361

                from wx.lib.inspection import InspectionTool

   362

                if not InspectionTool().initialized:

   363

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

   364

   365

                wnd = wx.GetApp()

   366

                InspectionTool().Show(wnd, True)

   367

   368

            def OnTaskBarQuit(self, evt):

   369

                if wx.Platform == '__WXMSW__':

   370

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

   371

                self.RemoveIcon()

   372

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

   373

   374

            def UpdateIcon(self, plcstatus):

   375

                if plcstatus is PlcStatus.Started:

   376

                    currenticon = self.MakeIcon(starticon)

   377

                elif plcstatus is PlcStatus.Stopped:

   378

                    currenticon = self.MakeIcon(stopicon)

   379

                else:

   380

                    currenticon = self.MakeIcon(defaulticon)

   381

                self.SetIcon(currenticon, "Beremiz Service")

   382

   383

   384

if not os.path.isdir(WorkingDir):

   385

    os.mkdir(WorkingDir)

   386

   387

   388

if enabletwisted:

   389

    import warnings

   390

    with warnings.catch_warnings():

   391

        warnings.simplefilter("ignore")

   392

        try:

   393

            if havewx:

   394

                from twisted.internet import wxreactor

   395

                wxreactor.install()

   396

            from twisted.internet import reactor

   397

   398

            havetwisted = True

   399

        except ImportError:

   400

            print(_("Twisted unavailable."))

   401

            havetwisted = False

   402

   403

pyruntimevars = {}

   404

statuschange = []

   405

   406

if havetwisted:

   407

    if havewx:

   408

        reactor.registerWxApp(app)

   409

   410

twisted_reactor_thread_id = None

   411

ui_thread = None

   412

   413

if havewx:

   414

    wx_eval_lock = Semaphore(0)

   415

   416

    def statuschangeTskBar(status):

   417

        wx.CallAfter(taskbar_instance.UpdateIcon, status)

   418

   419

    statuschange.append(statuschangeTskBar)

   420

   421

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

   422

        tocall, args, kwargs = obj.call

   423

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

   424

        wx_eval_lock.release()

   425

   426

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

   427

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

   428

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

   429

        # worker thread from twisted "threadselect" reactor

   430

        current_id = currentThread().ident

   431

   432

        if ui_thread is not None \

   433

            and ui_thread.ident != current_id \

   434

            and (not havetwisted or (

   435

                    twisted_reactor_thread_id is not None

   436

                    and twisted_reactor_thread_id != current_id)):

   437

   438

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

   439

            wx.CallAfter(wx_evaluator, o)

   440

            wx_eval_lock.acquire()

   441

            return o.res

   442

        else:

   443

            # avoid dead lock if called from the wx mainloop

   444

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

   445

else:

   446

    evaluator = default_evaluator

   447

   448

# Exception hooks

   449

   450

   451

def LogException(*exp):

   452

    LogMessageAndException("", exp)

   453

   454

   455

sys.excepthook = LogException

   456

   457

   458

def installThreadExcepthook():

   459

    init_old = threading.Thread.__init__

   460

   461

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

   462

        init_old(self, *args, **kwargs)

   463

        run_old = self.run

   464

   465

        def run_with_except_hook(*args, **kw):

   466

            try:

   467

                run_old(*args, **kw)

   468

            except (KeyboardInterrupt, SystemExit):

   469

                raise

   470

            except Exception:

   471

                sys.excepthook(*sys.exc_info())

   472

        self.run = run_with_except_hook

   473

    threading.Thread.__init__ = init

   474

   475

   476

installThreadExcepthook()

   477

havewamp = False

   478

haveBNconf = False

   479

haveMBconf = False

   480