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

   209

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

   210

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

   211

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

   212

   213

                self.Tests = []

   214

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

   215

   216

            def OnOK(self, event):

   217

                value = self.GetValue()

   218

                texts = {"value": value}

   219

                for function, message in self.Tests:

   220

                    if not function(value):

   221

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

   222

                        message.ShowModal()

   223

                        message.Destroy()

   224

                        return

   225

                self.EndModal(wx.ID_OK)

   226

                event.Skip()

   227

   228

            def GetValue(self):

   229

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

   230

   231

            def SetTests(self, tests):

   232

                self.Tests = tests

   233

   234

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   235

            TBMENU_START = wx.NewId()

   236

            TBMENU_STOP = wx.NewId()

   237

            TBMENU_CHANGE_NAME = wx.NewId()

   238

            TBMENU_CHANGE_PORT = wx.NewId()

   239

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   240

            TBMENU_LIVE_SHELL = wx.NewId()

   241

            TBMENU_WXINSPECTOR = wx.NewId()

   242

            TBMENU_CHANGE_WD = wx.NewId()

   243

            TBMENU_QUIT = wx.NewId()

   244

   245

            def __init__(self, pyroserver, level):

   246

                wx.TaskBarIcon.__init__(self)

   247

                self.pyroserver = pyroserver

   248

                # Set the image

   249

                self.UpdateIcon(None)

   250

                self.level = level

   251

   252

                # bind some events

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

   263

            def CreatePopupMenu(self):

   264

                """

   265

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

   266

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   267

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

   268

                the base class takes care of the rest.

   269

                """

   270

                menu = wx.Menu()

   271

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

   272

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

   273

                if self.level == 1:

   274

                    menu.AppendSeparator()

   275

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

   276

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

   277

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

   278

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

   279

                    menu.AppendSeparator()

   280

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

   281

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

   282

                menu.AppendSeparator()

   283

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

   284

                return menu

   285

   286

            def MakeIcon(self, img):

   287

                """

   288

                The various platforms have different requirements for the

   289

                icon size...

   290

                """

   291

                if "wxMSW" in wx.PlatformInfo:

   292

                    img = img.Scale(16, 16)

   293

                elif "wxGTK" in wx.PlatformInfo:

   294

                    img = img.Scale(22, 22)

   295

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

   296

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

   297

                return icon

   298

   299

            def OnTaskBarStartPLC(self, evt):

   300

                if self.pyroserver.plcobj is not None:

   301

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

   302

                    if plcstatus is "Stopped":

   303

                        self.pyroserver.plcobj.StartPLC()

   304

                    else:

   305

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

   306

   307

            def OnTaskBarStopPLC(self, evt):

   308

                if self.pyroserver.plcobj is not None:

   309

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

   310

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

   311

                    else:

   312

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

   313

   314

            def OnTaskBarChangeInterface(self, evt):

   315

                ip_addr = self.pyroserver.ip_addr

   316

                ip_addr = '' if ip_addr is None else ip_addr

   317

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

   318

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

   319

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

   320

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

   321

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

   322

                    self.pyroserver.ip_addr = dlg.GetValue()

   323

                    self.pyroserver.Restart()

   324

   325

            def OnTaskBarChangePort(self, evt):

   326

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

   327

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

   328

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

   329

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

   330

                    self.pyroserver.Restart()

   331

   332

            def OnTaskBarChangeWorkingDir(self, evt):

   333

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

   334

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

   335

                    self.pyroserver.workdir = dlg.GetPath()

   336

                    self.pyroserver.Restart()

   337

   338

            def OnTaskBarChangeName(self, evt):

   339

                servicename = self.pyroserver.servicename

   340

                servicename = '' if servicename is None else servicename

   341

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

   342

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

   343

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

   344

                    self.pyroserver.servicename = dlg.GetValue()

   345

                    self.pyroserver.Restart()

   346

   347

            def _LiveShellLocals(self):

   348

                if self.pyroserver.plcobj is not None:

   349

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

   350

                else:

   351

                    return {}

   352

   353

            def OnTaskBarLiveShell(self, evt):

   354

                from wx import py

   355

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

   356

                frame.Show()

   357

   358

            def OnTaskBarWXInspector(self, evt):

   359

                # Activate the widget inspection tool

   360

                from wx.lib.inspection import InspectionTool

   361

                if not InspectionTool().initialized:

   362

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

   363

   364

                wnd = wx.GetApp()

   365

                InspectionTool().Show(wnd, True)

   366

   367

            def OnTaskBarQuit(self, evt):

   368

                if wx.Platform == '__WXMSW__':

   369

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

   370

                self.RemoveIcon()

   371

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

   372

   373

            def UpdateIcon(self, plcstatus):

   374

                if plcstatus is "Started":

   375

                    currenticon = self.MakeIcon(starticon)

   376

                elif plcstatus is "Stopped":

   377

                    currenticon = self.MakeIcon(stopicon)

   378

                else:

   379

                    currenticon = self.MakeIcon(defaulticon)

   380

                self.SetIcon(currenticon, "Beremiz Service")

   381

   382

   383

if not os.path.isdir(WorkingDir):

   384

    os.mkdir(WorkingDir)

   385

   386

   387

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

   388

    try:

   389

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

   390

    except Exception:

   391

        res = (None, sys.exc_info())

   392

    return res

   393

   394

   395

class Server(object):

   396

    def __init__(self, servicename, ip_addr, port,

   397

                 workdir, argv,

   398

                 statuschange=None, evaluator=default_evaluator,

   399

                 pyruntimevars=None):

   400

        self.continueloop = True

   401

        self.daemon = None

   402

        self.servicename = servicename

   403

        self.ip_addr = ip_addr

   404

        self.port = port

   405

        self.workdir = workdir

   406

        self.argv = argv

   407

        self.servicepublisher = None

   408

        self.statuschange = statuschange

   409

        self.evaluator = evaluator

   410

        self.pyruntimevars = pyruntimevars

   411

        self.plcobj = PLCObject(self)

   412

   413

    def _to_be_published(self):

   414

        return self.servicename is not None and \

   415

               self.ip_addr is not None and \

   416

               self.ip_addr != "localhost" and \

   417

               self.ip_addr != "127.0.0.1"

   418

   419

    def PrintServerInfo(self):

   420

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

   421

   422

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

   423

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

   424

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

   425

   426

        if self._to_be_published():

   427

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

   428

   429

        sys.stdout.flush()

   430

   431

    def PyroLoop(self, when_ready):

   432

        while self.continueloop:

   433

            Pyro.config.PYRO_MULTITHREADED = 0

   434

            pyro.initServer()

   435

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

   436

   437

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

   438

            # taking too small timeout value may cause

   439

            # unwanted diconnection when IDE is kept busy for long periods

   440

            self.daemon.setTimeout(60)

   441

   442

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

   443

   444

            if self._to_be_published():

   445

                self.servicepublisher = ServicePublisher.ServicePublisher()

   446

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

   447

   448

            when_ready()

   449

            self.daemon.requestLoop()

   450

            self.daemon.sock.close()

   451

   452

    def Restart(self):

   453

        self._stop()

   454

   455

    def Quit(self):

   456

        self.continueloop = False

   457

        if self.plcobj is not None:

   458

            self.plcobj.StopPLC()

   459

            self.plcobj.UnLoadPLC()

   460

        self._stop()

   461

   462

    def _stop(self):

   463

        if self.plcobj is not None:

   464

            self.plcobj.StopPLC()

   465

        if self.servicepublisher is not None:

   466

            self.servicepublisher.UnRegisterService()

   467

            self.servicepublisher = None

   468

        self.daemon.shutdown(True)

   469

   470

    def AutoLoad(self):

   471

        self.plcobj.AutoLoad()

   472

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

   473

            if autostart:

   474

                self.plcobj.StartPLC()

   475

        self.plcobj.StatusChange()

   476

   477

   478

if enabletwisted:

   479

    import warnings

   480

    with warnings.catch_warnings():

   481

        warnings.simplefilter("ignore")

   482