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

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

from runtime import PlcStatus

    42

import util.paths as paths

    43

    44

    45

def version():

    46

    from version import app_version

    47

    print("Beremiz_service: ", app_version)

    48

    49

    50

def usage():

    51

    version()

    52

    print("""

    53

Usage of Beremiz PLC execution service :\n

    54

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

    55

  -n  zeroconf service name (default:disabled)

    56

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

    57

  -p  port number default:3000

    58

  -h  print this help text and quit

    59

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

    60

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

    61

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

    62

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

    63

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

    64

  -s  WAMP client secret, given as a file (can be overriden by wamp.secret in project)

    65

  -e  python extension (absolute path .py)

    66

    67

           working_dir - directory where are stored PLC files

    68

""" % sys.argv[0])

    69

    70

    71

try:

    72

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

    73

except getopt.GetoptError as err:

    74

    # print help information and exit:

    75

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

    76

    usage()

    77

    sys.exit(2)

    78

    79

# default values

    80

given_ip = None

    81

port = 3000

    82

webport = 8009

    83

wampsecret = None

    84

wampconf = None

    85

servicename = None

    86

autostart = False

    87

enablewx = True

    88

havewx = False

    89

enabletwisted = True

    90

havetwisted = False

    91

    92

extensions = []

    93

    94

for o, a in opts:

    95

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

    96

        usage()

    97

        sys.exit()

    98

    if o == "--version":

    99

        version()

   100

        sys.exit()

   101

    elif o == "-i":

   102

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

   103

            given_ip = a

   104

        else:

   105

            usage()

   106

            sys.exit()

   107

    elif o == "-p":

   108

        # port: port that the service runs on

   109

        port = int(a)

   110

    elif o == "-n":

   111

        servicename = a

   112

    elif o == "-x":

   113

        enablewx = int(a)

   114

    elif o == "-t":

   115

        enabletwisted = int(a)

   116

    elif o == "-a":

   117

        autostart = int(a)

   118

    elif o == "-w":

   119

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

   120

    elif o == "-c":

   121

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

   122

    elif o == "-s":

   123

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

   124

    elif o == "-e":

   125

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

   126

        fnameanddirname.reverse()

   127

        extensions.append(fnameanddirname)

   128

    else:

   129

        usage()

   130

        sys.exit()

   131

   132

   133

beremiz_dir = paths.AbsDir(__file__)

   134

   135

if len(argv) > 1:

   136

    usage()

   137

    sys.exit()

   138

elif len(argv) == 1:

   139

    WorkingDir = argv[0]

   140

    os.chdir(WorkingDir)

   141

elif len(argv) == 0:

   142

    WorkingDir = os.getcwd()

   143

    argv = [WorkingDir]

   144

   145

if __name__ == '__main__':

   146

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

   147

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

   148

    TryPreloadXenomai()

   149

    version()

   150

   151

   152

def Bpath(*args):

   153

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

   154

   155

   156

def SetupI18n():

   157

    # Get folder containing translation files

   158

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

   159

    # Get the default language

   160

    langid = wx.LANGUAGE_DEFAULT

   161

    # Define translation domain (name of translation files)

   162

    domain = "Beremiz"

   163

   164

    # Define locale for wx

   165

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

   166

    if loc is None:

   167

        wx.LogGui.EnableLogging(False)

   168

        loc = wx.Locale(langid)

   169

        wx.LogGui.EnableLogging(True)

   170

        __builtin__.__dict__['loc'] = loc

   171

        # Define location for searching translation files

   172

    loc.AddCatalogLookupPathPrefix(localedir)

   173

    # Define locale domain

   174

    loc.AddCatalog(domain)

   175

   176

    import locale

   177

    global default_locale

   178

    default_locale = locale.getdefaultlocale()[1]

   179

   180

    # sys.stdout.encoding = default_locale

   181

    # if Beremiz_service is started from Beremiz IDE

   182

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

   183

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

   184

    # automatically converted to 'ascii' string.

   185

    def unicode_translation(message):

   186

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

   187

   188

    if __name__ == '__main__':

   189

        __builtin__.__dict__['_'] = unicode_translation

   190

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

   191

   192

   193

# Life is hard... have a candy.

   194

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

   195

if enablewx:

   196

    try:

   197

        import wx

   198

        havewx = True

   199

    except ImportError:

   200

        print("Wx unavailable !")

   201

        havewx = False

   202

   203

    if havewx:

   204

        import re

   205

        from types import *

   206

   207

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

   208

            app = wx.App(redirect=False)

   209

        else:

   210

            app = wx.PySimpleApp(redirect=False)

   211

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

   212

   213

        default_locale = None

   214

        SetupI18n()

   215

   216

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

   217

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

   218

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

   219

   220

        class ParamsEntryDialog(wx.TextEntryDialog):

   221

   222

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

   223

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

   224

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

   225

   226

                self.Tests = []

   227

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

   228

   229

            def OnOK(self, event):

   230

                value = self.GetValue()

   231

                texts = {"value": value}

   232

                for function, message in self.Tests:

   233

                    if not function(value):

   234

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

   235

                        message.ShowModal()

   236

                        message.Destroy()

   237

                        return

   238

                self.EndModal(wx.ID_OK)

   239

                event.Skip()

   240

   241

            def GetValue(self):

   242

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

   243

   244

            def SetTests(self, tests):

   245

                self.Tests = tests

   246

   247

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   248

            TBMENU_START = wx.NewId()

   249

            TBMENU_STOP = wx.NewId()

   250

            TBMENU_CHANGE_NAME = wx.NewId()

   251

            TBMENU_CHANGE_PORT = wx.NewId()

   252

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   253

            TBMENU_LIVE_SHELL = wx.NewId()

   254

            TBMENU_WXINSPECTOR = wx.NewId()

   255

            TBMENU_CHANGE_WD = wx.NewId()

   256

            TBMENU_QUIT = wx.NewId()

   257

   258

            def __init__(self, pyroserver, level):

   259

                wx.TaskBarIcon.__init__(self)

   260

                self.pyroserver = pyroserver

   261

                # Set the image

   262

                self.UpdateIcon(None)

   263

                self.level = level

   264

   265

                # bind some events

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

   276

            def CreatePopupMenu(self):

   277

                """

   278

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

   279

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   280

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

   281

                the base class takes care of the rest.

   282

                """

   283

                menu = wx.Menu()

   284

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

   285

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

   286

                if self.level == 1:

   287

                    menu.AppendSeparator()

   288

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

   289

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

   290

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

   291

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

   292

                    menu.AppendSeparator()

   293

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

   294

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

   295

                menu.AppendSeparator()

   296

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

   297

                return menu

   298

   299

            def MakeIcon(self, img):

   300

                """

   301

                The various platforms have different requirements for the

   302

                icon size...

   303

                """

   304

                if "wxMSW" in wx.PlatformInfo:

   305

                    img = img.Scale(16, 16)

   306

                elif "wxGTK" in wx.PlatformInfo:

   307

                    img = img.Scale(22, 22)

   308

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

   309

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

   310

                return icon

   311

   312

            def OnTaskBarStartPLC(self, evt):

   313

                if self.pyroserver.plcobj is not None:

   314

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

   315

                    if plcstatus is PlcStatus.Stopped:

   316

                        self.pyroserver.plcobj.StartPLC()

   317

                    else:

   318

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

   319

   320

            def OnTaskBarStopPLC(self, evt):

   321

                if self.pyroserver.plcobj is not None:

   322

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

   323

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

   324

                    else:

   325

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

   326

   327

            def OnTaskBarChangeInterface(self, evt):

   328

                ip_addr = self.pyroserver.ip_addr

   329

                ip_addr = '' if ip_addr is None else ip_addr

   330

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

   331

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

   332

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

   333

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

   334

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

   335

                    self.pyroserver.ip_addr = dlg.GetValue()

   336

                    self.pyroserver.Restart()

   337

   338

            def OnTaskBarChangePort(self, evt):

   339

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

   340

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

   341

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

   342

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

   343

                    self.pyroserver.Restart()

   344

   345

            def OnTaskBarChangeWorkingDir(self, evt):

   346

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

   347

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

   348

                    self.pyroserver.workdir = dlg.GetPath()

   349

                    self.pyroserver.Restart()

   350

   351

            def OnTaskBarChangeName(self, evt):

   352

                servicename = self.pyroserver.servicename

   353

                servicename = '' if servicename is None else servicename

   354

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

   355

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

   356

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

   357

                    self.pyroserver.servicename = dlg.GetValue()

   358

                    self.pyroserver.Restart()

   359

   360

            def _LiveShellLocals(self):

   361

                if self.pyroserver.plcobj is not None:

   362

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

   363

                else:

   364

                    return {}

   365

   366

            def OnTaskBarLiveShell(self, evt):

   367

                from wx import py

   368

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

   369

                frame.Show()

   370

   371

            def OnTaskBarWXInspector(self, evt):

   372

                # Activate the widget inspection tool

   373

                from wx.lib.inspection import InspectionTool

   374

                if not InspectionTool().initialized:

   375

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

   376

   377

                wnd = wx.GetApp()

   378

                InspectionTool().Show(wnd, True)

   379

   380

            def OnTaskBarQuit(self, evt):

   381

                if wx.Platform == '__WXMSW__':

   382

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

   383

                self.RemoveIcon()

   384

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

   385

   386

            def UpdateIcon(self, plcstatus):

   387

                if plcstatus is PlcStatus.Started:

   388

                    currenticon = self.MakeIcon(starticon)

   389

                elif plcstatus is PlcStatus.Stopped:

   390

                    currenticon = self.MakeIcon(stopicon)

   391

                else:

   392

                    currenticon = self.MakeIcon(defaulticon)

   393

                self.SetIcon(currenticon, "Beremiz Service")

   394

   395

   396

if not os.path.isdir(WorkingDir):

   397

    os.mkdir(WorkingDir)

   398

   399

   400

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

   401

    try:

   402

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

   403

    except Exception:

   404

        res = (None, sys.exc_info())

   405

    return res

   406

   407

   408

class Server(object):

   409

    def __init__(self, servicename, ip_addr, port,

   410

                 workdir, argv,

   411

                 statuschange=None, evaluator=default_evaluator,

   412

                 pyruntimevars=None):

   413

        self.continueloop = True

   414

        self.daemon = None

   415

        self.servicename = servicename

   416

        self.ip_addr = ip_addr

   417

        self.port = port

   418

        self.workdir = workdir

   419

        self.argv = argv

   420

        self.servicepublisher = None

   421

        self.statuschange = statuschange

   422

        self.evaluator = evaluator

   423

        self.pyruntimevars = pyruntimevars

   424

        self.plcobj = PLCObject(self)

   425

   426

    def _to_be_published(self):

   427

        return self.servicename is not None and \

   428

               self.ip_addr is not None and \

   429

               self.ip_addr != "localhost" and \

   430

               self.ip_addr != "127.0.0.1"

   431

   432

    def PrintServerInfo(self):

   433

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

   434

   435

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

   436

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

   437

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

   438

   439

        if self._to_be_published():

   440

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

   441

   442

        sys.stdout.flush()

   443

   444

    def PyroLoop(self, when_ready):

   445

        while self.continueloop:

   446

            Pyro.config.PYRO_MULTITHREADED = 0

   447

            pyro.initServer()

   448

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

   449

   450

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

   451

            # taking too small timeout value may cause

   452

            # unwanted diconnection when IDE is kept busy for long periods

   453

            self.daemon.setTimeout(60)

   454

   455

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

   456

   457

            if self._to_be_published():

   458

                self.servicepublisher = ServicePublisher.ServicePublisher()

   459

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

   460

   461

            when_ready()

   462

            self.daemon.requestLoop()

   463

            self.daemon.sock.close()

   464

   465

    def Restart(self):

   466

        self._stop()

   467

   468

    def Quit(self):

   469

        self.continueloop = False

   470

        if self.plcobj is not None:

   471

            self.plcobj.StopPLC()

   472

            self.plcobj.UnLoadPLC()

   473

        self._stop()

   474

   475

    def _stop(self):

   476

        if self.plcobj is not None:

   477

            self.plcobj.StopPLC()

   478

        if self.servicepublisher is not None:

   479

            self.servicepublisher.UnRegisterService()

   480

            self.servicepublisher = None

   481