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

   237

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

   238

            app = wx.App(redirect=False)

   239

        else:

   240

            app = wx.PySimpleApp(redirect=False)

   241

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

   242

   243

        default_locale = None

   244

        SetupI18n()

   245

   246

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

   247

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

   248

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

   249

   250

        class ParamsEntryDialog(wx.TextEntryDialog):

   251

   252

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

   253

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

   254

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

   255

   256

                self.Tests = []

   257

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

   258

   259

            def OnOK(self, event):

   260

                value = self.GetValue()

   261

                texts = {"value": value}

   262

                for function, message in self.Tests:

   263

                    if not function(value):

   264

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

   265

                        message.ShowModal()

   266

                        message.Destroy()

   267

                        return

   268

                self.EndModal(wx.ID_OK)

   269

                event.Skip()

   270

   271

            def GetValue(self):

   272

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

   273

   274

            def SetTests(self, tests):

   275

                self.Tests = tests

   276

   277

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   278

            TBMENU_START = wx.NewId()

   279

            TBMENU_STOP = wx.NewId()

   280

            TBMENU_CHANGE_NAME = wx.NewId()

   281

            TBMENU_CHANGE_PORT = wx.NewId()

   282

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   283

            TBMENU_LIVE_SHELL = wx.NewId()

   284

            TBMENU_WXINSPECTOR = wx.NewId()

   285

            TBMENU_CHANGE_WD = wx.NewId()

   286

            TBMENU_QUIT = wx.NewId()

   287

   288

            def __init__(self, pyroserver):

   289

                wx.TaskBarIcon.__init__(self)

   290

                self.pyroserver = pyroserver

   291

                # Set the image

   292

                self.UpdateIcon(None)

   293

   294

                # bind some events

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

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

   303

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

   304

   305

            def CreatePopupMenu(self):

   306

                """

   307

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

   308

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   309

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

   310

                the base class takes care of the rest.

   311

                """

   312

                menu = wx.Menu()

   313

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

   314

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

   315

                menu.AppendSeparator()

   316

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

   317

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

   318

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

   319

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

   320

                menu.AppendSeparator()

   321

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

   322

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

   323

                menu.AppendSeparator()

   324

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

   325

                return menu

   326

   327

            def MakeIcon(self, img):

   328

                """

   329

                The various platforms have different requirements for the

   330

                icon size...

   331

                """

   332

                if "wxMSW" in wx.PlatformInfo:

   333

                    img = img.Scale(16, 16)

   334

                elif "wxGTK" in wx.PlatformInfo:

   335

                    img = img.Scale(22, 22)

   336

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

   337

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

   338

                return icon

   339

   340

            def OnTaskBarStartPLC(self, evt):

   341

                runtime.GetPLCObjectSingleton().StartPLC()

   342

   343

            def OnTaskBarStopPLC(self, evt):

   344

                runtime.GetPLCObjectSingleton().StopPLC()

   345

   346

            def OnTaskBarChangeInterface(self, evt):

   347

                ip_addr = self.pyroserver.ip_addr

   348

                ip_addr = '' if ip_addr is None else ip_addr

   349

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

   350

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

   351

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

   352

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

   353

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

   354

                    self.pyroserver.ip_addr = dlg.GetValue()

   355

                    self.pyroserver.Restart()

   356

   357

            def OnTaskBarChangePort(self, evt):

   358

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

   359

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

   360

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

   361

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

   362

                    self.pyroserver.Restart()

   363

   364

            def OnTaskBarChangeWorkingDir(self, evt):

   365

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

   366

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

   367

                    self.pyroserver.workdir = dlg.GetPath()

   368

                    self.pyroserver.Restart()

   369

   370

            def OnTaskBarChangeName(self, evt):

   371

                _servicename = self.pyroserver.servicename

   372

                _servicename = '' if _servicename is None else _servicename

   373

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

   374

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

   375

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

   376

                    self.pyroserver.servicename = dlg.GetValue()

   377

                    self.pyroserver.Restart()

   378

   379

            def _LiveShellLocals(self):

   380

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

   381

   382

            def OnTaskBarLiveShell(self, evt):

   383

                from wx import py

   384

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

   385

                frame.Show()

   386

   387

            def OnTaskBarWXInspector(self, evt):

   388

                # Activate the widget inspection tool

   389

                from wx.lib.inspection import InspectionTool

   390

                if not InspectionTool().initialized:

   391

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

   392

   393

                wnd = wx.GetApp()

   394

                InspectionTool().Show(wnd, True)

   395

   396

            def OnTaskBarQuit(self, evt):

   397

                if wx.Platform == '__WXMSW__':

   398

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

   399

                self.RemoveIcon()

   400

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

   401

   402

            def UpdateIcon(self, plcstatus):

   403

                if plcstatus is PlcStatus.Started:

   404

                    currenticon = self.MakeIcon(starticon)

   405

                elif plcstatus is PlcStatus.Stopped:

   406

                    currenticon = self.MakeIcon(stopicon)

   407

                else:

   408

                    currenticon = self.MakeIcon(defaulticon)

   409

                self.SetIcon(currenticon, "Beremiz Service")

   410

   411

   412

if not os.path.isdir(WorkingDir):

   413

    os.mkdir(WorkingDir)

   414

   415

   416

if enabletwisted:

   417

    import warnings

   418

    with warnings.catch_warnings():

   419

        warnings.simplefilter("ignore")

   420

        try:

   421

            if havewx:

   422

                from twisted.internet import wxreactor

   423

                wxreactor.install()

   424

            from twisted.internet import reactor

   425

   426

            havetwisted = True

   427

        except ImportError:

   428

            print(_("Twisted unavailable."))

   429

            havetwisted = False

   430

   431

pyruntimevars = {}

   432

   433

if havetwisted:

   434

    if havewx:

   435

        reactor.registerWxApp(app)

   436

   437

twisted_reactor_thread_id = None

   438

ui_thread = None

   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

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

   454

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

   455

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

   456

        # worker thread from twisted "threadselect" reactor

   457

        current_id = currentThread().ident

   458

   459

        if ui_thread is not None \

   460

            and ui_thread.ident != current_id \

   461

            and (not havetwisted or (

   462

                    twisted_reactor_thread_id is not None

   463

                    and twisted_reactor_thread_id != current_id)):

   464

   465

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

   466

            wx.CallAfter(wx_evaluator, o)

   467

            wx_eval_lock.acquire()

   468

            return o.res

   469

        else:

   470

            # avoid dead lock if called from the wx mainloop

   471

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

   472

else:

   473

    evaluator = default_evaluator

   474

   475

# Exception hooks

   476

   477

   478

def LogException(*exp):

   479

    LogMessageAndException("", exp)

   480