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) 2016: Andrey Skvortsov <andrej.skvortzov@gmail.com>

     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

import os

    28

import sys

    29

import tempfile

    30

import shutil

    31

import random

    32

import time

    33

import version

    34

    35

from types import ListType

    36

    37

import wx.lib.buttons

    38

import wx.lib.statbmp

    39

import wx.stc

    40

import cPickle

    41

import types

    42

import time

    43

import re

    44

import platform

    45

import time

    46

import traceback

    47

import commands

    48

import threading

    49

from threading import Lock, Timer, currentThread

    50

from time import time as gettime

    51

    52

import util.paths as paths

    53

from docutil import OpenHtmlFrame

    54

from editors.EditorPanel import EditorPanel

    55

from editors.Viewer import Viewer

    56

from editors.TextViewer import TextViewer

    57

from editors.ResourceEditor import ConfigurationEditor, ResourceEditor

    58

from editors.DataTypeEditor import DataTypeEditor

    59

from util.MiniTextControler import MiniTextControler

    60

from util.ProcessLogger import ProcessLogger

    61

from controls.LogViewer import LogViewer

    62

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

    63

from controls import EnhancedStatusBar as esb

    64

from dialogs.AboutDialog import ShowAboutDialog

    65

    66

from PLCControler import \

    67

    LOCATION_CONFNODE, \

    68

    LOCATION_MODULE, \

    69

    LOCATION_GROUP, \

    70

    LOCATION_VAR_INPUT, \

    71

    LOCATION_VAR_OUTPUT, \

    72

    LOCATION_VAR_MEMORY, \

    73

    ITEM_PROJECT, \

    74

    ITEM_RESOURCE

    75

    76

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

    77

    78

from IDEFrame import \

    79

    TITLE,\

    80

    EDITORTOOLBAR,\

    81

    FILEMENU,\

    82

    EDITMENU,\

    83

    DISPLAYMENU,\

    84

    PROJECTTREE,\

    85

    POUINSTANCEVARIABLESPANEL,\

    86

    LIBRARYTREE,\

    87

    SCALING,\

    88

    PAGETITLES,\

    89

    IDEFrame, \

    90

    AppendMenu,\

    91

    EncodeFileSystemPath, \

    92

    DecodeFileSystemPath

    93

    94

from util.BitmapLibrary import GetBitmap

    95

    96

    97

beremiz_dir = paths.AbsDir(__file__)

    98

    99

   100

def Bpath(*args):

   101

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

   102

   103

   104

MAX_RECENT_PROJECTS = 9

   105

   106

   107

if wx.Platform == '__WXMSW__':

   108

    faces = {

   109

        'mono': 'Courier New',

   110

        'size': 8,

   111

    }

   112

else:

   113

    faces = {

   114

        'mono': 'Courier',

   115

        'size': 10,

   116

    }

   117

   118

   119

MainThread = currentThread().ident

   120

REFRESH_PERIOD = 0.1

   121

   122

   123

class LogPseudoFile:

   124

    """ Base class for file like objects to facilitate StdOut for the Shell."""

   125

    def __init__(self, output, risecall):

   126

        self.red_white = 1

   127

        self.red_yellow = 2

   128

        self.black_white = wx.stc.STC_STYLE_DEFAULT

   129

        self.output = output

   130

        self.risecall = risecall

   131

        # to prevent rapid fire on rising log panel

   132

        self.rising_timer = 0

   133

        self.lock = Lock()

   134

        self.YieldLock = Lock()

   135

        self.RefreshLock = Lock()

   136

        self.TimerAccessLock = Lock()

   137

        self.stack = []

   138

        self.LastRefreshTime = gettime()

   139

        self.LastRefreshTimer = None

   140

   141

    def write(self, s, style=None):

   142

        if self.lock.acquire():

   143

            self.stack.append((s, style))

   144

            self.lock.release()

   145

            current_time = gettime()

   146

            self.TimerAccessLock.acquire()

   147

            if self.LastRefreshTimer:

   148

                self.LastRefreshTimer.cancel()

   149

                self.LastRefreshTimer = None

   150

            self.TimerAccessLock.release()

   151

            if current_time - self.LastRefreshTime > REFRESH_PERIOD and self.RefreshLock.acquire(False):

   152

                self._should_write()

   153

            else:

   154

                self.TimerAccessLock.acquire()

   155

                self.LastRefreshTimer = Timer(REFRESH_PERIOD, self._timer_expired)

   156

                self.LastRefreshTimer.start()

   157

                self.TimerAccessLock.release()

   158

   159

    def _timer_expired(self):

   160

        if self.RefreshLock.acquire(False):

   161

            self._should_write()

   162

        else:

   163

            self.TimerAccessLock.acquire()

   164

            self.LastRefreshTimer = Timer(REFRESH_PERIOD, self._timer_expired)

   165

            self.LastRefreshTimer.start()

   166

            self.TimerAccessLock.release()

   167

   168

    def _should_write(self):

   169

        wx.CallAfter(self._write)

   170

        if MainThread == currentThread().ident:

   171

            app = wx.GetApp()

   172

            if app is not None:

   173

                if self.YieldLock.acquire(0):

   174

                    app.Yield()

   175

                    self.YieldLock.release()

   176

   177

    def _write(self):

   178

        if self.output:

   179

            self.output.Freeze()

   180

            self.lock.acquire()

   181

            for s, style in self.stack:

   182

                if style is None:

   183

                    style = self.black_white

   184

                if style != self.black_white:

   185

                    self.output.StartStyling(self.output.GetLength(), 0xff)

   186

   187

                # Temporary deactivate read only mode on StyledTextCtrl for

   188

                # adding text. It seems that text modifications, even

   189

                # programmatically, are disabled in StyledTextCtrl when read

   190

                # only is active

   191

                start_pos = self.output.GetLength()

   192

                self.output.SetReadOnly(False)

   193

                self.output.AppendText(s)

   194

                self.output.SetReadOnly(True)

   195

                text_len = self.output.GetLength() - start_pos

   196

   197

                if style != self.black_white:

   198

                    self.output.SetStyling(text_len, style)

   199

            self.stack = []

   200

            self.lock.release()

   201

            self.output.Thaw()

   202

            self.LastRefreshTime = gettime()

   203

            try:

   204

                self.RefreshLock.release()

   205

            except Exception:

   206

                pass

   207

            newtime = time.time()

   208

            if newtime - self.rising_timer > 1:

   209

                self.risecall(self.output)

   210

            self.rising_timer = newtime

   211

   212

    def write_warning(self, s):

   213

        self.write(s, self.red_white)

   214

   215

    def write_error(self, s):

   216

        self.write(s, self.red_yellow)

   217

   218

    def writeyield(self, s):

   219

        self.write(s)

   220

        wx.GetApp().Yield()

   221

   222

    def flush(self):

   223

        # Temporary deactivate read only mode on StyledTextCtrl for clearing

   224

        # text. It seems that text modifications, even programmatically, are

   225

        # disabled in StyledTextCtrl when read only is active

   226

        self.output.SetReadOnly(False)

   227

        self.output.SetText("")

   228

        self.output.SetReadOnly(True)

   229

   230

    def isatty(self):

   231

        return False

   232

   233

   234

ID_FILEMENURECENTPROJECTS = wx.NewId()

   235

   236

   237

class Beremiz(IDEFrame):

   238

   239

    def _init_utils(self):

   240

        self.ConfNodeMenu = wx.Menu(title='')

   241

        self.RecentProjectsMenu = wx.Menu(title='')

   242

   243

        IDEFrame._init_utils(self)

   244

   245

    def _init_coll_FileMenu_Items(self, parent):

   246

        AppendMenu(parent, help='', id=wx.ID_NEW,

   247

                   kind=wx.ITEM_NORMAL, text=_(u'New') + '\tCTRL+N')

   248

        AppendMenu(parent, help='', id=wx.ID_OPEN,

   249

                   kind=wx.ITEM_NORMAL, text=_(u'Open') + '\tCTRL+O')

   250

        parent.AppendMenu(ID_FILEMENURECENTPROJECTS, _("&Recent Projects"), self.RecentProjectsMenu)

   251

        parent.AppendSeparator()

   252

        AppendMenu(parent, help='', id=wx.ID_SAVE,

   253

                   kind=wx.ITEM_NORMAL, text=_(u'Save') + '\tCTRL+S')

   254

        AppendMenu(parent, help='', id=wx.ID_SAVEAS,

   255

                   kind=wx.ITEM_NORMAL, text=_(u'Save as') + '\tCTRL+SHIFT+S')

   256

        AppendMenu(parent, help='', id=wx.ID_CLOSE,

   257

                   kind=wx.ITEM_NORMAL, text=_(u'Close Tab') + '\tCTRL+W')

   258

        AppendMenu(parent, help='', id=wx.ID_CLOSE_ALL,

   259

                   kind=wx.ITEM_NORMAL, text=_(u'Close Project') + '\tCTRL+SHIFT+W')

   260

        parent.AppendSeparator()

   261

        AppendMenu(parent, help='', id=wx.ID_PAGE_SETUP,

   262

                   kind=wx.ITEM_NORMAL, text=_(u'Page Setup') + '\tCTRL+ALT+P')

   263

        AppendMenu(parent, help='', id=wx.ID_PREVIEW,

   264

                   kind=wx.ITEM_NORMAL, text=_(u'Preview') + '\tCTRL+SHIFT+P')

   265

        AppendMenu(parent, help='', id=wx.ID_PRINT,

   266

                   kind=wx.ITEM_NORMAL, text=_(u'Print') + '\tCTRL+P')

   267

        parent.AppendSeparator()

   268

        AppendMenu(parent, help='', id=wx.ID_EXIT,

   269

                   kind=wx.ITEM_NORMAL, text=_(u'Quit') + '\tCTRL+Q')

   270

   271

        self.Bind(wx.EVT_MENU, self.OnNewProjectMenu, id=wx.ID_NEW)

   272

        self.Bind(wx.EVT_MENU, self.OnOpenProjectMenu, id=wx.ID_OPEN)

   273

        self.Bind(wx.EVT_MENU, self.OnSaveProjectMenu, id=wx.ID_SAVE)

   274

        self.Bind(wx.EVT_MENU, self.OnSaveProjectAsMenu, id=wx.ID_SAVEAS)

   275

        self.Bind(wx.EVT_MENU, self.OnCloseTabMenu, id=wx.ID_CLOSE)

   276

        self.Bind(wx.EVT_MENU, self.OnCloseProjectMenu, id=wx.ID_CLOSE_ALL)

   277

        self.Bind(wx.EVT_MENU, self.OnPageSetupMenu, id=wx.ID_PAGE_SETUP)

   278

        self.Bind(wx.EVT_MENU, self.OnPreviewMenu, id=wx.ID_PREVIEW)

   279

        self.Bind(wx.EVT_MENU, self.OnPrintMenu, id=wx.ID_PRINT)

   280

        self.Bind(wx.EVT_MENU, self.OnQuitMenu, id=wx.ID_EXIT)

   281

   282

        self.AddToMenuToolBar([(wx.ID_NEW, "new", _(u'New'), None),

   283

                               (wx.ID_OPEN, "open", _(u'Open'), None),

   284

                               (wx.ID_SAVE, "save", _(u'Save'), None),

   285

                               (wx.ID_SAVEAS, "saveas", _(u'Save As...'), None),

   286

                               (wx.ID_PRINT, "print", _(u'Print'), None)])

   287

   288

    def _RecursiveAddMenuItems(self, menu, items):

   289

        for name, text, help, children in items:

   290

            new_id = wx.NewId()

   291

            if len(children) > 0:

   292

                new_menu = wx.Menu(title='')

   293

                menu.AppendMenu(new_id, text, new_menu)

   294

                self._RecursiveAddMenuItems(new_menu, children)

   295

            else:

   296

                AppendMenu(menu, help=help, id=new_id,

   297

                           kind=wx.ITEM_NORMAL, text=text)

   298

                self.Bind(wx.EVT_MENU, self.GetAddConfNodeFunction(name),

   299

                          id=new_id)

   300

   301

    def _init_coll_AddMenu_Items(self, parent):

   302

        IDEFrame._init_coll_AddMenu_Items(self, parent, False)

   303

        self._RecursiveAddMenuItems(parent, GetAddMenuItems())

   304

   305

    def _init_coll_HelpMenu_Items(self, parent):

   306

        def handler(event):

   307

            return wx.MessageBox(

   308

                version.GetCommunityHelpMsg(),

   309

                _(u'Community support'),

   310

                wx.OK | wx.ICON_INFORMATION)

   311

   312

        id = wx.NewId()

   313

        parent.Append(help='', id=id, kind=wx.ITEM_NORMAL, text=_(u'Community support'))

   314

        self.Bind(wx.EVT_MENU, handler, id=id)

   315

   316

        parent.Append(help='', id=wx.ID_ABOUT,

   317

                      kind=wx.ITEM_NORMAL, text=_(u'About'))

   318

        self.Bind(wx.EVT_MENU, self.OnAboutMenu, id=wx.ID_ABOUT)

   319

   320

    def _init_coll_ConnectionStatusBar_Fields(self, parent):

   321

        parent.SetFieldsCount(3)

   322

   323

        parent.SetStatusText(number=0, text='')

   324

        parent.SetStatusText(number=1, text='')

   325

        parent.SetStatusText(number=2, text='')

   326

   327

        parent.SetStatusWidths([-1, 300, 200])

   328

   329

    def _init_ctrls(self, prnt):

   330

        IDEFrame._init_ctrls(self, prnt)

   331

   332

        self.EditMenuSize = self.EditMenu.GetMenuItemCount()

   333

   334

        inspectorID = wx.NewId()

   335

        self.Bind(wx.EVT_MENU, self.OnOpenWidgetInspector, id=inspectorID)

   336

        accels = [wx.AcceleratorEntry(wx.ACCEL_CTRL | wx.ACCEL_ALT, ord('I'), inspectorID)]

   337

   338

        keyID = wx.NewId()

   339

        self.Bind(wx.EVT_MENU, self.SwitchFullScrMode, id=keyID)

   340

        accels += [wx.AcceleratorEntry(wx.ACCEL_NORMAL, wx.WXK_F12, keyID)]

   341

   342

        for method, shortcut in [("Stop",     wx.WXK_F4),

   343

                                 ("Run",      wx.WXK_F5),

   344

                                 ("Transfer", wx.WXK_F6),

   345

                                 ("Connect",  wx.WXK_F7),

   346

                                 ("Build",    wx.WXK_F11)]:

   347

            def OnMethodGen(obj, meth):

   348

                def OnMethod(evt):

   349

                    if obj.CTR is not None:

   350

                        obj.CTR.CallMethod('_'+meth)

   351

                    wx.CallAfter(self.RefreshStatusToolBar)

   352

                return OnMethod

   353

            newid = wx.NewId()

   354

            self.Bind(wx.EVT_MENU, OnMethodGen(self, method), id=newid)

   355

            accels += [wx.AcceleratorEntry(wx.ACCEL_NORMAL, shortcut, newid)]

   356

   357

        self.SetAcceleratorTable(wx.AcceleratorTable(accels))

   358

   359

        self.LogConsole = CustomStyledTextCtrl(

   360

                  name='LogConsole', parent=self.BottomNoteBook, pos=wx.Point(0, 0),

   361

                  size=wx.Size(0, 0))

   362

        self.LogConsole.Bind(wx.EVT_SET_FOCUS, self.OnLogConsoleFocusChanged)

   363

        self.LogConsole.Bind(wx.EVT_KILL_FOCUS, self.OnLogConsoleFocusChanged)

   364

        self.LogConsole.Bind(wx.stc.EVT_STC_UPDATEUI, self.OnLogConsoleUpdateUI)

   365

        self.LogConsole.SetReadOnly(True)

   366

        self.LogConsole.SetWrapMode(wx.stc.STC_WRAP_CHAR)

   367

   368

        # Define Log Console styles

   369

        self.LogConsole.StyleSetSpec(wx.stc.STC_STYLE_DEFAULT, "face:%(mono)s,size:%(size)d" % faces)

   370

        self.LogConsole.StyleClearAll()

   371

        self.LogConsole.StyleSetSpec(1, "face:%(mono)s,fore:#FF0000,size:%(size)d" % faces)

   372

        self.LogConsole.StyleSetSpec(2, "face:%(mono)s,fore:#FF0000,back:#FFFF00,size:%(size)d" % faces)

   373

   374

        # Define Log Console markers

   375

        self.LogConsole.SetMarginSensitive(1, True)

   376

        self.LogConsole.SetMarginType(1, wx.stc.STC_MARGIN_SYMBOL)

   377

        self.LogConsole.MarkerDefine(0, wx.stc.STC_MARK_CIRCLE, "BLACK", "RED")

   378

   379

        self.LogConsole.SetModEventMask(wx.stc.STC_MOD_INSERTTEXT)

   380

   381

        self.LogConsole.Bind(wx.stc.EVT_STC_MARGINCLICK, self.OnLogConsoleMarginClick)

   382

        self.LogConsole.Bind(wx.stc.EVT_STC_MODIFIED, self.OnLogConsoleModified)

   383

   384

        self.MainTabs["LogConsole"] = (self.LogConsole, _("Console"))

   385

        self.BottomNoteBook.AddPage(*self.MainTabs["LogConsole"])

   386

        # self.BottomNoteBook.Split(self.BottomNoteBook.GetPageIndex(self.LogConsole), wx.RIGHT)

   387

   388

        self.LogViewer = LogViewer(self.BottomNoteBook, self)

   389

        self.MainTabs["LogViewer"] = (self.LogViewer, _("PLC Log"))

   390

        self.BottomNoteBook.AddPage(*self.MainTabs["LogViewer"])

   391

        # self.BottomNoteBook.Split(self.BottomNoteBook.GetPageIndex(self.LogViewer), wx.RIGHT)

   392

   393

        StatusToolBar = wx.ToolBar(self, -1, wx.DefaultPosition, wx.DefaultSize,

   394

                                   wx.TB_FLAT | wx.TB_NODIVIDER | wx.NO_BORDER)

   395

        StatusToolBar.SetToolBitmapSize(wx.Size(25, 25))

   396

        StatusToolBar.Realize()

   397

        self.Panes["StatusToolBar"] = StatusToolBar

   398

        self.AUIManager.AddPane(StatusToolBar, wx.aui.AuiPaneInfo().

   399

                                Name("StatusToolBar").Caption(_("Status ToolBar")).

   400

                                ToolbarPane().Top().Position(1).

   401

                                LeftDockable(False).RightDockable(False))

   402

   403

        self.AUIManager.Update()

   404

   405

        self.ConnectionStatusBar = esb.EnhancedStatusBar(self, style=wx.ST_SIZEGRIP)

   406

        self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

   407

        self.ProgressStatusBar = wx.Gauge(self.ConnectionStatusBar, -1, range=100)

   408

        self.ConnectionStatusBar.AddWidget(self.ProgressStatusBar, esb.ESB_EXACT_FIT, esb.ESB_EXACT_FIT, 2)

   409

        self.ProgressStatusBar.Hide()

   410

        self.SetStatusBar(self.ConnectionStatusBar)

   411

   412

    def __init_execute_path(self):

   413

        if os.name == 'nt':

   414

            # on windows, desktop shortcut launches Beremiz.py

   415

            # with working dir set to mingw/bin.

   416

            # then we prefix CWD to PATH in order to ensure that

   417

            # commands invoked by build process by default are

   418

            # found here.

   419

            os.environ["PATH"] = os.getcwd()+';'+os.environ["PATH"]

   420

   421

    def __init__(self, parent, projectOpen=None, buildpath=None, ctr=None, debug=True):

   422

        # Add beremiz's icon in top left corner of the frame

   423

        self.icon = wx.Icon(Bpath("images", "brz.ico"), wx.BITMAP_TYPE_ICO)

   424

        self.__init_execute_path()

   425

   426

        IDEFrame.__init__(self, parent, debug)

   427

        self.Log = LogPseudoFile(self.LogConsole, self.SelectTab)

   428

   429

        self.local_runtime = None

   430

        self.runtime_port = None

   431

        self.local_runtime_tmpdir = None

   432

   433

        self.LastPanelSelected = None

   434

   435

        # Define Tree item icon list

   436

        self.LocationImageList = wx.ImageList(16, 16)

   437

        self.LocationImageDict = {}

   438

   439

        # Icons for location items

   440

        for imgname, itemtype in [

   441

                ("CONFIGURATION", LOCATION_CONFNODE),

   442

                ("RESOURCE",      LOCATION_MODULE),

   443

                ("PROGRAM",       LOCATION_GROUP),

   444

                ("VAR_INPUT",     LOCATION_VAR_INPUT),

   445

                ("VAR_OUTPUT",    LOCATION_VAR_OUTPUT),

   446

                ("VAR_LOCAL",     LOCATION_VAR_MEMORY)]:

   447

            self.LocationImageDict[itemtype] = self.LocationImageList.Add(GetBitmap(imgname))

   448

   449

        # Icons for other items

   450

        for imgname, itemtype in [

   451

                ("Extension", ITEM_CONFNODE)]:

   452

            self.TreeImageDict[itemtype] = self.TreeImageList.Add(GetBitmap(imgname))

   453

   454

        if projectOpen is not None:

   455

            projectOpen = DecodeFileSystemPath(projectOpen, False)

   456

   457

        if projectOpen is not None and os.path.isdir(projectOpen):

   458

            self.CTR = ProjectController(self, self.Log)

   459

            self.Controler = self.CTR

   460

            result, err = self.CTR.LoadProject(projectOpen, buildpath)

   461

            if not result:

   462

                self.LibraryPanel.SetController(self.Controler)

   463

                self.ProjectTree.Enable(True)

   464

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   465

                self.RefreshConfigRecentProjects(os.path.abspath(projectOpen))

   466

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   467

            else:

   468

                self.ResetView()

   469

                self.ShowErrorMessage(result)

   470

        else:

   471

            self.CTR = ctr

   472

            self.Controler = ctr

   473

            if ctr is not None:

   474

                self.LibraryPanel.SetController(self.Controler)

   475

                self.ProjectTree.Enable(True)

   476

                self.PouInstanceVariablesPanel.SetController(self.Controler)

   477

                self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

   478

        if self.EnableDebug:

   479

            self.DebugVariablePanel.SetDataProducer(self.CTR)

   480

   481

        self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)

   482

   483

        self._Refresh(TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU)

   484

        self.RefreshAll()

   485

        self.LogConsole.SetFocus()

   486

   487

    def RefreshTitle(self):

   488

        name = _("Beremiz")

   489

        if self.CTR is not None:

   490

            projectname = self.CTR.GetProjectName()

   491

            if self.CTR.ProjectTestModified():

   492

                projectname = "~%s~" % projectname

   493

            self.SetTitle("%s - %s" % (name, projectname))

   494

        else:

   495

            self.SetTitle(name)

   496

   497

    def StartLocalRuntime(self, taskbaricon=True):

   498

        if (self.local_runtime is None) or (self.local_runtime.exitcode is not None):

   499

            # create temporary directory for runtime working directory

   500

            self.local_runtime_tmpdir = tempfile.mkdtemp()

   501

            # choose an arbitrary random port for runtime

   502

            self.runtime_port = int(random.random() * 1000) + 61131

   503

            # launch local runtime

   504

            self.local_runtime = ProcessLogger(

   505

                self.Log,

   506

                "\"%s\" \"%s\" -p %s -i localhost %s %s" % (

   507

                    sys.executable,

   508

                    Bpath("Beremiz_service.py"),

   509

                    self.runtime_port,

   510

                    {False: "-x 0", True: "-x 1"}[taskbaricon],

   511

                    self.local_runtime_tmpdir),

   512