from runtime.xenomai import TryPreloadXenomai

from runtime import LogMessageAndException

from runtime import PlcStatus

import util.paths as paths

reactor.registerWxApp(app)

twisted_reactor_thread_id = None

if havewx:

wx_eval_lock = Semaphore(0)

if ui_thread is not None \

and ui_thread.ident != current_id \

and (not havetwisted or (

o = type('', (object,), dict(call=(tocall, args, kwargs), res=None))

wx.CallAfter(wx_evaluator, o)

# Some extension may set 'servicename' to a computed ID or Serial Number

# instead of using commandline '-n'

if servicename is not None and PSKpath is not None:

ensurePSK(servicename, PSKpath)

runtime.CreatePLCObjectSingleton(

COL_ID, COL_URI, COL_DESC, COL_LAST = range(4)

REPLACE, REPLACE_ALL, KEEP, KEEP_ALL, CANCEL = range(5)

def _pskpath(project_path):

return os.path.join(project_path, 'psk')

def _mgtpath(project_path):

return os.path.join(_pskpath(project_path), 'management.json')

def _ensurePSKdir(project_path):

pskpath = _pskpath(project_path)

if not os.path.exists(pskpath):

os.mkdir(pskpath)

return pskpath

def _default(ID):

return [ID,

None] # last connection date

def _dataByID(data):

def _LoadData(project_path):

""" load known keys metadata """

return json.loads(open(_path).read())

return []

def _filterData(psk_files, data_input):

input_by_ID = _dataByID(data_input)

output = []

# this implicitly filters IDs out of metadata who's

# secret is missing

for filename in psk_files:

return output

def GetData(project_path):

loaded_data = _LoadData(project_path)

if loaded_data:

return _filterData(psk_files, loaded_data)

return []

def DeleteID(project_path, ID):

secret_path = os.path.join(_pskpath(project_path), ID+'.secret')

os.remove(secret_path)

def SaveData(project_path, data):

_ensurePSKdir(project_path)

with open(_mgtpath(project_path), 'w') as f:

f.write(json.dumps(data))

def UpdateID(project_path, ID, secret, URI):

pskpath = _ensurePSKdir(project_path)

if not os.path.exists(pskpath):

_is_new_ID = dataForID is None

if _is_new_ID:

dataForID[COL_URI] = URI

# then date display could be smarter, etc - sortable sting hack for now

dataForID[COL_LAST] = time.strftime('%y/%M/%d-%H:%M:%S')

SaveData(project_path, data)

def ExportIDs(project_path, export_zip):

with ZipFile(export_zip, 'w') as zf:

path = _pskpath(project_path)

if nm.endswith('.secret') or nm == 'management.json':

zf.write(os.path.join(path, nm), nm)

def ImportIDs(project_path, import_zip, should_I_replace_callback):

zf = ZipFile(import_zip, 'r')

data = GetData(project_path)

if result == CANCEL:

return

if result in [REPLACE_ALL, REPLACE]:

# replace with imported

existing_row[:] = imported_row

# copy the key of selected

keys_to_import.append(ID)

for ID in keys_to_import:

zf.extract(ID+".secret", _pskpath(project_path))

SaveData(project_path, data)

return data

self._SetConnector(connectors.ConnectorFactory(uri, self))

except Exception as e:

self.logger.write_error(

# Did connection success ?

if self._connector is None:

if self._connector is None:

return

builder = self.GetBuilder()

return

MD5 = builder.GetBinaryMD5()

if MD5 is None:

self.logger.write_error(_("Fatal : cannot get builder.\n"))

return False

MD5 = builder.GetBinaryMD5()

# Check if md5 file is empty : ask user to build PLC

for name in os.listdir(extrafilespath):

extrafiles.append((

self._connector.BlobFromFile(

# use file name as a seed to avoid collisions

# with files having same content

# Send PLC on target

object_path = builder.GetBinaryPath()

# See COPYING file for copyrights details.

import md5

class ConnectorBase(object):

chuncksize = 1024*1024

def BlobFromFile(self, filepath, seed):

s = md5.new()

s.update(seed)

blobID = self.SeedBlob(seed)

with open(filepath, "rb") as f:

while blobID == s.digest():

blobID = self.AppendChunkToBlob(chunk, blobID)

s.update(chunk)

import ssl

import Pyro

from Pyro.core import PyroURI

from Pyro.errors import ConnectionDeniedError, ProtocolError

from Pyro.util import Log

# The TLS-PSK adapter that handles SSL connections instead of regular sockets,

# but using Pre Shared Keys instead of Certificates

#

# This is essentialy the same as in Pyro/protocol.py

# only raw_sock wrapping into sock through sslpsk.wrap_socket was added

# Pyro unfortunately doesn't allow cleaner customization

with self.lock: # only 1 thread at a time can bind the URI

try:

# This are the statements that differ from Pyro/protocol.py

raw_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

_connect_socket(raw_sock, URI.address, URI.port, self.timeout)

sock = sslpsk.wrap_socket(

raw_sock, psk=Pyro.config.PYROPSK, server_side=False,

ssl_version=ssl.PROTOCOL_TLSv1)

# receive the authentication challenge string, and use that to build the actual identification string.

try:

# check if we were denied

raise ConnectionDeniedError(Pyro.constants.deniedReasons[int(x.partialMsg[-1])])

else:

raise

# reply with our ident token, generated from the ident passphrase and the challenge

try:

raise ConnectionDeniedError(Pyro.constants.deniedReasons[int(msg[-1])])

raise ConnectionDeniedError('invalid response')

except socket.error:

raise ProtocolError('connection failed')

_getProtocolAdapter = Pyro.protocol.getProtocolAdapter

def getProtocolAdapter(protocol):

if protocol in ('PYROPSK', 'PYROLOCPSK'):

return PYROPSKAdapter()

return _getProtocolAdapter(protocol)

Pyro.protocol.getProtocolAdapter = getProtocolAdapter

_processStringURI = Pyro.core.processStringURI

def processStringURI(URI):

if x:

if port:

else:

return _processStringURI(URI)

Pyro.core.processStringURI = processStringURI

scheme, location = uri.split("://")

if scheme == "PYROS":

import connectors.PYRO.PSK_Adapter

schemename = "PYROLOCPSK"

# load PSK from project

secpath = os.path.join(str(confnodesroot.ProjectPath), 'psk', ID+'.secret')

if not os.path.exists(secpath):

# Try to get the proxy object

try:

RemotePLCObjectProxy = Pyro.core.getAttrProxyForURI(schemename + "://" + location + "/PLCObject")

return None

RemotePLCObjectProxy.adapter.setTimeout(60)

if IDPSK is None:

confnodesroot.logger.write_warning(_("PLC did not provide identity and security infomation.\n"))

else:

PSK.UpdateID(confnodesroot.ProjectPath, ID, secret, uri)

_special_return_funcs = {

"StartPLC": False,

"GetTraceVariables": (PlcStatus.Broken, None),

from connectors.SchemeEditor import SchemeEditor

# (scheme, model, secure)

models = [("LOCAL", [], False), ("PYRO", model, False), ("PYROS", model, True)]

Schemes = list(zip(*models)[0])

class PYRO_dialog(SchemeEditor):

def __init__(self, scheme, *args, **kwargs):

# ID selector is enabled only on PYROS (secure)

self.model, self.EnableIDSelector = _PerSchemeConf[scheme]

SchemeEditor.__init__(self, scheme, *args, **kwargs)

def SetLoc(self, loc):

self.SetFields(locals())

def GetLoc(self):

fields = self.GetFields()

template = "{host}"

if fields['port']:

if fields['ID']:

return template.format(**fields)

return ''

from __future__ import absolute_import

from functools import partial

import wx

from controls.IDBrowser import IDBrowser

class SchemeEditor(wx.Panel):

def __init__(self, scheme, parent, *args, **kwargs):

wx.Panel.__init__(self, parent, *args, **kwargs)

self.fieldsizer = wx.FlexGridSizer(cols=2, hgap=10, vgap=10)

txtctrl = wx.TextCtrl(parent=self, size=wx.Size(200, -1))

self.txtctrls[tag] = txtctrl

for win, flag in [

self.fieldsizer.AddWindow(win, flag=flag)

self.fieldsizer.AddSpacer(20)

self.SetSizer(self.fieldsizer)

def SetFields(self, fields):

self.txtctrls[tag].SetValue(fields[tag])

def GetFields(self):

return WampPLCObjectProxy

WAMP_connector_factory = partial(_WAMP_connector_factory, WampSession)

from __future__ import absolute_import

from itertools import repeat, islice, chain

from connectors.SchemeEditor import SchemeEditor

Schemes = ["WAMP", "WAMPS"]

class WAMP_dialog(SchemeEditor):

def __init__(self, *args, **kwargs):

self.EnableIDSelector = True

SchemeEditor.__init__(self, *args, **kwargs)

def SetLoc(self, loc):

self.SetFields(locals())

def GetLoc(self):

fields = self.GetFields()

template = "{host}" + \

(":{port}" if fields['port'] else '') +\

"#{realm}#{ID}"

return template.format(**fields)

from connectors.ConnectorBase import ConnectorBase

from types import ClassType

def _GetLocalConnectorClassFactory(name):

_dialogs_imported = False

per_URI_connectors = None

# lazy import of connectors dialogs, only if used

def _Import_Dialogs():

global per_URI_connectors, schemes, _dialogs_imported

_dialogs_imported = True

per_URI_connectors = {}

schemes = []

for con_name in connectors_packages:

for scheme in module.Schemes:

per_URI_connectors[scheme] = getattr(module, con_name + '_dialog')

return None

# import module according to uri type and get connector specific baseclass

# then call with parameters to create the class

connector_specific_class = connectors[scheme]()(uri, confnodesroot)

if connector_specific_class is None:

return None

# new class inheriting from generic and specific connector base classes

(ConnectorBase, connector_specific_class), {})()

def EditorClassFromScheme(scheme):

_Import_Dialogs()

def ConnectorSchemes():

_Import_Dialogs()

import wx

import wx.lib.mixins.listctrl as listmix

from zeroconf import ServiceBrowser, Zeroconf, get_all_addresses

service_type = '_Beremiz._tcp.local.'

wx.ListCtrl.__init__(self, parent, id, pos, size, style, name=name)

listmix.ListCtrlAutoWidthMixin.__init__(self)

class DiscoveryPanel(wx.Panel, listmix.ColumnSorterMixin):

def _init_coll_MainSizer_Items(self, parent):

self.IfacesMonitorState = None

self.IfacesMonitorTimer = wx.Timer(self)

self.IfacesMonitorTimer.Start(2000)

def __del__(self):

self.IfacesMonitorTimer.Stop()

def IfacesMonitor(self, event):

NewState = get_all_addresses(socket.AF_INET)

if self.IfacesMonitorState is not None:

# refresh only if a new address appeared

for addr in NewState:

if self.LatestSelection is not None:

# if self.ByIPCheck.IsChecked():

svcname, scheme, host, port = \

range(4))

return ("%s://%s:%s#%s" % (scheme, host, port, svcname)) \

if scheme[-1] == "S" \

# See COPYING file for copyrights details.

from __future__ import absolute_import

import wx

import wx.dataview as dv

import PSKManagement as PSK

from PSKManagement import *

from dialogs.IDMergeDialog import IDMergeDialog

class IDBrowserModel(dv.PyDataViewIndexListModel):

def __init__(self, project_path, columncount):

self.project_path = project_path

def GetCount(self):

return len(self.data)

def Compare(self, item1, item2, col, ascending):

item2, item1 = item1, item2

row1 = self.GetRow(item1)

row2 = self.GetRow(item2)

def DeleteRows(self, rows):

rows = list(rows)

rows.sort(reverse=True)

for row in rows:

PSK.DeleteID(self.project_path, self.data[row][COL_ID])

del self.data[row]

self.RowDeleted(row)

self._saveData()

def AddRow(self, value):

self.data.append(value)

self.RowAppended()

data = PSK.ImportIDs(self.project_path, filepath, sircb)

if data is not None:

self.data = data

def Export(self, filepath):

PSK.ExportIDs(self.project_path, filepath)

class IDBrowser(wx.Panel):

def __init__(self, parent, ctr, SelectURICallBack=None, SelectIDCallBack=None, **kwargs):

wx.Panel.__init__(self, parent, -1, size=(800 if big else 450,

600 if big else 200))

self.SelectIDCallBack = SelectIDCallBack

dvStyle = wx.BORDER_THEME | dv.DV_ROW_LINES

# no multiple selection in selector mode

dvStyle |= dv.DV_MULTIPLE

ColumnsDesc = [

]

self.model = IDBrowserModel(ctr.ProjectPath, len(ColumnsDesc))

self.dvc.AssociateModel(self.model)

col_list = []

col_list.append(

col_list[COL_LAST].SetSortOrder(False)

# TODO : sort by last bvisit by default

self.Sizer.Add(self.dvc, 1, wx.EXPAND)

btnbox = wx.BoxSizer(wx.HORIZONTAL)

# deletion of secret and metadata

deleteButton = wx.Button(self, label=_("Delete ID"))

self.Bind(wx.EVT_BUTTON, self.OnDeleteButton, deleteButton)

# export all

exportButton = wx.Button(self, label=_("Export all"))

self.Bind(wx.EVT_BUTTON, self.OnExportButton, exportButton)

# import with a merge -> duplicates are asked for

importButton = wx.Button(self, label=_("Import"))

self.Bind(wx.EVT_BUTTON, self.OnImportButton, importButton)

# selector mode

self.useURIButton = wx.Button(self, label=_("Use last URI"))

self.Bind(wx.EVT_BUTTON, self.OnUseURIButton, self.useURIButton)

self.useURIButton.Disable()

self.Bind(dv.EVT_DATAVIEW_SELECTION_CHANGED, self.OnSelectionChanged, self.dvc)

def OnDeleteButton(self, evt):

items = self.dvc.GetSelections()

rows = [self.model.GetRow(item) for item in items]

# Ask if user really wants to delete

if wx.MessageBox(_('Are you sure to delete selected IDs?'),

_('Delete IDs'),

return

self.model.DeleteRows(rows)

def OnSelectionChanged(self, evt):

items = self.dvc.GetSelections()

somethingSelected = len(items) > 0

self.useURIButton.Enable(somethingSelected)

ID = self.model.GetValueByRow(row, COL_ID)

self.SelectIDCallBack(ID)

def OnUseURIButton(self, evt):

row = self.model.GetRow(self.dvc.GetSelections()[0])

URI = self.model.GetValueByRow(row, COL_URI)

def OnExportButton(self, evt):

dialog = wx.FileDialog(self, _("Choose a file"),

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

self.model.Export(dialog.GetPath())

(_("Replace information for ID {ID} ?") + "\n\n" +

_("Existing:") + "\n " +

_("Description:") + " {DESC}\n " +

_("Last known URI:") + " {_URI}\n " +

_("Last connection:") + " {_LAST}\n").format(**locals()),

_("Do the same for following IDs"),

if answer == wx.ID_CANCEL:

return CANCEL

def OnImportButton(self, evt):

dialog = wx.FileDialog(self, _("Choose a file"),

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

self.model.Import(dialog.GetPath(),

self.ShouldIReplaceCallback)

from controls.LogViewer import LogViewer

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

from controls.CustomToolTip import CustomToolTip

from __future__ import absolute_import

import wx

from controls.IDBrowser import IDBrowser

class IDManager(wx.Dialog):

def __init__(self, parent, ctr):

self.ctr = ctr

name='IDManager', parent=parent,

title=_('URI Editor'),

style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER,

# start IDBrowser in manager mode

self.browser = IDBrowser(self, ctr)

self.Bind(wx.EVT_CHAR_HOOK, self.OnEscapeKey)

self.EndModal(wx.ID_CANCEL)

else:

event.Skip()

from __future__ import absolute_import

import wx

class IDMergeDialog(wx.Dialog):

def __init__(self, parent, title, question, optiontext, button_texts):

wx.Dialog.__init__(self, parent, title=title)

message = wx.StaticText(self, label=question)

main_sizer.AddWindow(message, border=20,

self.check = wx.CheckBox(self, label=optiontext)

main_sizer.AddWindow(self.check, border=20,

flag=wx.LEFT | wx.RIGHT | wx.BOTTOM | wx.ALIGN_CENTER_HORIZONTAL)

buttons_sizer = wx.BoxSizer(wx.HORIZONTAL)

Button = wx.Button(self, label=label)

def OnButtonFactory(_wxID):

return lambda event: self.EndModal(_wxID)

self.Bind(wx.EVT_BUTTON, OnButtonFactory(wxID), Button)

buttons_sizer.AddWindow(Button)

from connectors import ConnectorSchemes, EditorClassFromScheme

from controls.DiscoveryPanel import DiscoveryPanel

class UriEditor(wx.Dialog):

def _init_ctrls(self, parent):

self.UriTypeChoice = wx.Choice(parent=self, choices=self.choices)

self.mainSizer = wx.BoxSizer(wx.VERTICAL)

typeSizer = wx.BoxSizer(wx.HORIZONTAL)

typeSizer.Add(wx.StaticText(self, wx.ID_ANY, _("Scheme :")), border=5,

typeSizer.Add(self.UriTypeChoice, border=5, flag=wx.ALL)

self.mainSizer.Add(typeSizer)

def SetURI(self, uri):

try:

scheme = scheme.upper()

scheme = None

if scheme in ConnectorSchemes():

if scheme is not None:

self.scheme_editor.SetLoc(loc)

def GetURI(self):

if self.scheme is None:

return self.scheme_editor.GetURI()

def _replaceSchemeEditor(self, scheme):

self.scheme = scheme

if self.scheme_editor is not None:

self.editor_sizer.Detach(self.scheme_editor)

self.scheme_editor.Destroy()

self.scheme_editor = None

EditorClass = EditorClassFromScheme(scheme)

# None is for searching local network

self.editor_sizer.Add(self.scheme_editor)

self.scheme_editor.Refresh()

self.editor_sizer.Layout()

self.mainSizer.Layout()

self.Fit()

from dialogs.BrowseValuesLibraryDialog import BrowseValuesLibraryDialog

from dialogs.UriEditor import UriEditor

from dialogs.IDManager import IDManager

import traceback

from time import time

import _ctypes # pylint: disable=wrong-import-order

from past.builtins import execfile

import md5

from tempfile import mkstemp

import shutil

from runtime.typemapping import TypeTranslator

from runtime.loglevels import LogLevelsDefault, LogLevelsCount

class PLCObject(object):

def __init__(self, WorkingDir, argv, statuschange, evaluator, pyruntimevars):

self.tmpdir = os.path.join(WorkingDir, 'tmp')

if os.path.exists(self.tmpdir):

shutil.rmtree(self.tmpdir)

@RunInMain

def GetPLCID(self):

def _init_blobs(self):

self.blobs = {}

if os.path.exists(self.tmpdir):

shutil.rmtree(self.tmpdir)

os.mkdir(self.tmpdir)

@RunInMain

def SeedBlob(self, seed):

blob = (mkstemp(dir=self.tmpdir) + (md5.new(),))

md5sum.update(seed)

newBlobID = md5sum.digest()

self.blobs[newBlobID] = blob

if blob is None:

return None

md5sum.update(data)

newBlobID = md5sum.digest()

self.blobs[newBlobID] = blob

return newBlobID

@RunInMain

def PurgeBlobs(self):

self._init_blobs()

def _BlobAsFile(self, blobID, newpath):

if blob is None:

raise Exception(_("Missing data to create file: {}").format(newpath))

os.close(fobj)

shutil.move(path, newpath)

@RunInMain

def NewPLC(self, md5sum, plc_object, extrafiles):

if self.PLCStatus in [PlcStatus.Stopped, PlcStatus.Empty, PlcStatus.Broken]:

@RunInMain

def GetTraceVariables(self, DebugToken):

return self.PLCStatus, self._TracesSwap()

return PlcStatus.Broken, []

sys.stdout.flush()

def PyroLoop(self, when_ready):

while self.continueloop:

Pyro.config.PYRO_MULTITHREADED = 0

pyro.initServer()

service_type = '_Beremiz._tcp.local.'

class ServicePublisher(object):

def __init__(self, protocol):

# type: fully qualified service type name

if ip == "0.0.0.0":

print("MDNS brodcasted on all interfaces")

ip = self.gethostaddr()

else:

self.server = zeroconf.Zeroconf(interfaces=interfaces)

print("MDNS brodcasted service address :" + ip)

self.ip_32b = socket.inet_aton(ip)

import os

from binascii import b2a_hqx

try:

except ImportError:

from subprocess import call

_PSKpath = None

def PSKgen(ID, PSKpath):

# b2a_hqx output len is 4/3 input len

secretstring = b2a_hqx(secret)

PSKstring = ID+":"+secretstring

f.write(PSKstring)

call(restart_stunnel_cmdline)

def ensurePSK(ID, PSKpath):

global _PSKpath

_PSKpath = PSKpath

# create if needed

PSKgen(ID, PSKpath)

if not os.path.exists(_PSKpath):

'Error: Pre-Shared-Key Secret in %s is missing!\n' % _PSKpath)

return None

PSK = PSK.rstrip('\n\r')

return None

from __future__ import absolute_import

import sys

import thread

from threading import Lock, Condition

class job(object):

# subset of subprocess built-in module using posix_spawn rather than fork.

import os

import signal

PIPE = "42"

class Popen(object):

self.returncode = None

self.stdout = None

self.stdin = None

def _wait(self):

if self.returncode is None:

def communicate(self):

if self.stdin is not None:

stdoutdata = self.stdout.read()

else:

stdoutdata = ""

# TODO

stderrdata = ""

if self.stdout is not None:

self.stdout.close()

self.stdout = None

return (stdoutdata, stderrdata)

def wait(self):

def poll(self):

if self.returncode is None:

pid, ret = os.waitpid(self.pid, os.WNOHANG)

self.returncode = ret

if self.stdin is not None:

self.stdout = None

return self.returncode

def kill(self):

os.kill(self.pid, signal.SIGKILL)

self.stdout.close()

self.stdout = None

def call(*args):

cmd = []

if isinstance(args[0], str):

# oversimplified splitting of arguments,

# TODO: care about use of simple and double quotes

cmd = args[0].split()

else:

cmd = args

cmd = args[0]

else:

raise Exception("Wrong arguments passed to subprocess.call")

pid = posix_spawn.posix_spawnp(cmd[0], cmd)

if __name__ == '__main__':

# unit test

p = Popen(["tr", "abc", "def"], stdin=PIPE, stdout=PIPE)

p.stdin.write("blah")

p.stdin.close()

p.wait()

p = Popen(["tr", "abc", "def"], stdin=PIPE, stdout=PIPE)

p.stdin.write("blah")

call("echo blah0")

call(["echo", "blah1"])

[x["name"] for x in main_frames]) if len(main_frames) > 0 else "")

declare_hmi = \

def OnCloseFrame(evt):

wx.MessageBox(_("Please stop PLC to close"))

def InitHMI():

%(name)s = %(class)s(None)

%(name)s.Bind(wx.EVT_CLOSE, OnCloseFrame)

%(name)s.Show()

""" % x for x in main_frames]) + """\

def CleanupHMI():

%(name)s.Destroy()

""" % x for x in main_frames])