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

    41

import runtime

    42

from runtime.PyroServer import PyroServer

    43

from runtime.xenomai import TryPreloadXenomai

    44

from runtime import LogMessageAndException

    45

from runtime import PlcStatus

    46

from runtime import default_evaluator

    47

from runtime.Stunnel import ensurePSK

    48

import util.paths as paths

    49

    50

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

    51

# monotonic timers for timers and other timeout based operations.

    52

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

    53

# Thread/Timer/Event/Condition

    54

    55

from runtime.monotonic_time import monotonic

    56

threading._time = monotonic

    57

    58

try:

    59

    from runtime.spawn_subprocess import Popen

    60

except ImportError:

    61

    from subprocess import Popen

    62

    63

def version():

    64

    from version import app_version

    65

    print("Beremiz_service: ", app_version)

    66

    67

    68

def usage():

    69

    version()

    70

    print("""

    71

Usage of Beremiz PLC execution service :\n

    72

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

    73

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

    74

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

    75

  -p  port number default:3000

    76

  -h  print this help text and quit

    77

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

    78

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

    79

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

    80

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

    81

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

    82

  -s  PSK secret path (default:PSK disabled)

    83

  -e  python extension (absolute path .py)

    84

    85

           working_dir - directory where are stored PLC files

    86

""" % sys.argv[0])

    87

    88

    89

try:

    90

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

    91

except getopt.GetoptError as err:

    92

    # print help information and exit:

    93

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

    94

    usage()

    95

    sys.exit(2)

    96

    97

# default values

    98

interface = ''

    99

port = 3000

   100

webport = 8009

   101

PSKpath = None

   102

wampconf = None

   103

servicename = None

   104

autostart = False

   105

enablewx = True

   106

havewx = False

   107

enabletwisted = True

   108

havetwisted = False

   109

   110

extensions = []

   111

statuschange = []

   112

def status_change_call_factory(wanted, args):

   113

    def status_change_call(status):

   114

        if wanted is None or status is wanted:

   115

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

   116

            Popen(cmd)

   117

    return status_change_call

   118

   119

for o, a in opts:

   120

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

   121

        usage()

   122

        sys.exit()

   123

    if o == "--version":

   124

        version()

   125

        sys.exit()

   126

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

   127

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

   128

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

   129

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

   130

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

   131

        statuschange.append(status_change_call_factory(None, a))

   132

    elif o == "-i":

   133

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

   134

            interface = a

   135

        elif a == "localhost":

   136

            interface = '127.0.0.1'

   137

        else:

   138

            usage()

   139

            sys.exit()

   140

    elif o == "-p":

   141

        # port: port that the service runs on

   142

        port = int(a)

   143

    elif o == "-n":

   144

        servicename = a

   145

    elif o == "-x":

   146

        enablewx = int(a)

   147

    elif o == "-t":

   148

        enabletwisted = int(a)

   149

    elif o == "-a":

   150

        autostart = int(a)

   151

    elif o == "-w":

   152

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

   153

    elif o == "-c":

   154

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

   155

    elif o == "-s":

   156

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

   157

    elif o == "-e":

   158

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

   159

        fnameanddirname.reverse()

   160

        extensions.append(fnameanddirname)

   161

    else:

   162

        usage()

   163

        sys.exit()

   164

   165

   166

beremiz_dir = paths.AbsDir(__file__)

   167

   168

if len(argv) > 1:

   169

    usage()

   170

    sys.exit()

   171

elif len(argv) == 1:

   172

    WorkingDir = argv[0]

   173

    os.chdir(WorkingDir)

   174

elif len(argv) == 0:

   175

    WorkingDir = os.getcwd()

   176

    argv = [WorkingDir]

   177

   178

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

   179

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

   180

TryPreloadXenomai()

   181

version()

   182

   183

   184

def Bpath(*args):

   185

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

   186

   187

   188

def SetupI18n():

   189

    # Get folder containing translation files

   190

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

   191

    # Get the default language

   192

    langid = wx.LANGUAGE_DEFAULT

   193

    # Define translation domain (name of translation files)

   194

    domain = "Beremiz"

   195

   196

    # Define locale for wx

   197

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

   198

    if loc is None:

   199

        wx.LogGui.EnableLogging(False)

   200

        loc = wx.Locale(langid)

   201

        wx.LogGui.EnableLogging(True)

   202

        builtins.__dict__['loc'] = loc

   203

        # Define location for searching translation files

   204

    loc.AddCatalogLookupPathPrefix(localedir)

   205

    # Define locale domain

   206

    loc.AddCatalog(domain)

   207

   208

    import locale

   209

    global default_locale

   210

    default_locale = locale.getdefaultlocale()[1]

   211

   212

    # sys.stdout.encoding = default_locale

   213

    # if Beremiz_service is started from Beremiz IDE

   214

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

   215

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

   216

    # automatically converted to 'ascii' string.

   217

    def unicode_translation(message):

   218

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

   219

   220

    builtins.__dict__['_'] = unicode_translation

   221

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

   222

   223

   224

# Life is hard... have a candy.

   225

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

   226

if enablewx:

   227

    try:

   228

        import wx

   229

        havewx = True

   230

    except ImportError:

   231

        print("Wx unavailable !")

   232

        havewx = False

   233

   234

    if havewx:

   235

        import re

   236

        import wx.adv

   237

   238

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

   239

            app = wx.App(redirect=False)

   240

        else:

   241

            app = wx.PySimpleApp(redirect=False)

   242

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

   243

   244

        default_locale = None

   245

        SetupI18n()

   246

   247

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

   248

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

   249

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

   250

   251

        class ParamsEntryDialog(wx.TextEntryDialog):

   252

   253

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

   254

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

   255

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

   256

   257

                self.Tests = []

   258

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

   259

   260

            def OnOK(self, event):

   261

                value = self.GetValue()

   262

                texts = {"value": value}

   263

                for function, message in self.Tests:

   264

                    if not function(value):

   265

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

   266

                        message.ShowModal()

   267

                        message.Destroy()

   268

                        return

   269

                self.EndModal(wx.ID_OK)

   270

                event.Skip()

   271

   272

            def GetValue(self):

   273

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

   274

   275

            def SetTests(self, tests):

   276

                self.Tests = tests

   277

   278

        class BeremizTaskBarIcon(wx.adv.TaskBarIcon):

   279

            TBMENU_START = wx.NewId()

   280

            TBMENU_STOP = wx.NewId()

   281

            TBMENU_CHANGE_NAME = wx.NewId()

   282

            TBMENU_CHANGE_PORT = wx.NewId()

   283

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   284

            TBMENU_LIVE_SHELL = wx.NewId()

   285

            TBMENU_WXINSPECTOR = wx.NewId()

   286

            TBMENU_CHANGE_WD = wx.NewId()

   287

            TBMENU_QUIT = wx.NewId()

   288

   289

            def __init__(self, pyroserver):

   290

                wx.adv.TaskBarIcon.__init__(self)

   291

                self.pyroserver = pyroserver

   292

                # Set the image

   293

                self.UpdateIcon(None)

   294

   295

                # bind some events

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

   306

            def CreatePopupMenu(self):

   307

                """

   308

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

   309

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   310

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

   311

                the base class takes care of the rest.

   312

                """

   313

                menu = wx.Menu()

   314

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

   315

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

   316

                menu.AppendSeparator()

   317

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

   318

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

   319

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

   320

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

   321

                menu.AppendSeparator()

   322

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

   323

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

   324

                menu.AppendSeparator()

   325

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

   326

                return menu

   327

   328

            def MakeIcon(self, img):

   329

                """

   330

                The various platforms have different requirements for the

   331

                icon size...

   332

                """

   333

                if "wxMSW" in wx.PlatformInfo:

   334

                    img = img.Scale(16, 16)

   335

                elif "wxGTK" in wx.PlatformInfo:

   336

                    img = img.Scale(22, 22)

   337

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

   338

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

   339

                return icon

   340

   341

            def OnTaskBarStartPLC(self, evt):

   342

                runtime.GetPLCObjectSingleton().StartPLC()

   343

   344

            def OnTaskBarStopPLC(self, evt):

   345

                runtime.GetPLCObjectSingleton().StopPLC()

   346

   347

            def OnTaskBarChangeInterface(self, evt):

   348

                ip_addr = self.pyroserver.ip_addr

   349

                ip_addr = '' if ip_addr is None else ip_addr

   350

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

   351

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

   352

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

   353

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

   354

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

   355

                    self.pyroserver.ip_addr = dlg.GetValue()

   356

                    self.pyroserver.Restart()

   357

   358

            def OnTaskBarChangePort(self, evt):

   359

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

   360

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

   361

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

   362

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

   363

                    self.pyroserver.Restart()

   364

   365

            def OnTaskBarChangeWorkingDir(self, evt):

   366

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

   367

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

   368

                    self.pyroserver.workdir = dlg.GetPath()

   369

                    self.pyroserver.Restart()

   370

   371

            def OnTaskBarChangeName(self, evt):

   372

                _servicename = self.pyroserver.servicename

   373

                _servicename = '' if _servicename is None else _servicename

   374

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

   375

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

   376

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

   377

                    self.pyroserver.servicename = dlg.GetValue()

   378

                    self.pyroserver.Restart()

   379

   380

            def _LiveShellLocals(self):

   381

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

   382

   383

            def OnTaskBarLiveShell(self, evt):

   384

                from wx import py

   385

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

   386

                frame.Show()

   387

   388

            def OnTaskBarWXInspector(self, evt):

   389

                # Activate the widget inspection tool

   390

                from wx.lib.inspection import InspectionTool

   391

                if not InspectionTool().initialized:

   392

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

   393

   394

                wnd = wx.GetApp()

   395

                InspectionTool().Show(wnd, True)

   396

   397

            def OnTaskBarQuit(self, evt):

   398

                if wx.Platform == '__WXMSW__':

   399

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

   400

                self.RemoveIcon()

   401

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

   402

   403

            def UpdateIcon(self, plcstatus):

   404

                if plcstatus is PlcStatus.Started:

   405

                    currenticon = self.MakeIcon(starticon)

   406

                elif plcstatus is PlcStatus.Stopped:

   407

                    currenticon = self.MakeIcon(stopicon)

   408

                else:

   409

                    currenticon = self.MakeIcon(defaulticon)

   410

                self.SetIcon(currenticon, "Beremiz Service")

   411

   412

   413

if not os.path.isdir(WorkingDir):

   414

    os.mkdir(WorkingDir)

   415

   416

   417

if enabletwisted:

   418

    import warnings

   419

    with warnings.catch_warnings():

   420

        warnings.simplefilter("ignore")

   421

        try:

   422

            if havewx:

   423

                from twisted.internet import wxreactor

   424

                wxreactor.install()

   425

            from twisted.internet import reactor

   426

   427

            havetwisted = True

   428

        except ImportError:

   429

            print(_("Twisted unavailable."))

   430

            havetwisted = False

   431

   432

pyruntimevars = {}

   433

   434

if havetwisted:

   435

    if havewx:

   436

        reactor.registerWxApp(app)

   437

   438

twisted_reactor_thread_id = None

   439

ui_thread = None

   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

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

   455

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

   456

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

   457

        # worker thread from twisted "threadselect" reactor

   458

        current_id = currentThread().ident

   459

   460

        if ui_thread is not None \

   461

            and ui_thread.ident != current_id \

   462

            and (not havetwisted or (

   463

                    twisted_reactor_thread_id is not None

   464

                    and twisted_reactor_thread_id != current_id)):

   465

   466

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

   467

            wx.CallAfter(wx_evaluator, o)

   468

            wx_eval_lock.acquire()

   469

            return o.res

   470

        else:

   471

            # avoid dead lock if called from the wx mainloop

   472

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

   473

else:

   474

    evaluator = default_evaluator

   475

   476

# Exception hooks

   477

   478

   479

def LogException(*exp):

   480

    LogMessageAndException("", exp)