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

    34

import traceback

    35

from builtins import str as text

    36

from past.builtins import execfile

    37

from six.moves import builtins

    38

import Pyro

    39

import Pyro.core as pyro

    40

    41

from runtime import PLCObject, ServicePublisher, MainWorker

    42

from runtime.xenomai import TryPreloadXenomai

    43

from runtime import PlcStatus

    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  zeroconf service name (default: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  WAMP client secret, given as a file (can be overriden by wamp.secret in project)

    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

given_ip = None

    83

port = 3000

    84

webport = 8009

    85

wampsecret = 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 or a == "localhost":

   105

            given_ip = a

   106

        else:

   107

            usage()

   108

            sys.exit()

   109

    elif o == "-p":

   110

        # port: port that the service runs on

   111

        port = int(a)

   112

    elif o == "-n":

   113

        servicename = a

   114

    elif o == "-x":

   115

        enablewx = int(a)

   116

    elif o == "-t":

   117

        enabletwisted = int(a)

   118

    elif o == "-a":

   119

        autostart = int(a)

   120

    elif o == "-w":

   121

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

   122

    elif o == "-c":

   123

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

   124

    elif o == "-s":

   125

        wampsecret = None if a == "off" else a

   126

    elif o == "-e":

   127

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

   128

        fnameanddirname.reverse()

   129

        extensions.append(fnameanddirname)

   130

    else:

   131

        usage()

   132

        sys.exit()

   133

   134

   135

beremiz_dir = paths.AbsDir(__file__)

   136

   137

if len(argv) > 1:

   138

    usage()

   139

    sys.exit()

   140

elif len(argv) == 1:

   141

    WorkingDir = argv[0]

   142

    os.chdir(WorkingDir)

   143

elif len(argv) == 0:

   144

    WorkingDir = os.getcwd()

   145

    argv = [WorkingDir]

   146

   147

if __name__ == '__main__':

   148

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

   149

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

   150

    TryPreloadXenomai()

   151

    version()

   152

   153

   154

def Bpath(*args):

   155

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

   156

   157

   158

def SetupI18n():

   159

    # Get folder containing translation files

   160

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

   161

    # Get the default language

   162

    langid = wx.LANGUAGE_DEFAULT

   163

    # Define translation domain (name of translation files)

   164

    domain = "Beremiz"

   165

   166

    # Define locale for wx

   167

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

   168

    if loc is None:

   169

        wx.LogGui.EnableLogging(False)

   170

        loc = wx.Locale(langid)

   171

        wx.LogGui.EnableLogging(True)

   172

        builtins.__dict__['loc'] = loc

   173

        # Define location for searching translation files

   174

    loc.AddCatalogLookupPathPrefix(localedir)

   175

    # Define locale domain

   176

    loc.AddCatalog(domain)

   177

   178

    import locale

   179

    global default_locale

   180

    default_locale = locale.getdefaultlocale()[1]

   181

   182

    # sys.stdout.encoding = default_locale

   183

    # if Beremiz_service is started from Beremiz IDE

   184

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

   185

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

   186

    # automatically converted to 'ascii' string.

   187

    def unicode_translation(message):

   188

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

   189

   190

    if __name__ == '__main__':

   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, level):

   260

                wx.TaskBarIcon.__init__(self)

   261

                self.pyroserver = pyroserver

   262

                # Set the image

   263

                self.UpdateIcon(None)

   264

                self.level = level

   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

                if self.level == 1:

   288

                    menu.AppendSeparator()

   289

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

   290

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

   291

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

   292

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

   293

                    menu.AppendSeparator()

   294

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

   295

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

   296

                menu.AppendSeparator()

   297

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

   298

                return menu

   299

   300

            def MakeIcon(self, img):

   301

                """

   302

                The various platforms have different requirements for the

   303

                icon size...

   304

                """

   305

                if "wxMSW" in wx.PlatformInfo:

   306

                    img = img.Scale(16, 16)

   307

                elif "wxGTK" in wx.PlatformInfo:

   308

                    img = img.Scale(22, 22)

   309

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

   310

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

   311

                return icon

   312

   313

            def OnTaskBarStartPLC(self, evt):

   314

                if self.pyroserver.plcobj is not None:

   315

                    plcstatus = self.pyroserver.plcobj.GetPLCstatus()[0]

   316

                    if plcstatus is PlcStatus.Stopped:

   317

                        self.pyroserver.plcobj.StartPLC()

   318

                    else:

   319

                        print(_("PLC is empty or already started."))

   320

   321

            def OnTaskBarStopPLC(self, evt):

   322

                if self.pyroserver.plcobj is not None:

   323

                    if self.pyroserver.plcobj.GetPLCstatus()[0] == PlcStatus.Started:

   324

                        Thread(target=self.pyroserver.plcobj.StopPLC).start()

   325

                    else:

   326

                        print(_("PLC is not started."))

   327

   328

            def OnTaskBarChangeInterface(self, evt):

   329

                ip_addr = self.pyroserver.ip_addr

   330

                ip_addr = '' if ip_addr is None else ip_addr

   331

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

   332

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

   333

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

   334

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

   335

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

   336

                    self.pyroserver.ip_addr = dlg.GetValue()

   337

                    self.pyroserver.Restart()

   338

   339

            def OnTaskBarChangePort(self, evt):

   340

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

   341

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

   342

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

   343

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

   344

                    self.pyroserver.Restart()

   345

   346

            def OnTaskBarChangeWorkingDir(self, evt):

   347

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

   348

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

   349

                    self.pyroserver.workdir = dlg.GetPath()

   350

                    self.pyroserver.Restart()

   351

   352

            def OnTaskBarChangeName(self, evt):

   353

                servicename = self.pyroserver.servicename

   354

                servicename = '' if servicename is None else servicename

   355

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

   356

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

   357

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

   358

                    self.pyroserver.servicename = dlg.GetValue()

   359

                    self.pyroserver.Restart()

   360

   361

            def _LiveShellLocals(self):

   362

                if self.pyroserver.plcobj is not None:

   363

                    return {"locals": self.pyroserver.plcobj.python_runtime_vars}

   364

                else:

   365

                    return {}

   366

   367

            def OnTaskBarLiveShell(self, evt):

   368

                from wx import py

   369

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

   370

                frame.Show()

   371

   372

            def OnTaskBarWXInspector(self, evt):

   373

                # Activate the widget inspection tool

   374

                from wx.lib.inspection import InspectionTool

   375

                if not InspectionTool().initialized:

   376

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

   377

   378

                wnd = wx.GetApp()

   379

                InspectionTool().Show(wnd, True)

   380

   381

            def OnTaskBarQuit(self, evt):

   382

                if wx.Platform == '__WXMSW__':

   383

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

   384

                self.RemoveIcon()

   385

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

   386

   387

            def UpdateIcon(self, plcstatus):

   388

                if plcstatus is PlcStatus.Started:

   389

                    currenticon = self.MakeIcon(starticon)

   390

                elif plcstatus is PlcStatus.Stopped:

   391

                    currenticon = self.MakeIcon(stopicon)

   392

                else:

   393

                    currenticon = self.MakeIcon(defaulticon)

   394

                self.SetIcon(currenticon, "Beremiz Service")

   395

   396

   397

if not os.path.isdir(WorkingDir):

   398

    os.mkdir(WorkingDir)

   399

   400

   401

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

   402

    try:

   403

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

   404

    except Exception:

   405

        res = (None, sys.exc_info())

   406

    return res

   407

   408

   409

class Server(object):

   410

    def __init__(self, servicename, ip_addr, port,

   411

                 workdir, argv,

   412

                 statuschange=None, evaluator=default_evaluator,

   413

                 pyruntimevars=None):

   414

        self.continueloop = True

   415

        self.daemon = None

   416

        self.servicename = servicename

   417

        self.ip_addr = ip_addr

   418

        self.port = port

   419

        self.workdir = workdir

   420

        self.argv = argv

   421

        self.servicepublisher = None

   422

        self.statuschange = statuschange

   423

        self.evaluator = evaluator

   424

        self.pyruntimevars = pyruntimevars

   425

        self.plcobj = PLCObject(self)

   426

   427

    def _to_be_published(self):

   428

        return self.servicename is not None and \

   429

               self.ip_addr is not None and \

   430

               self.ip_addr != "localhost" and \

   431

               self.ip_addr != "127.0.0.1"

   432

   433

    def PrintServerInfo(self):

   434

        print(_("Pyro port :"), self.port)

   435

   436

        # Beremiz IDE detects LOCAL:// runtime is ready by looking

   437

        # for self.workdir in the daemon's stdout.

   438

        print(_("Current working directory :"), self.workdir)

   439

   440

        if self._to_be_published():

   441

            print(_("Publishing service on local network"))

   442

   443

        sys.stdout.flush()

   444

   445

    def PyroLoop(self, when_ready):

   446

        while self.continueloop:

   447

            Pyro.config.PYRO_MULTITHREADED = 0

   448

            pyro.initServer()

   449

            self.daemon = pyro.Daemon(host=self.ip_addr, port=self.port)

   450

   451

            # pyro never frees memory after connection close if no timeout set

   452

            # taking too small timeout value may cause

   453

            # unwanted diconnection when IDE is kept busy for long periods

   454

            self.daemon.setTimeout(60)

   455

   456

            self.daemon.connect(self.plcobj, "PLCObject")

   457

   458

            if self._to_be_published():

   459

                self.servicepublisher = ServicePublisher.ServicePublisher()

   460

                self.servicepublisher.RegisterService(self.servicename, self.ip_addr, self.port)

   461

   462

            when_ready()

   463

            self.daemon.requestLoop()

   464

            self.daemon.sock.close()

   465

   466

    def Restart(self):

   467

        self._stop()

   468

   469

    def Quit(self):

   470

        self.continueloop = False

   471

        if self.plcobj is not None:

   472

            self.plcobj.StopPLC()

   473

            self.plcobj.UnLoadPLC()

   474

        self._stop()

   475

   476

    def _stop(self):

   477

        if self.plcobj is not None:

   478

            self.plcobj.StopPLC()

   479

        if self.servicepublisher is not None:

   480

            self.servicepublisher.UnRegisterService()