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, currentThread, Semaphore, Lock

    34

import traceback

    35

import __builtin__

    36

import Pyro

    37

import Pyro.core as pyro

    38

    39

from runtime import PLCObject, ServicePublisher, MainWorker

    40

from runtime.xenomai import TryPreloadXenomai

    41

import util.paths as paths

    42

    43

    44

def usage():

    45

    print("""

    46

Usage of Beremiz PLC execution service :\n

    47

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

    48

           -n        - zeroconf service name (default:disabled)

    49

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

    50

           -p        - port number default:3000

    51

           -h        - print this help text and quit

    52

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

    53

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

    54

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

    55

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

    56

           -c        - WAMP client default config file (default:wampconf.json)

    57

           -s        - WAMP client secret, given as a file

    58

           -e        - python extension (absolute path .py)

    59

    60

           working_dir - directory where are stored PLC files

    61

""" % sys.argv[0])

    62

    63

    64

try:

    65

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

    66

except getopt.GetoptError, err:

    67

    # print help information and exit:

    68

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

    69

    usage()

    70

    sys.exit(2)

    71

    72

# default values

    73

given_ip = None

    74

port = 3000

    75

webport = 8009

    76

wampsecret = None

    77

wampconf = None

    78

servicename = None

    79

autostart = False

    80

enablewx = True

    81

havewx = False

    82

enabletwisted = True

    83

havetwisted = False

    84

    85

extensions = []

    86

    87

for o, a in opts:

    88

    if o == "-h":

    89

        usage()

    90

        sys.exit()

    91

    elif o == "-i":

    92

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

    93

            given_ip = a

    94

        else:

    95

            usage()

    96

            sys.exit()

    97

    elif o == "-p":

    98

        # port: port that the service runs on

    99

        port = int(a)

   100

    elif o == "-n":

   101

        servicename = a

   102

    elif o == "-x":

   103

        enablewx = int(a)

   104

    elif o == "-t":

   105

        enabletwisted = int(a)

   106

    elif o == "-a":

   107

        autostart = int(a)

   108

    elif o == "-w":

   109

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

   110

    elif o == "-c":

   111

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

   112

    elif o == "-s":

   113

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

   114

    elif o == "-e":

   115

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

   116

        fnameanddirname.reverse()

   117

        extensions.append(fnameanddirname)

   118

    else:

   119

        usage()

   120

        sys.exit()

   121

   122

   123

beremiz_dir = paths.AbsDir(__file__)

   124

   125

if len(argv) > 1:

   126

    usage()

   127

    sys.exit()

   128

elif len(argv) == 1:

   129

    WorkingDir = argv[0]

   130

    os.chdir(WorkingDir)

   131

elif len(argv) == 0:

   132

    WorkingDir = os.getcwd()

   133

    argv = [WorkingDir]

   134

   135

if __name__ == '__main__':

   136

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

   137

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

   138

    TryPreloadXenomai()

   139

   140

   141

def Bpath(*args):

   142

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

   143

   144

   145

def SetupI18n():

   146

    # Get folder containing translation files

   147

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

   148

    # Get the default language

   149

    langid = wx.LANGUAGE_DEFAULT

   150

    # Define translation domain (name of translation files)

   151

    domain = "Beremiz"

   152

   153

    # Define locale for wx

   154

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

   155

    if loc is None:

   156

        loc = wx.Locale(langid)

   157

        __builtin__.__dict__['loc'] = loc

   158

        # Define location for searching translation files

   159

    loc.AddCatalogLookupPathPrefix(localedir)

   160

    # Define locale domain

   161

    loc.AddCatalog(domain)

   162

   163

    import locale

   164

    global default_locale

   165

    default_locale = locale.getdefaultlocale()[1]

   166

   167

    # sys.stdout.encoding = default_locale

   168

    # if Beremiz_service is started from Beremiz IDE

   169

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

   170

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

   171

    # automatically converted to 'ascii' string.

   172

    def unicode_translation(message):

   173

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

   174

   175

    if __name__ == '__main__':

   176

        __builtin__.__dict__['_'] = unicode_translation

   177

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

   178

   179

   180

# Life is hard... have a candy.

   181

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

   182

if enablewx:

   183

    try:

   184

        import wx

   185

        havewx = True

   186

    except ImportError:

   187

        print("Wx unavailable !")

   188

        havewx = False

   189

   190

    if havewx:

   191

        import re

   192

        from types import *

   193

   194

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

   195

            app = wx.App(redirect=False)

   196

        else:

   197

            app = wx.PySimpleApp(redirect=False)

   198

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

   199

   200

        default_locale = None

   201

        SetupI18n()

   202

   203

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

   204

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

   205

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

   206

   207

        class ParamsEntryDialog(wx.TextEntryDialog):

   208

            if wx.VERSION < (2, 6, 0):

   209

                def Bind(self, event, function, id=None):

   210

                    if id is not None:

   211

                        event(self, id, function)

   212

                    else:

   213

                        event(self, function)

   214

   215

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

   216

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

   217

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

   218

   219

                self.Tests = []

   220

                if wx.VERSION >= (2, 8, 0):

   221

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

   222

                elif wx.VERSION >= (2, 6, 0):

   223

                    self.Bind(wx.EVT_BUTTON, self.OnOK, id=self.GetSizer().GetItem(3).GetSizer().GetAffirmativeButton().GetId())

   224

                else:

   225

                    self.Bind(wx.EVT_BUTTON, self.OnOK, id=self.GetSizer().GetItem(3).GetSizer().GetChildren()[0].GetSizer().GetChildren()[0].GetWindow().GetId())

   226

   227

            def OnOK(self, event):

   228

                value = self.GetValue()

   229

                texts = {"value": value}

   230

                for function, message in self.Tests:

   231

                    if not function(value):

   232

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

   233

                        message.ShowModal()

   234

                        message.Destroy()

   235

                        return

   236

                self.EndModal(wx.ID_OK)

   237

                event.Skip()

   238

   239

            def GetValue(self):

   240

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

   241

   242

            def SetTests(self, tests):

   243

                self.Tests = tests

   244

   245

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   246

            TBMENU_START = wx.NewId()

   247

            TBMENU_STOP = wx.NewId()

   248

            TBMENU_CHANGE_NAME = wx.NewId()

   249

            TBMENU_CHANGE_PORT = wx.NewId()

   250

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   251

            TBMENU_LIVE_SHELL = wx.NewId()

   252

            TBMENU_WXINSPECTOR = wx.NewId()

   253

            TBMENU_CHANGE_WD = wx.NewId()

   254

            TBMENU_QUIT = wx.NewId()

   255

   256

            def __init__(self, pyroserver, level):

   257

                wx.TaskBarIcon.__init__(self)

   258

                self.pyroserver = pyroserver

   259

                # Set the image

   260

                self.UpdateIcon(None)

   261

                self.level = level

   262

   263

                # bind some events

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

   274

            def CreatePopupMenu(self):

   275

                """

   276

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

   277

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   278

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

   279

                the base class takes care of the rest.

   280

                """

   281

                menu = wx.Menu()

   282

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

   283

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

   284

                if self.level == 1:

   285

                    menu.AppendSeparator()

   286

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

   287

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

   288

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

   289

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

   290

                    menu.AppendSeparator()

   291

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

   292

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

   293

                menu.AppendSeparator()

   294

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

   295

                return menu

   296

   297

            def MakeIcon(self, img):

   298

                """

   299

                The various platforms have different requirements for the

   300

                icon size...

   301

                """

   302

                if "wxMSW" in wx.PlatformInfo:

   303

                    img = img.Scale(16, 16)

   304

                elif "wxGTK" in wx.PlatformInfo:

   305

                    img = img.Scale(22, 22)

   306

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

   307

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

   308

                return icon

   309

   310

            def OnTaskBarStartPLC(self, evt):

   311

                if self.pyroserver.plcobj is not None:

   312

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

   313

                    if plcstatus is "Stopped":

   314

                        self.pyroserver.plcobj.StartPLC()

   315

                    else:

   316

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

   317

   318

            def OnTaskBarStopPLC(self, evt):

   319

                if self.pyroserver.plcobj is not None:

   320

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

   321

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

   322

                    else:

   323

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

   324

   325

            def OnTaskBarChangeInterface(self, evt):

   326

                ip_addr = self.pyroserver.ip_addr

   327

                ip_addr = '' if ip_addr is None else ip_addr

   328

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

   329

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

   330

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

   331

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

   332

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

   333

                    self.pyroserver.ip_addr = dlg.GetValue()

   334

                    self.pyroserver.Restart()

   335

   336

            def OnTaskBarChangePort(self, evt):

   337

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

   338

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

   339

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

   340

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

   341

                    self.pyroserver.Restart()

   342

   343

            def OnTaskBarChangeWorkingDir(self, evt):

   344

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

   345

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

   346

                    self.pyroserver.workdir = dlg.GetPath()

   347

                    self.pyroserver.Restart()

   348

   349

            def OnTaskBarChangeName(self, evt):

   350

                servicename = self.pyroserver.servicename

   351

                servicename = '' if servicename is None else servicename

   352

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

   353

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

   354

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

   355

                    self.pyroserver.servicename = dlg.GetValue()

   356

                    self.pyroserver.Restart()

   357

   358

            def _LiveShellLocals(self):

   359

                if self.pyroserver.plcobj is not None:

   360

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

   361

                else:

   362

                    return {}

   363

   364

            def OnTaskBarLiveShell(self, evt):

   365

                from wx import py

   366

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

   367

                frame.Show()

   368

   369

            def OnTaskBarWXInspector(self, evt):

   370

                # Activate the widget inspection tool

   371

                from wx.lib.inspection import InspectionTool

   372

                if not InspectionTool().initialized:

   373

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

   374

   375

                wnd = wx.GetApp()

   376

                InspectionTool().Show(wnd, True)

   377

   378

            def OnTaskBarQuit(self, evt):

   379

                if wx.Platform == '__WXMSW__':

   380

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

   381

                self.RemoveIcon()

   382

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

   383

   384

            def UpdateIcon(self, plcstatus):

   385

                if plcstatus is "Started":

   386

                    currenticon = self.MakeIcon(starticon)

   387

                elif plcstatus is "Stopped":

   388

                    currenticon = self.MakeIcon(stopicon)

   389

                else:

   390

                    currenticon = self.MakeIcon(defaulticon)

   391

                self.SetIcon(currenticon, "Beremiz Service")

   392

   393

   394

if not os.path.isdir(WorkingDir):

   395

    os.mkdir(WorkingDir)

   396

   397

   398

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

   399

    try:

   400

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

   401

    except Exception:

   402

        res = (None, sys.exc_info())

   403

    return res

   404

   405

   406

class Server(object):

   407

    def __init__(self, servicename, ip_addr, port,

   408

                 workdir, argv,

   409

                 statuschange=None, evaluator=default_evaluator,

   410

                 pyruntimevars=None):

   411

        self.continueloop = True

   412

        self.daemon = None

   413

        self.servicename = servicename

   414

        self.ip_addr = ip_addr

   415

        self.port = port

   416

        self.workdir = workdir

   417

        self.argv = argv

   418

        self.servicepublisher = None

   419

        self.statuschange = statuschange

   420

        self.evaluator = evaluator

   421

        self.pyruntimevars = pyruntimevars

   422

        self.plcobj = PLCObject(self)

   423

   424

    def _to_be_published(self):

   425

        return self.servicename is not None and \

   426

               self.ip_addr is not None and \

   427

               self.ip_addr != "localhost" and \

   428

               self.ip_addr != "127.0.0.1"

   429

   430

    def PrintServerInfo(self):

   431

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

   432

   433

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

   434

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

   435

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

   436

   437

        if self._to_be_published():

   438

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

   439

   440

        sys.stdout.flush()

   441

   442

    def PyroLoop(self, when_ready):

   443

        while self.continueloop:

   444

            Pyro.config.PYRO_MULTITHREADED = 0

   445

            pyro.initServer()

   446

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

   447

   448

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

   449

            # taking too small timeout value may cause

   450

            # unwanted diconnection when IDE is kept busy for long periods

   451

            self.daemon.setTimeout(60)

   452

   453

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

   454

   455

            if self._to_be_published():

   456

                self.servicepublisher = ServicePublisher.ServicePublisher()

   457

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

   458

   459

            when_ready()

   460

            self.daemon.requestLoop()

   461

            self.daemon.sock.close()

   462

   463

    def Restart(self):

   464

        self._stop()

   465

   466

    def Quit(self):

   467

        self.continueloop = False

   468

        if self.plcobj is not None:

   469

            self.plcobj.StopPLC()

   470

            self.plcobj.UnLoadPLC()

   471

        self._stop()

   472

   473

    def _stop(self):

   474

        if self.plcobj is not None:

   475

            self.plcobj.StopPLC()

   476

        if self.servicepublisher is not None:

   477

            self.servicepublisher.UnRegisterService()

   478

            self.servicepublisher = None

   479

        self.daemon.shutdown(True)

   480

   481

    def AutoLoad(self):