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

from threading import Thread, Semaphore, Lock, currentThread

    36

from builtins import str as text

    37

from past.builtins import execfile

    38

from six.moves import builtins

    39

    40

import runtime

    41

from runtime.PyroServer import PyroServer

    42

from runtime.xenomai import TryPreloadXenomai

    43

from runtime import LogMessageAndException

    44

from runtime import PlcStatus

    45

from runtime import default_evaluator

    46

from runtime.Stunnel import ensurePSK

    47

import util.paths as paths

    48

    49

try:

    50

    from runtime.spawn_subprocess import Popen

    51

except ImportError:

    52

    from subprocess import Popen

    53

    54

def version():

    55

    from version import app_version

    56

    print("Beremiz_service: ", app_version)

    57

    58

    59

def usage():

    60

    version()

    61

    print("""

    62

Usage of Beremiz PLC execution service :\n

    63

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

    64

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

    65

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

    66

  -p  port number default:3000

    67

  -h  print this help text and quit

    68

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

    69

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

    70

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

    71

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

    72

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

    73

  -s  PSK secret path (default:PSK disabled)

    74

  -e  python extension (absolute path .py)

    75

    76

           working_dir - directory where are stored PLC files

    77

""" % sys.argv[0])

    78

    79

    80

try:

    81

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

    82

except getopt.GetoptError as err:

    83

    # print help information and exit:

    84

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

    85

    usage()

    86

    sys.exit(2)

    87

    88

# default values

    89

interface = ''

    90

port = 3000

    91

webport = 8009

    92

PSKpath = None

    93

wampconf = None

    94

servicename = None

    95

autostart = False

    96

enablewx = True

    97

havewx = False

    98

enabletwisted = True

    99

havetwisted = False

   100

   101

extensions = []

   102

statuschange = []

   103

def status_change_call_factory(wanted, args):

   104

    def status_change_call(status):

   105

        if wanted is None or status is wanted:

   106

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

   107

            Popen(cmd)

   108

    return status_change_call

   109

   110

for o, a in opts:

   111

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

   112

        usage()

   113

        sys.exit()

   114

    if o == "--version":

   115

        version()

   116

        sys.exit()

   117

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

   118

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

   119

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

   120

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

   121

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

   122

        statuschange.append(status_change_call_factory(None, a))

   123

    elif o == "-i":

   124

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

   125

            interface = a

   126

        elif a == "localhost":

   127

            interface = '127.0.0.1'

   128

        else:

   129

            usage()

   130

            sys.exit()

   131

    elif o == "-p":

   132

        # port: port that the service runs on

   133

        port = int(a)

   134

    elif o == "-n":

   135

        servicename = a

   136

    elif o == "-x":

   137

        enablewx = int(a)

   138

    elif o == "-t":

   139

        enabletwisted = int(a)

   140

    elif o == "-a":

   141

        autostart = int(a)

   142

    elif o == "-w":

   143

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

   144

    elif o == "-c":

   145

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

   146

    elif o == "-s":

   147

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

   148

    elif o == "-e":

   149

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

   150

        fnameanddirname.reverse()

   151

        extensions.append(fnameanddirname)

   152

    else:

   153

        usage()

   154

        sys.exit()

   155

   156

   157

beremiz_dir = paths.AbsDir(__file__)

   158

   159

if len(argv) > 1:

   160

    usage()

   161

    sys.exit()

   162

elif len(argv) == 1:

   163

    WorkingDir = argv[0]

   164

    os.chdir(WorkingDir)

   165

elif len(argv) == 0:

   166

    WorkingDir = os.getcwd()

   167

    argv = [WorkingDir]

   168

   169

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

   170

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

   171

TryPreloadXenomai()

   172

version()

   173

   174

   175

def Bpath(*args):

   176

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

   177

   178

   179

def SetupI18n():

   180

    # Get folder containing translation files

   181

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

   182

    # Get the default language

   183

    langid = wx.LANGUAGE_DEFAULT

   184

    # Define translation domain (name of translation files)

   185

    domain = "Beremiz"

   186

   187

    # Define locale for wx

   188

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

   189

    if loc is None:

   190

        wx.LogGui.EnableLogging(False)

   191

        loc = wx.Locale(langid)

   192

        wx.LogGui.EnableLogging(True)

   193

        builtins.__dict__['loc'] = loc

   194

        # Define location for searching translation files

   195

    loc.AddCatalogLookupPathPrefix(localedir)

   196

    # Define locale domain

   197

    loc.AddCatalog(domain)

   198

   199

    import locale

   200

    global default_locale

   201

    default_locale = locale.getdefaultlocale()[1]

   202

   203

    # sys.stdout.encoding = default_locale

   204

    # if Beremiz_service is started from Beremiz IDE

   205

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

   206

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

   207

    # automatically converted to 'ascii' string.

   208

    def unicode_translation(message):

   209

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

   210

   211

    builtins.__dict__['_'] = unicode_translation

   212

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

   213

   214

   215

# Life is hard... have a candy.

   216

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

   217

if enablewx:

   218

    try:

   219

        import wx

   220

        havewx = True

   221

    except ImportError:

   222

        print("Wx unavailable !")

   223

        havewx = False

   224

   225

    if havewx:

   226

        import re

   227

   228

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

   229

            app = wx.App(redirect=False)

   230

        else:

   231

            app = wx.PySimpleApp(redirect=False)

   232

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

   233

   234

        default_locale = None

   235

        SetupI18n()

   236

   237

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

   238

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

   239

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

   240

   241

        class ParamsEntryDialog(wx.TextEntryDialog):

   242

   243

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

   244

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

   245

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

   246

   247

                self.Tests = []

   248

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

   249

   250

            def OnOK(self, event):

   251

                value = self.GetValue()

   252

                texts = {"value": value}

   253

                for function, message in self.Tests:

   254

                    if not function(value):

   255

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

   256

                        message.ShowModal()

   257

                        message.Destroy()

   258

                        return

   259

                self.EndModal(wx.ID_OK)

   260

                event.Skip()

   261

   262

            def GetValue(self):

   263

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

   264

   265

            def SetTests(self, tests):

   266

                self.Tests = tests

   267

   268

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   269

            TBMENU_START = wx.NewId()

   270

            TBMENU_STOP = wx.NewId()

   271

            TBMENU_CHANGE_NAME = wx.NewId()

   272

            TBMENU_CHANGE_PORT = wx.NewId()

   273

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   274

            TBMENU_LIVE_SHELL = wx.NewId()

   275

            TBMENU_WXINSPECTOR = wx.NewId()

   276

            TBMENU_CHANGE_WD = wx.NewId()

   277

            TBMENU_QUIT = wx.NewId()

   278

   279

            def __init__(self, pyroserver):

   280

                wx.TaskBarIcon.__init__(self)

   281

                self.pyroserver = pyroserver

   282

                # Set the image

   283

                self.UpdateIcon(None)

   284

   285

                # bind some events

   286

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

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

   296

            def CreatePopupMenu(self):

   297

                """

   298

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

   299

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   300

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

   301

                the base class takes care of the rest.

   302

                """

   303

                menu = wx.Menu()

   304

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

   305

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

   306

                menu.AppendSeparator()

   307

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

   308

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

   309

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

   310

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

   311

                menu.AppendSeparator()

   312

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

   313

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

   314

                menu.AppendSeparator()

   315

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

   316

                return menu

   317

   318

            def MakeIcon(self, img):

   319

                """

   320

                The various platforms have different requirements for the

   321

                icon size...

   322

                """

   323

                if "wxMSW" in wx.PlatformInfo:

   324

                    img = img.Scale(16, 16)

   325

                elif "wxGTK" in wx.PlatformInfo:

   326

                    img = img.Scale(22, 22)

   327

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

   328

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

   329

                return icon

   330

   331

            def OnTaskBarStartPLC(self, evt):

   332

                runtime.GetPLCObjectSingleton().StartPLC()

   333

   334

            def OnTaskBarStopPLC(self, evt):

   335

                runtime.GetPLCObjectSingleton().StopPLC()

   336

   337

            def OnTaskBarChangeInterface(self, evt):

   338

                ip_addr = self.pyroserver.ip_addr

   339

                ip_addr = '' if ip_addr is None else ip_addr

   340

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

   341

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

   342

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

   343

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

   344

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

   345

                    self.pyroserver.ip_addr = dlg.GetValue()

   346

                    self.pyroserver.Restart()

   347

   348

            def OnTaskBarChangePort(self, evt):

   349

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

   350

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

   351

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

   352

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

   353

                    self.pyroserver.Restart()

   354

   355

            def OnTaskBarChangeWorkingDir(self, evt):

   356

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

   357

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

   358

                    self.pyroserver.workdir = dlg.GetPath()

   359

                    self.pyroserver.Restart()

   360

   361

            def OnTaskBarChangeName(self, evt):

   362

                _servicename = self.pyroserver.servicename

   363

                _servicename = '' if _servicename is None else _servicename

   364

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

   365

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

   366

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

   367

                    self.pyroserver.servicename = dlg.GetValue()

   368

                    self.pyroserver.Restart()

   369

   370

            def _LiveShellLocals(self):

   371

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

   372

   373

            def OnTaskBarLiveShell(self, evt):

   374

                from wx import py

   375

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

   376

                frame.Show()

   377

   378

            def OnTaskBarWXInspector(self, evt):

   379

                # Activate the widget inspection tool

   380

                from wx.lib.inspection import InspectionTool

   381

                if not InspectionTool().initialized:

   382

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

   383

   384

                wnd = wx.GetApp()

   385

                InspectionTool().Show(wnd, True)

   386

   387

            def OnTaskBarQuit(self, evt):

   388

                if wx.Platform == '__WXMSW__':

   389

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

   390

                self.RemoveIcon()

   391

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

   392

   393

            def UpdateIcon(self, plcstatus):

   394

                if plcstatus is PlcStatus.Started:

   395

                    currenticon = self.MakeIcon(starticon)

   396

                elif plcstatus is PlcStatus.Stopped:

   397

                    currenticon = self.MakeIcon(stopicon)

   398

                else:

   399

                    currenticon = self.MakeIcon(defaulticon)

   400

                self.SetIcon(currenticon, "Beremiz Service")

   401

   402

   403

if not os.path.isdir(WorkingDir):

   404

    os.mkdir(WorkingDir)

   405

   406

   407

if enabletwisted:

   408

    import warnings

   409

    with warnings.catch_warnings():

   410

        warnings.simplefilter("ignore")

   411

        try:

   412

            if havewx:

   413

                from twisted.internet import wxreactor

   414

                wxreactor.install()

   415

            from twisted.internet import reactor

   416

   417

            havetwisted = True

   418

        except ImportError:

   419

            print(_("Twisted unavailable."))

   420

            havetwisted = False

   421

   422

pyruntimevars = {}

   423

   424

if havetwisted:

   425

    if havewx:

   426

        reactor.registerWxApp(app)

   427

   428

twisted_reactor_thread_id = None

   429

ui_thread = None

   430

   431

if havewx:

   432

    wx_eval_lock = Semaphore(0)

   433

   434

    def statuschangeTskBar(status):

   435

        wx.CallAfter(taskbar_instance.UpdateIcon, status)

   436

   437

    statuschange.append(statuschangeTskBar)

   438

   439

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

   440

        tocall, args, kwargs = obj.call

   441

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

   442

        wx_eval_lock.release()

   443

   444

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

   445

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

   446

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

   447

        # worker thread from twisted "threadselect" reactor

   448

        current_id = currentThread().ident

   449

   450

        if ui_thread is not None \

   451

            and ui_thread.ident != current_id \

   452

            and (not havetwisted or (

   453

                    twisted_reactor_thread_id is not None

   454

                    and twisted_reactor_thread_id != current_id)):

   455

   456

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

   457

            wx.CallAfter(wx_evaluator, o)

   458

            wx_eval_lock.acquire()

   459

            return o.res

   460

        else:

   461

            # avoid dead lock if called from the wx mainloop

   462

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

   463

else:

   464

    evaluator = default_evaluator

   465

   466

# Exception hooks

   467

   468

   469

def LogException(*exp):

   470

    LogMessageAndException("", exp)

   471

   472

   473

sys.excepthook = LogException

   474

   475

   476

def installThreadExcepthook():

   477

    init_old = threading.Thread.__init__

   478

   479

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

   480

        init_old(self, *args, **kwargs)