1

from __future__ import print_function

     2

from __future__ import absolute_import

     3

     4

import csv

     5

import functools

     6

from threading import Thread

     7

from collections import OrderedDict as OD

     8

     9

import wx

    10

import wx.dataview as dv

    11

    12

import util.paths as paths

    13

    14

MQTT_UNSUPPORTED_types = set([

    15

    "TIME",

    16

    "DATE",

    17

    "TOD",

    18

    "DT",

    19

    "STEP",

    20

    "TRANSITION",

    21

    "ACTION",

    22

    "STRING"

    23

])

    24

    25

MQTT_IEC_types_list =[ 

    26

# IEC61131|  C  type   | sz

    27

    ("BOOL" , ("uint8_t" , "X")),

    28

    ("SINT" , ("int8_t"  , "B")),

    29

    ("USINT", ("uint8_t" , "B")),

    30

    ("BYTE" , ("uint8_t" , "X")),

    31

    ("INT"  , ("int16_t" , "W")),

    32

    ("UINT" , ("uint16_t", "W")),

    33

    ("WORD" , ("uint16_t", "W")),

    34

    ("DINT" , ("int32_t" , "D")),

    35

    ("UDINT", ("uint32_t", "D")),

    36

    ("DWORD", ("uint32_t", "D")),

    37

    ("LINT" , ("int64_t" , "L")),

    38

    ("ULINT", ("uint64_t", "L")),

    39

    ("LWORD", ("uint64_t", "L")),

    40

    ("REAL" , ("float"   , "D")),

    41

    ("LREAL", ("double"  , "L"))

    42

]

    43

MQTT_IEC_SUPPORTED_types = list(zip(*MQTT_IEC_types_list)[0])

    44

MQTT_IEC_types = dict(MQTT_IEC_types_list)

    45

    46

MQTT_JSON_SUPPORTED_types = set(MQTT_IEC_types.keys()+["STRING"])

    47

    48

"""

    49

 QoS - Quality of Service

    50

  0  : "At most one delivery"

    51

  1  : "At least one delivery"

    52

  2  : "Exactly one delivery"

    53

"""

    54

QoS_values = [0, 1, 2]

    55

    56

def boolean(v):

    57

    if v in ["False","0"]:

    58

        return False

    59

    else:

    60

        return bool(v)

    61

    62

_lstcolnames  = [ "Topic",  "QoS",  "Retained", "Type", "Location"]

    63

_lstcolwidths = [     100,     50,         100,    100,         50]

    64

_lstcoltypess = [     str,    int,     boolean,    str,        int]

    65

_lstcoldeflts = [ "a/b/c",    "1",       False, "DINT",        "0"]

    66

    67

subsublist = lambda l : l[0:2] + l[3:5]

    68

    69

lstcoldsc = {

    70

    "input" : type("",(),dict(

    71

        lstcolnames  = subsublist(_lstcolnames),

    72

        lstcolwidths = subsublist(_lstcolwidths),

    73

        lstcoltypess = subsublist(_lstcoltypess),

    74

        lstcoldeflts = subsublist(_lstcoldeflts),

    75

        Location_column = 3)),

    76

    "output" : type("",(),dict(

    77

        lstcolnames  = _lstcolnames,

    78

        lstcolwidths = _lstcolwidths,

    79

        lstcoltypess = _lstcoltypess,

    80

        lstcoldeflts = _lstcoldeflts,

    81

        Location_column = 4)),

    82

}

    83

    84

directions = ["input", "output"]

    85

    86

# expected configuration entries with internal default value

    87

authParams = {

    88

    "x509":[

    89

        ("Verify", True),

    90

        ("KeyStore", None),

    91

        ("TrustStore", None)],

    92

    "UserPassword":[

    93

        ("User", None),

    94

        ("Password", None)]}

    95

    96

class MQTTTopicListModel(dv.PyDataViewIndexListModel):

    97

    def __init__(self, data, log, direction):

    98

        dv.PyDataViewIndexListModel.__init__(self, len(data))

    99

        self.data = data

   100

        self.log = log

   101

        self.dsc = lstcoldsc[direction]

   102

   103

    def GetColumnType(self, col):

   104

        return "string"

   105

   106

    def GetValueByRow(self, row, col):

   107

        return str(self.data[row][col])

   108

   109

    # This method is called when the user edits a data item in the view.

   110

    def SetValueByRow(self, value, row, col):

   111

        expectedtype = self.dsc.lstcoltypess[col]

   112

   113

        try:

   114

            v = expectedtype(value)

   115

        except ValueError: 

   116

            self.log("String {} is invalid for type {}\n".format(value,expectedtype.__name__))

   117

            return False

   118

   119

        if col == self.dsc.lstcolnames.index("QoS") and v not in QoS_values:

   120

            self.log("{} is invalid for IdType\n".format(value))

   121

            return False

   122

   123

        line = self.data[row]

   124

        line[col] = v

   125

        self.data[row] = line

   126

        return True

   127

   128

    # Report how many columns this model provides data for.

   129

    def GetColumnCount(self):

   130

        return len(self.dsc.lstcolnames)

   131

   132

    # Report the number of rows in the model

   133

    def GetCount(self):

   134

        #self.log.write('GetCount')

   135

        return len(self.data)

   136

   137

    # Called to check if non-standard attributes should be used in the

   138

    # cell at (row, col)

   139

    def GetAttrByRow(self, row, col, attr):

   140

        if col == self.dsc.Location_column:

   141

            attr.SetColour('blue')

   142

            attr.SetBold(True)

   143

            return True

   144

        return False

   145

   146

   147

    def DeleteRows(self, rows):

   148

        # make a copy since we'll be sorting(mutating) the list

   149

        # use reverse order so the indexes don't change as we remove items

   150

        rows = sorted(rows, reverse=True)

   151

   152

        for row in rows:

   153

            # remove it from our data structure

   154

            del self.data[row]

   155

            # notify the view(s) using this model that it has been removed

   156

            self.RowDeleted(row)

   157

   158

   159

    def AddRow(self, value):

   160

        if self.data.append(value):

   161

            # notify views

   162

            self.RowAppended()

   163

   164

    def InsertDefaultRow(self, row):

   165

        self.data.insert(row, self.dsc.lstcoldeflts[:])

   166

        # notify views

   167

        self.RowInserted(row)

   168

   169

    def ResetData(self):

   170

        self.Reset(len(self.data))

   171

   172

class MQTTTopicListPanel(wx.Panel):

   173

    def __init__(self, parent, log, model, direction, types_getter):

   174

        self.log = log

   175

        wx.Panel.__init__(self, parent, -1)

   176

   177

        self.dvc = dv.DataViewCtrl(self,

   178

                                   style=wx.BORDER_THEME

   179

                                   | dv.DV_ROW_LINES

   180

                                   | dv.DV_HORIZ_RULES

   181

                                   | dv.DV_VERT_RULES

   182

                                   | dv.DV_MULTIPLE

   183

                                   )

   184

   185

        self.model = model

   186

   187

        self.dvc.AssociateModel(self.model)

   188

   189

        self.types_getter = types_getter

   190

        self.direction =  direction

   191

        self.CreateDVCColumns()

   192

   193

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

   194

   195

        titlestr = direction + " variables"

   196

   197

        title = wx.StaticText(self, label = titlestr)

   198

   199

        addbt = wx.Button(self, label="Add")

   200

        self.Bind(wx.EVT_BUTTON, self.OnAddRow, addbt)

   201

        delbt = wx.Button(self, label="Delete")

   202

        self.Bind(wx.EVT_BUTTON, self.OnDeleteRows, delbt)

   203

   204

        topsizer = wx.BoxSizer(wx.HORIZONTAL)

   205

        topsizer.Add(title, 1, wx.ALIGN_CENTER_VERTICAL|wx.LEFT|wx.RIGHT, 5)

   206

        topsizer.Add(addbt, 0, wx.LEFT|wx.RIGHT, 5)

   207

        topsizer.Add(delbt, 0, wx.LEFT|wx.RIGHT, 5)

   208

        self.Sizer.Add(topsizer, 0, wx.EXPAND|wx.TOP|wx.BOTTOM, 5)

   209

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

   210

   211

   212

    def CreateDVCColumns(self):

   213

        dsc = lstcoldsc[self.direction]

   214

        for idx,(colname,width) in enumerate(zip(dsc.lstcolnames,dsc.lstcolwidths)):

   215

            if colname == "Type":

   216

                choice_DV_render = dv.DataViewChoiceRenderer(MQTT_IEC_SUPPORTED_types + self.types_getter())

   217

                choice_DV_col = dv.DataViewColumn(colname, choice_DV_render, idx, width=width)

   218

                self.dvc.AppendColumn(choice_DV_col)

   219

            else:

   220

                self.dvc.AppendTextColumn(colname,  idx, width=width, mode=dv.DATAVIEW_CELL_EDITABLE)

   221

   222

    def ResetDVCColumns(self):

   223

        self.dvc.ClearColumns()

   224

        self.CreateDVCColumns()

   225

   226

    def OnAddRow(self, evt):

   227

        items = self.dvc.GetSelections()

   228

        row = self.model.GetRow(items[0]) if items else 0

   229

        self.model.InsertDefaultRow(row)

   230

   231

    def OnDeleteRows(self, evt):

   232

        items = self.dvc.GetSelections()

   233

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

   234

        self.model.DeleteRows(rows)

   235

   236

   237

class MQTTClientPanel(wx.SplitterWindow):

   238

    def __init__(self, parent, modeldata, log, types_getter):

   239

        self.log = log

   240

        wx.SplitterWindow.__init__(self, parent, style=wx.SUNKEN_BORDER | wx.SP_3D)

   241

   242

        self.selected_datas = modeldata

   243

        self.selected_models = { direction:MQTTTopicListModel(

   244

            self.selected_datas[direction], log, direction) for direction in directions }

   245

        self.selected_lists = { direction:MQTTTopicListPanel(

   246

                self, log, 

   247

                self.selected_models[direction], direction, types_getter) 

   248

            for direction in directions }

   249

   250

        self.SplitHorizontally(*[self.selected_lists[direction] for direction in directions]+[300])

   251

   252

        self.SetAutoLayout(True)

   253

   254

    def RefreshView(self):

   255

        for direction in directions:

   256

            self.selected_lists[direction].ResetDVCColumns()

   257

   258

    def OnClose(self):

   259

        pass

   260

   261

    def __del__(self):

   262

        self.OnClose()

   263

   264

    def Reset(self):

   265

        for direction in directions:

   266

            self.selected_models[direction].ResetData() 

   267

   268

   269

class MQTTClientList(list):

   270

    def __init__(self, log, change_callback, direction):

   271

        super(MQTTClientList, self).__init__(self)

   272

        self.log = log

   273

        self.change_callback = change_callback

   274

        self.dsc = lstcoldsc[direction]

   275

   276

    def _filter_line(self, value):

   277

        v = dict(list(zip(self.dsc.lstcolnames, value)))

   278

   279

        if type(v["Location"]) != int:

   280

            if len(self) == 0:

   281

                v["Location"] = 0

   282

            else:

   283

                iecnums = set(zip(*self)[self.dsc.Location_column])

   284

                greatest = max(iecnums)

   285

                holes = set(range(greatest)) - iecnums

   286

                v["Location"] = min(holes) if holes else greatest+1

   287

   288

        try:

   289

            for t,n in zip(self.dsc.lstcoltypess, self.dsc.lstcolnames):

   290

                v[n] = t(v[n]) 

   291

        except ValueError: 

   292

            self.log("MQTT topic {} (Location={}) has invalid type\n".format(v["Topic"],v["Location"]))

   293

            return None

   294

   295

        if v["QoS"] not in QoS_values:

   296

            self.log("Unknown QoS\n".format(value))

   297

            return None

   298

   299

        if len(self)>0 and v["Topic"] in list(zip(*self))[self.dsc.lstcolnames.index("Topic")]:

   300

            self.log("MQTT topic {} (Location={}) already in the list\n".format(v["Topic"],v["Location"]))

   301

            return None

   302

   303

        return [v[n] for n in self.dsc.lstcolnames]

   304

   305

    def insert(self, row, value):

   306

        v = self._filter_line(value)

   307

        if v is not None:

   308

            list.insert(self, row, v)

   309

            self.change_callback()

   310

            return True

   311

        return False

   312

   313

    def append(self, value):

   314

        v = self._filter_line(value)

   315

        if v is not None:

   316

            list.append(self, v)

   317

            self.change_callback()

   318

            return True

   319

        return False

   320

   321

    def __setitem__(self, index, value):

   322

        list.__setitem__(self, index, value)

   323

        self.change_callback()

   324

   325

    def __delitem__(self, index):

   326

        list.__delitem__(self, index)

   327

        self.change_callback()

   328

   329

   330

class MQTTClientModel(dict):

   331

    def __init__(self, log, change_callback = lambda : None):

   332

        super(MQTTClientModel, self).__init__()

   333

        for direction in directions:

   334

            self[direction] = MQTTClientList(log, change_callback, direction)

   335

   336

    def LoadCSV(self,path):

   337

        with open(path, 'r') as csvfile:

   338

            reader = csv.reader(csvfile, delimiter=',', quotechar='"')

   339

            buf = {direction:[] for direction, _model in self.iteritems()}

   340

            for direction, model in self.iteritems():

   341

                self[direction][:] = []

   342

            for row in reader:

   343

                direction = row[0]

   344

                # avoids calling change callback when loading CSV

   345

                l = self[direction]

   346

                v = l._filter_line(row[1:])

   347

                if v is not None:

   348

                    list.append(l,v)

   349

                # TODO be verbose in case of malformed CSV

   350

   351

    def SaveCSV(self,path):

   352

        with open(path, 'w') as csvfile:

   353

            for direction, data in self.items():

   354

                writer = csv.writer(csvfile, delimiter=',',

   355

                                quotechar='"', quoting=csv.QUOTE_MINIMAL)

   356

                for row in data:

   357

                    writer.writerow([direction] + row)

   358

   359

    def GenerateC(self, path, locstr, config, datatype_info_getter):

   360

        c_template_filepath = paths.AbsNeighbourFile(__file__, "mqtt_template.c")

   361

        c_template_file = open(c_template_filepath , 'rb')

   362

        c_template = c_template_file.read()

   363

        c_template_file.close()

   364

   365

        json_types = OD()

   366

   367

        formatdict = dict(

   368

            locstr          = locstr,

   369

            uri             = config["URI"],

   370

            clientID        = config["clientID"],

   371

            decl            = "",

   372

            topics          = "",

   373

            cleanup         = "",

   374

            init            = "",

   375

            init_pubsub     = "",

   376

            retrieve        = "",

   377

            publish         = "",

   378

            publish_changes = "",

   379

            json_decl       = ""

   380

        )

   381

   382

   383

        # Use Config's "MQTTVersion" to switch between protocol version at build time

   384

        if config["UseMQTT5"]:

   385

            formatdict["decl"] += """

   386

#define USE_MQTT_5""".format(**config)

   387

   388

        AuthType = config["AuthType"]

   389

        if AuthType == "x509":

   390

            for k in ["KeyStore","TrustStore"]:

   391

                config[k] = '"'+config[k]+'"' if config[k] else "NULL"

   392

            formatdict["init"] += """

   393

    INIT_x509({Verify:d}, {KeyStore}, {TrustStore})""".format(**config)

   394

        if AuthType == "PSK":

   395

            formatdict["init"] += """

   396

    INIT_PSK("{Secret}", "{ID}")""".format(**config)

   397

        elif AuthType == "UserPassword":

   398

            formatdict["init"] += """

   399

    INIT_UserPassword("{User}", "{Password}")""".format(**config)

   400

        else:

   401

            formatdict["init"] += """

   402

    INIT_NoAuth()"""

   403

   404

        for row in self["output"]:

   405

            Topic, QoS, _Retained, iec_type, iec_number = row

   406

            Retained = 1 if _Retained=="True" else 0

   407

            if iec_type in MQTT_IEC_types:

   408

                C_type, iec_size_prefix = MQTT_IEC_types[iec_type]

   409

                c_loc_name = "__Q" + iec_size_prefix + locstr + "_" + str(iec_number)

   410

                encoding = "SIMPLE"

   411

            elif iec_type in MQTT_UNSUPPORTED_types:

   412

                raise Exception("Type "+iec_type+" is not supported in MQTT")

   413

            else:

   414

                C_type = iec_type.upper();

   415

                c_loc_name = "__Q" + locstr + "_" + str(iec_number)

   416

                json_types.setdefault(iec_type,OD()).setdefault("OUTPUT",[]).append(c_loc_name)

   417

                encoding = "JSON"

   418

   419

   420

   421

            formatdict["decl"] += """

   422

DECL_VAR({iec_type}, {C_type}, {c_loc_name})""".format(**locals())

   423

            formatdict["init_pubsub"] += """

   424

    INIT_PUBLICATION({encoding}, {Topic}, {QoS}, {C_type}, {c_loc_name}, {Retained})""".format(**locals())

   425

            formatdict["publish"] += """

   426

        WRITE_VALUE({c_loc_name}, {C_type})""".format(**locals())

   427

            formatdict["publish_changes"] += """

   428

            PUBLISH_CHANGE({encoding}, {Topic}, {QoS}, {C_type}, {c_loc_name}, {Retained})""".format(**locals())

   429

   430

        # inputs need to be sorted for bisection search

   431

        for row in sorted(self["input"]):

   432

            Topic, QoS, iec_type, iec_number = row

   433

            if iec_type in MQTT_IEC_types:

   434

                C_type, iec_size_prefix = MQTT_IEC_types[iec_type]

   435

                c_loc_name = "__I" + iec_size_prefix + locstr + "_" + str(iec_number)

   436

                init_topic_call = "INIT_TOPIC"

   437

            elif iec_type in MQTT_UNSUPPORTED_types:

   438

                raise Exception("Type "+iec_type+" is not supported in MQTT")

   439

            else:

   440

                C_type = iec_type.upper();

   441

                c_loc_name = "__I" + locstr + "_" + str(iec_number)

   442

                init_topic_call = "INIT_JSON_TOPIC"

   443

                json_types.setdefault(iec_type,OD()).setdefault("INPUT",[]).append(c_loc_name)

   444

   445

            formatdict["decl"] += """

   446

DECL_VAR({iec_type}, {C_type}, {c_loc_name})""".format(**locals())

   447

            formatdict["topics"] += """

   448

    {init_topic_call}({Topic}, {iec_type}, {c_loc_name})""".format(**locals())

   449

            formatdict["init_pubsub"] += """

   450

    INIT_SUBSCRIPTION({Topic}, {QoS})""".format(**locals())

   451

            formatdict["retrieve"] += """

   452

        READ_VALUE({c_loc_name}, {C_type})""".format(**locals())

   453

   454

        # collect all used type with their dependencies

   455

        basetypes=[]

   456

        arrays=set()

   457

        structures=set()

   458

        already_generated_types = set()

   459

   460

        def recurseJsonTypes(datatype):

   461

            # append derivated type first so we can expect the list

   462

            # to be sorted with base types in last position

   463

            basetypes.append(datatype)

   464

            infos = datatype_info_getter(datatype)

   465

            element_type = infos["type"]

   466

            if element_type == "Structure":

   467

                structures.add(datatype)

   468

                for element in infos["elements"]:

   469

                    field_datatype = element["Type"]

   470

                    if field_datatype not in MQTT_JSON_SUPPORTED_types and\

   471

                       field_datatype not in MQTT_UNSUPPORTED_types:

   472

                        recurseJsonTypes(field_datatype)

   473

            elif element_type == "Array":

   474

                arrays.add(datatype)

   475

                item_datatype = infos["base_type"]

   476

                if item_datatype not in MQTT_JSON_SUPPORTED_types and\

   477

                   item_datatype not in MQTT_UNSUPPORTED_types:

   478

                    recurseJsonTypes(item_datatype)

   479

        def typeCategory(iec_type):

   480

            if field_iec_type in arrays:

   481

                return "ARRAY"

   482

            elif field_iec_type in structures:

   483

                return "OBJECT"

   484

            return "SIMPLE"

   485

   486

        for iec_type,_instances in json_types.items():

   487

            recurseJsonTypes(iec_type)

   488

   489

        # go backard to get most derivated type definition last

   490

        # so that CPP can always find base type deinition before

   491

        for iec_type in reversed(basetypes):

   492

            # avoid repeating type definition

   493

            if iec_type in already_generated_types:

   494

                continue

   495

            already_generated_types.add(iec_type)

   496

   497

            C_type = iec_type.upper()

   498

            json_decl = "#define TYPE_" + C_type + "(_P, _A) \\\n"

   499

   500

            infos = datatype_info_getter(iec_type)

   501

   502

            element_type = infos["type"]