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

import util.paths as paths

    42

    43

    44

def version():

    45

    from version import app_version

    46

    print("Beremiz_service: ", app_version)

    47

    48

    49

def usage():

    50

    version()

    51

    print("""

    52

Usage of Beremiz PLC execution service :\n

    53

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

    54

  -n  zeroconf service name (default:disabled)

    55

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

    56

  -p  port number default:3000

    57

  -h  print this help text and quit

    58

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

    59

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

    60

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

    61

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

    62

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

    63

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

    64

  -e  python extension (absolute path .py)

    65

    66

           working_dir - directory where are stored PLC files

    67

""" % sys.argv[0])

    68

    69

    70

try:

    71

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

    72

except getopt.GetoptError, err:

    73

    # print help information and exit:

    74

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

    75

    usage()

    76

    sys.exit(2)

    77

    78

# default values

    79

given_ip = None

    80

port = 3000

    81

webport = 8009

    82

wampsecret = None

    83

wampconf = None

    84

servicename = None

    85

autostart = False

    86

enablewx = True

    87

havewx = False

    88

enabletwisted = True

    89

havetwisted = False

    90

    91

extensions = []

    92

    93

for o, a in opts:

    94

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

    95

        usage()

    96

        sys.exit()

    97

    if o == "--version":

    98

        version()

    99

        sys.exit()

   100

    elif o == "-i":

   101

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

   102

            given_ip = a

   103

        else:

   104

            usage()

   105

            sys.exit()

   106

    elif o == "-p":

   107

        # port: port that the service runs on

   108

        port = int(a)

   109

    elif o == "-n":

   110

        servicename = a

   111

    elif o == "-x":

   112

        enablewx = int(a)

   113

    elif o == "-t":

   114

        enabletwisted = int(a)

   115

    elif o == "-a":

   116

        autostart = int(a)

   117

    elif o == "-w":

   118

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

   119

    elif o == "-c":

   120

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

   121

    elif o == "-s":

   122

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

   123

    elif o == "-e":

   124

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

   125

        fnameanddirname.reverse()

   126

        extensions.append(fnameanddirname)

   127

    else:

   128

        usage()

   129

        sys.exit()

   130

   131

   132

beremiz_dir = paths.AbsDir(__file__)

   133

   134

if len(argv) > 1:

   135

    usage()

   136

    sys.exit()

   137

elif len(argv) == 1:

   138

    WorkingDir = argv[0]

   139

    os.chdir(WorkingDir)

   140

elif len(argv) == 0:

   141

    WorkingDir = os.getcwd()

   142

    argv = [WorkingDir]

   143

   144

if __name__ == '__main__':

   145

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

   146

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

   147

    TryPreloadXenomai()

   148

    version()

   149

   150

   151

def Bpath(*args):

   152

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

   153

   154

   155

def SetupI18n():

   156

    # Get folder containing translation files

   157

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

   158

    # Get the default language

   159

    langid = wx.LANGUAGE_DEFAULT

   160

    # Define translation domain (name of translation files)

   161

    domain = "Beremiz"

   162

   163

    # Define locale for wx

   164

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

   165

    if loc is None:

   166

        wx.LogGui.EnableLogging(False)

   167

        loc = wx.Locale(langid)

   168

        wx.LogGui.EnableLogging(True)

   169

        __builtin__.__dict__['loc'] = loc

   170

        # Define location for searching translation files

   171

    loc.AddCatalogLookupPathPrefix(localedir)

   172

    # Define locale domain

   173

    loc.AddCatalog(domain)

   174

   175

    import locale

   176

    global default_locale

   177

    default_locale = locale.getdefaultlocale()[1]

   178

   179

    # sys.stdout.encoding = default_locale

   180

    # if Beremiz_service is started from Beremiz IDE

   181

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

   182

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

   183

    # automatically converted to 'ascii' string.

   184

    def unicode_translation(message):

   185

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

   186

   187

    if __name__ == '__main__':

   188

        __builtin__.__dict__['_'] = unicode_translation

   189

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

   190

   191

   192

# Life is hard... have a candy.

   193

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

   194

if enablewx:

   195

    try:

   196

        import wx

   197

        havewx = True

   198

    except ImportError:

   199

        print("Wx unavailable !")

   200

        havewx = False

   201

   202

    if havewx:

   203

        import re

   204

        from types import *

   205

   206

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

   207

            app = wx.App(redirect=False)

   208

        else:

   209

            app = wx.PySimpleApp(redirect=False)

   210

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

   211

   212

        default_locale = None

   213

        SetupI18n()

   214

   215

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

   216

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

   217

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

   218

   219

        class ParamsEntryDialog(wx.TextEntryDialog):

   220

   221

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

   222

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

   223

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

   224

   225

                self.Tests = []

   226

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

   227

   228

            def OnOK(self, event):

   229

                value = self.GetValue()

   230

                texts = {"value": value}

   231

                for function, message in self.Tests:

   232

                    if not function(value):

   233

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

   234

                        message.ShowModal()

   235

                        message.Destroy()

   236

                        return

   237

                self.EndModal(wx.ID_OK)

   238

                event.Skip()

   239

   240

            def GetValue(self):

   241

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

   242

   243

            def SetTests(self, tests):

   244

                self.Tests = tests

   245

   246

        class BeremizTaskBarIcon(wx.TaskBarIcon):

   247

            TBMENU_START = wx.NewId()

   248

            TBMENU_STOP = wx.NewId()

   249

            TBMENU_CHANGE_NAME = wx.NewId()

   250

            TBMENU_CHANGE_PORT = wx.NewId()

   251

            TBMENU_CHANGE_INTERFACE = wx.NewId()

   252

            TBMENU_LIVE_SHELL = wx.NewId()

   253

            TBMENU_WXINSPECTOR = wx.NewId()

   254

            TBMENU_CHANGE_WD = wx.NewId()

   255

            TBMENU_QUIT = wx.NewId()

   256

   257

            def __init__(self, pyroserver, level):

   258

                wx.TaskBarIcon.__init__(self)

   259

                self.pyroserver = pyroserver

   260

                # Set the image

   261

                self.UpdateIcon(None)

   262

                self.level = level

   263

   264

                # bind some events

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

   275

            def CreatePopupMenu(self):

   276

                """

   277

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

   278

                the menu for the default EVT_RIGHT_DOWN event.  Just create

   279

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

   280

                the base class takes care of the rest.

   281

                """

   282

                menu = wx.Menu()

   283

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

   284

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

   285

                if self.level == 1:

   286

                    menu.AppendSeparator()

   287

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

   288

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

   289

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

   290

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

   291

                    menu.AppendSeparator()

   292

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

   293

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

   294

                menu.AppendSeparator()

   295

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

   296

                return menu

   297

   298

            def MakeIcon(self, img):

   299

                """

   300

                The various platforms have different requirements for the

   301

                icon size...

   302

                """

   303

                if "wxMSW" in wx.PlatformInfo:

   304

                    img = img.Scale(16, 16)

   305

                elif "wxGTK" in wx.PlatformInfo:

   306

                    img = img.Scale(22, 22)

   307

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

   308

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

   309

                return icon

   310

   311

            def OnTaskBarStartPLC(self, evt):

   312

                if self.pyroserver.plcobj is not None:

   313

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

   314

                    if plcstatus is "Stopped":

   315

                        self.pyroserver.plcobj.StartPLC()

   316

                    else:

   317

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

   318

   319

            def OnTaskBarStopPLC(self, evt):

   320

                if self.pyroserver.plcobj is not None:

   321

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

   322

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

   323

                    else:

   324

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

   325

   326

            def OnTaskBarChangeInterface(self, evt):

   327

                ip_addr = self.pyroserver.ip_addr

   328

                ip_addr = '' if ip_addr is None else ip_addr

   329

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

   330

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

   331

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

   332

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

   333

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

   334

                    self.pyroserver.ip_addr = dlg.GetValue()

   335

                    self.pyroserver.Restart()

   336

   337

            def OnTaskBarChangePort(self, evt):

   338

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

   339

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

   340

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

   341

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

   342

                    self.pyroserver.Restart()

   343

   344

            def OnTaskBarChangeWorkingDir(self, evt):

   345

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

   346

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

   347

                    self.pyroserver.workdir = dlg.GetPath()

   348

                    self.pyroserver.Restart()

   349

   350

            def OnTaskBarChangeName(self, evt):

   351

                servicename = self.pyroserver.servicename

   352

                servicename = '' if servicename is None else servicename

   353

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

   354

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

   355

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

   356

                    self.pyroserver.servicename = dlg.GetValue()

   357

                    self.pyroserver.Restart()

   358

   359

            def _LiveShellLocals(self):

   360

                if self.pyroserver.plcobj is not None:

   361

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

   362

                else:

   363

                    return {}

   364

   365

            def OnTaskBarLiveShell(self, evt):

   366

                from wx import py

   367

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

   368

                frame.Show()

   369

   370

            def OnTaskBarWXInspector(self, evt):

   371

                # Activate the widget inspection tool

   372

                from wx.lib.inspection import InspectionTool

   373

                if not InspectionTool().initialized:

   374

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

   375

   376

                wnd = wx.GetApp()

   377

                InspectionTool().Show(wnd, True)

   378

   379

            def OnTaskBarQuit(self, evt):

   380

                if wx.Platform == '__WXMSW__':

   381

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

   382

                self.RemoveIcon()

   383

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

   384

   385

            def UpdateIcon(self, plcstatus):

   386

                if plcstatus is "Started":

   387

                    currenticon = self.MakeIcon(starticon)

   388

                elif plcstatus is "Stopped":

   389

                    currenticon = self.MakeIcon(stopicon)

   390

                else:

   391

                    currenticon = self.MakeIcon(defaulticon)

   392

                self.SetIcon(currenticon, "Beremiz Service")

   393

   394

   395

if not os.path.isdir(WorkingDir):

   396

    os.mkdir(WorkingDir)

   397

   398

   399

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

   400

    try:

   401

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

   402

    except Exception:

   403

        res = (None, sys.exc_info())

   404

    return res

   405

   406

   407

class Server(object):

   408

    def __init__(self, servicename, ip_addr, port,

   409

                 workdir, argv,

   410

                 statuschange=None, evaluator=default_evaluator,

   411

                 pyruntimevars=None):

   412

        self.continueloop = True

   413

        self.daemon = None

   414

        self.servicename = servicename

   415

        self.ip_addr = ip_addr

   416

        self.port = port

   417

        self.workdir = workdir

   418

        self.argv = argv

   419

        self.servicepublisher = None

   420

        self.statuschange = statuschange

   421

        self.evaluator = evaluator

   422

        self.pyruntimevars = pyruntimevars

   423

        self.plcobj = PLCObject(self)

   424

   425

    def _to_be_published(self):

   426

        return self.servicename is not None and \

   427

               self.ip_addr is not None and \

   428

               self.ip_addr != "localhost" and \

   429

               self.ip_addr != "127.0.0.1"

   430

   431

    def PrintServerInfo(self):

   432

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

   433

   434

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

   435

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

   436

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

   437

   438

        if self._to_be_published():

   439

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

   440

   441

        sys.stdout.flush()

   442

   443

    def PyroLoop(self, when_ready):

   444

        while self.continueloop:

   445

            Pyro.config.PYRO_MULTITHREADED = 0

   446

            pyro.initServer()

   447

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

   448

   449

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

   450

            # taking too small timeout value may cause

   451

            # unwanted diconnection when IDE is kept busy for long periods

   452

            self.daemon.setTimeout(60)

   453

   454

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

   455

   456

            if self._to_be_published():

   457

                self.servicepublisher = ServicePublisher.ServicePublisher()

   458

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

   459

   460

            when_ready()

   461

            self.daemon.requestLoop()

   462

            self.daemon.sock.close()

   463

   464

    def Restart(self):

   465

        self._stop()

   466

   467

    def Quit(self):

   468

        self.continueloop = False

   469

        if self.plcobj is not None:

   470

            self.plcobj.StopPLC()

   471

            self.plcobj.UnLoadPLC()

   472

        self._stop()

   473

   474

    def _stop(self):

   475

        if self.plcobj is not None:

   476

            self.plcobj.StopPLC()

   477

        if self.servicepublisher is not None:

   478

            self.servicepublisher.UnRegisterService()

   479

            self.servicepublisher = None

   480

        self.daemon.shutdown(True)

   481