1

# mqtt/client.py

     2

     3

from __future__ import absolute_import

     4

     5

import os

     6

import re

     7

     8

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

     9

from PLCControler import LOCATION_CONFNODE, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT

    10

from .mqtt_client_gen import MQTTClientPanel, MQTTClientModel, MQTT_IEC_types, authParams

    11

    12

import util.paths as paths

    13

    14

    15

# assumes that "build" directory was created in paho.mqtt.c source directory,

    16

# and cmake build was invoked from this directory

    17

PahoMqttCLibraryPath = paths.ThirdPartyPath("paho.mqtt.c", "build", "src")

    18

    19

frozen_path = paths.ThirdPartyPath("frozen")

    20

    21

MqttCIncludePaths = [

    22

    paths.ThirdPartyPath("paho.mqtt.c", "build"),  # VersionInfo.h

    23

    paths.ThirdPartyPath("paho.mqtt.c", "src"),

    24

    frozen_path

    25

]

    26

    27

class MQTTClientEditor(ConfTreeNodeEditor):

    28

    CONFNODEEDITOR_TABS = [

    29

        (_("MQTT Client"), "CreateMQTTClient_UI")]

    30

    33

    def Log(self, msg):

    34

        self.Controler.GetCTRoot().logger.write(msg)

    35

    36

    def CreateMQTTClient_UI(self, parent):

    38

            parent,

    39

            self.Controler.GetModelData(),

    40

            self.Log,

    41

            self.Controler.GetTypes)

    49

    50

class MQTTClient(object):

    51

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

    52

    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

    53

      <xsd:element name="MQTTClient">

    54

        <xsd:complexType>

    55

          <xsd:sequence>

    56

            <xsd:element name="AuthType" minOccurs="0">

    57

              <xsd:complexType>

    58

                <xsd:choice minOccurs="0">

    59

                  <xsd:element name="x509">

    60

                    <xsd:complexType>

    61

                      <xsd:attribute name="Client_certificate" type="xsd:string" use="optional" default="KeyStore.pem"/>

    62

                      <xsd:attribute name="Broker_certificate" type="xsd:string" use="optional" default="TrustStore.pem"/>

    63

                      <xsd:attribute name="Verify_hostname" type="xsd:boolean" use="optional" default="true"/>

    64

                    </xsd:complexType>

    65

                  </xsd:element>

    66

                  <xsd:element name="PSK">

    67

                    <xsd:complexType>

    68

                      <xsd:attribute name="Secret" type="xsd:string" use="optional" default=""/>

    69

                      <xsd:attribute name="ID" type="xsd:string" use="optional" default=""/>

    70

                    </xsd:complexType>

    71

                  </xsd:element>

    72

                  <xsd:element name="UserPassword">

    73

                    <xsd:complexType>

    74

                      <xsd:attribute name="User" type="xsd:string" use="optional"/>

    75

                      <xsd:attribute name="Password" type="xsd:string" use="optional"/>

    76

                    </xsd:complexType>

    77

                  </xsd:element>

    78

                </xsd:choice>

    79

              </xsd:complexType>

    80

            </xsd:element>

    81

          </xsd:sequence>

    82

          <xsd:attribute name="Use_MQTT_5" type="xsd:boolean" use="optional" default="true"/>

    83

          <xsd:attribute name="Broker_URI" type="xsd:string" use="optional" default="ws://localhost:1883"/>

    84

          <xsd:attribute name="Client_ID" type="xsd:string" use="optional" default=""/>

    85

        </xsd:complexType>

    86

      </xsd:element>

    87

    </xsd:schema>

    88

    """

    89

    90

    EditorType = MQTTClientEditor

    91

    92

    def __init__(self):

    93

        self.modeldata = MQTTClientModel(self.Log, self.CTNMarkModified)

    94

    95

        filepath = self.GetFileName()

    96

        if os.path.isfile(filepath):

    97

            self.modeldata.LoadCSV(filepath)

    98

    99

    def Log(self, msg):

   100

        self.GetCTRoot().logger.write(msg)

   101

   102

    def GetModelData(self):

   103

        return self.modeldata

   104

   105

    def GetTypes(self):

   106

        datatype_candidates = self.GetCTRoot().GetDataTypes()

   107

        return datatype_candidates

   108

   109

    def GetDataTypeInfos(self, typename):

   110

        tagname = "D::"+typename

   111

        return self.GetCTRoot().GetDataTypeInfos(tagname)

   112

   113

    def GetConfig(self):

   114

        def cfg(path): 

   115

            try:

   116

                attr=self.GetParamsAttributes("MQTTClient."+path)

   117

            except ValueError:

   118

                return None

   119

            return attr["value"]

   120

   121

        AuthType = cfg("AuthType")

   122

        res = dict(

   123

            URI=cfg("Broker_URI"),

   124

            AuthType=AuthType,

   125

            clientID=cfg("Client_ID"),

   126

            UseMQTT5=cfg("Use_MQTT_5"))

   127

   128

        paramList = authParams.get(AuthType, None)

   129

        if paramList:

   130

            for name,default in paramList:

   131

   132

                # Translate internal config naming into user config naming

   133

                displayed_name = {"KeyStore"   : "Client_certificate",

   134

                                  "TrustStore" : "Broker_certificate", 

   135

                                  "Verify"     : "Verify_hostname"}.get(name, name)

   136

   137

                value = cfg("AuthType." + displayed_name)

   138

                if value == "" or value is None:

   139

                    value = default

   140

   141

                if value is not None:

   142

                    # cryptomaterial is expected to be in project's user provided file directory

   143

   144

                    # User input may contain char incompatible with C string literal escaping

   145

                    if name in ["User","Password","TrustStore","KeyStore","Broker_URI","Client_ID"]:

   146

                        value = re.sub(r'([\"\\])',  r'\\\1', value)

   147

   148

                res[name] = value

   149

   150

        return res

   151

   152

    def GetFileName(self):

   153

        return os.path.join(self.CTNPath(), 'selected.csv')

   154

   155

    def OnCTNSave(self, from_project_path=None):

   156

        self.modeldata.SaveCSV(self.GetFileName())

   157

        return True

   158

   159

    def CTNGenerate_C(self, buildpath, locations):

   160

        current_location = self.GetCurrentLocation()

   161

        locstr = "_".join(map(str, current_location))

   162

        c_path = os.path.join(buildpath, "mqtt_client__%s.c" % locstr)

   163

   164

        c_code = """

   165

#include "iec_types_all.h"

   166

#include "beremiz.h"

   167

"""

   168

        config = self.GetConfig()

   169

        c_code += self.modeldata.GenerateC(c_path, locstr, config, self.GetDataTypeInfos)

   170

   171

        with open(c_path, 'w') as c_file:

   172

            c_file.write(c_code)

   173

   174

        if config["AuthType"] == "x509":

   175

            static_lib = "libpaho-mqtt3cs.a"

   176

            libs = ['-lssl', '-lcrypto']

   177

        else:

   178

            static_lib = "libpaho-mqtt3c.a"

   179

            libs = []

   180

   181

        LDFLAGS = [' "' + os.path.join(PahoMqttCLibraryPath, static_lib) + '"'] + libs

   182

   183

        CFLAGS = ' '.join(['-I"' + path + '"' for path in MqttCIncludePaths])

   184

   185

        # TODO: add frozen only if using JSON

   186

        frozen_c_path = os.path.join(frozen_path, "frozen.c")

   187

   188

        return [(c_path, CFLAGS), (frozen_c_path, CFLAGS)], LDFLAGS, True

   189

   190

    def GetVariableLocationTree(self):

   191

        current_location = self.GetCurrentLocation()

   192

        locstr = "_".join(map(str, current_location))

   193

        name = self.BaseParams.getName()

   194

   195

        entries = []

   196

        children = []

   197

   198

        for row in self.modeldata["output"]:

   199

            Topic, QoS, _Retained, iec_type, iec_number = row

   200

            entries.append((Topic, QoS, iec_type, iec_number, "Q", LOCATION_VAR_OUTPUT))

   201

   202

        for row in self.modeldata["input"]:

   203

            Topic, QoS, iec_type, iec_number = row

   204

            entries.append((Topic, QoS, iec_type, iec_number, "I", LOCATION_VAR_INPUT))

   205

   206

        for Topic, QoS, iec_type, iec_number, iec_dir_prefix, loc_type in entries:

   207

            _C_type, iec_size_prefix = MQTT_IEC_types.get(iec_type,(None,""))

   208

            c_loc_name = "__" + iec_dir_prefix + iec_size_prefix + locstr + "_" + str(iec_number)

   209

            children.append({

   210

                "name": Topic,

   211

                "type": loc_type,

   212

                "size": {"X":1, "B":8, "W":16, "D":32, "L":64, "":None}[iec_size_prefix],

   213

                "IEC_type": iec_type,

   214

                "var_name": c_loc_name,

   215

                "location": "%" + iec_dir_prefix + iec_size_prefix + ".".join([str(i) for i in current_location]) + "." + str(iec_number),

   216

                "description": "",

   217

                "children": []})

   218

   219

        return {"name": name,

   220

                "type": LOCATION_CONFNODE,

   221

                "location": ".".join([str(i) for i in current_location]) + ".x",

   222

                "children": children}

   223

   224

   225

    def CTNGlobalInstances(self):

   226

        location_str = "_".join(map(str, self.GetCurrentLocation()))

   227

        return [("MQTT_HAPPY_"+location_str, "DINT", "")]

   228

   229