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

# from perfect_hash import generate_code, IntSaltHash

    15

    16

MQTT_IEC_types = dict(

    17

# IEC61131|  C  type   | sz

    30

)

    31

    32

"""

    33

 QoS - Quality of Service

    34

  0  : "At most one delivery"

    35

  1  : "At least one delivery"

    36

  2  : "Exactly one delivery"

    37

"""

    38

QoS_values = [0, 1, 2]

    39

    40

def boolean(v):

    41

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

    42

        return False

    43

    else:

    44

        return bool(v)

    45

    46

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

    47

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

    48

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

    49

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

    50

    51

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

    52

    53

lstcoldsc = {

    54

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

    55

        lstcolnames  = subsublist(_lstcolnames),

    56

        lstcolwidths = subsublist(_lstcolwidths),

    57

        lstcoltypess = subsublist(_lstcoltypess),

    58

        lstcoldeflts = subsublist(_lstcoldeflts),

    59

        Location_column = 3)),

    60

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

    61

        lstcolnames  = _lstcolnames,

    62

        lstcolwidths = _lstcolwidths,

    63

        lstcoltypess = _lstcoltypess,

    64

        lstcoldeflts = _lstcoldeflts,

    65

        Location_column = 4)),

    66

}

    67

    68

directions = ["input", "output"]

    69

    70

# expected configuration entries with internal default value

    71

authParams = {

    72

    "x509":[

    73

        ("Verify", True),

    74

        ("KeyStore", None),

    75

        ("TrustStore", None)],

    76

    "UserPassword":[

    77

        ("User", None),

    78

        ("Password", None)]}

    79

    80

class MQTTTopicListModel(dv.PyDataViewIndexListModel):

    81

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

    82

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

    83

        self.data = data

    84

        self.log = log

    85

        self.dsc = lstcoldsc[direction]

    86

    87

    def GetColumnType(self, col):

    88

        return "string"

    89

    90

    def GetValueByRow(self, row, col):

    91

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

    92

    93

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

    94

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

    95

        expectedtype = self.dsc.lstcoltypess[col]

    96

    97

        try:

    98

            v = expectedtype(value)

    99

        except ValueError: 

   100

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

   101

            return False

   102

   103

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

   104

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

   105

            return False

   106

   107

        line = self.data[row]

   108

        line[col] = v

   109

        self.data[row] = line

   110

        return True

   111

   112

    # Report how many columns this model provides data for.

   113

    def GetColumnCount(self):

   114

        return len(self.dsc.lstcolnames)

   115

   116

    # Report the number of rows in the model

   117

    def GetCount(self):

   118

        #self.log.write('GetCount')

   119

        return len(self.data)

   120

   121

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

   122

    # cell at (row, col)

   123

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

   124

        if col == self.dsc.Location_column:

   125

            attr.SetColour('blue')

   126

            attr.SetBold(True)

   127

            return True

   128

        return False

   129

   130

   131

    def DeleteRows(self, rows):

   132

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

   133

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

   134

        rows = sorted(rows, reverse=True)

   135

   136

        for row in rows:

   137

            # remove it from our data structure

   138

            del self.data[row]

   139

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

   140

            self.RowDeleted(row)

   141

   142

   143

    def AddRow(self, value):

   144

        if self.data.append(value):

   145

            # notify views

   146

            self.RowAppended()

   147

   148

    def InsertDefaultRow(self, row):

   149

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

   150

        # notify views

   151

        self.RowInserted(row)

   152

   153

    def ResetData(self):

   154

        self.Reset(len(self.data))

   155

   156

class MQTTTopicListPanel(wx.Panel):

   157

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

   158

        self.log = log

   159

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

   160

   161

        self.dvc = dv.DataViewCtrl(self,

   162

                                   style=wx.BORDER_THEME

   163

                                   | dv.DV_ROW_LINES

   164

                                   | dv.DV_HORIZ_RULES

   165

                                   | dv.DV_VERT_RULES

   166

                                   | dv.DV_MULTIPLE

   167

                                   )

   168

   169

        self.model = model

   170

   171

        self.dvc.AssociateModel(self.model)

   172

   173

        self.types_getter = types_getter

   174

        self.direction =  direction

   175

        self.CreateDVCColumns()

   176

   177

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

   178

   179

        titlestr = direction + " variables"

   180

   181

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

   182

   183

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

   184

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

   185

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

   186

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

   187

   188

        topsizer = wx.BoxSizer(wx.HORIZONTAL)

   189

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

   190

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

   191

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

   192

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

   193

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

   194

   195

   196

    def CreateDVCColumns(self):

   197

        dsc = lstcoldsc[self.direction]

   198

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

   199

            if colname == "Type":

   200

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

   201

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

   202

                self.dvc.AppendColumn(choice_DV_col)

   203

            else:

   204

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

   205

   206

    def ResetDVCColumns(self):

   207

        self.dvc.ClearColumns()

   208

        self.CreateDVCColumns()

   209

   210

    def OnAddRow(self, evt):

   211

        items = self.dvc.GetSelections()

   212

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

   213

        self.model.InsertDefaultRow(row)

   214

   215

    def OnDeleteRows(self, evt):

   216

        items = self.dvc.GetSelections()

   217

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

   218

        self.model.DeleteRows(rows)

   219

   220

   221

class MQTTClientPanel(wx.SplitterWindow):

   222

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

   223

        self.log = log

   224

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

   225

   226

        self.selected_datas = modeldata

   227

        self.selected_models = { direction:MQTTTopicListModel(

   228

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

   229

        self.selected_lists = { direction:MQTTTopicListPanel(

   230

                self, log, 

   231

                self.selected_models[direction], direction, types_getter) 

   232

            for direction in directions }

   233

   234

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

   235

   236

        self.SetAutoLayout(True)

   237

   238

    def RefreshView(self):

   239

        for direction in directions:

   240

            self.selected_lists[direction].ResetDVCColumns()

   241

   242

    def OnClose(self):

   243

        pass

   244

   245

    def __del__(self):

   246

        self.OnClose()

   247

   248

    def Reset(self):

   249

        for direction in directions:

   250

            self.selected_models[direction].ResetData() 

   251

   252

   253

class MQTTClientList(list):

   254

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

   255

        super(MQTTClientList, self).__init__(self)

   256

        self.log = log

   257

        self.change_callback = change_callback

   258

        self.dsc = lstcoldsc[direction]

   259

   260

    def _filter_line(self, value):

   261

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

   262

   263

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

   264

            if len(self) == 0:

   265

                v["Location"] = 0

   266

            else:

   267

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

   268

                greatest = max(iecnums)

   269

                holes = set(range(greatest)) - iecnums

   270

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

   271

   272

        try:

   273

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

   274

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

   275

        except ValueError: 

   276

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

   277

            return None

   278

   279

        if v["QoS"] not in QoS_values:

   280

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

   281

            return None

   282

   283

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

   284

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

   285

            return None

   286

   287

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

   288

   289

    def insert(self, row, value):

   290

        v = self._filter_line(value)

   291

        if v is not None:

   292

            list.insert(self, row, v)

   293

            self.change_callback()

   294

            return True

   295

        return False

   296

   297

    def append(self, value):

   298

        v = self._filter_line(value)

   299

        if v is not None:

   300

            list.append(self, v)

   301

            self.change_callback()

   302

            return True

   303

        return False

   304

   305

    def __setitem__(self, index, value):

   306

        list.__setitem__(self, index, value)

   307

        self.change_callback()

   308

   309

    def __delitem__(self, index):

   310

        list.__delitem__(self, index)

   311

        self.change_callback()

   312

   313

   314

class MQTTClientModel(dict):

   315

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

   316

        super(MQTTClientModel, self).__init__()

   317

        for direction in directions:

   318

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

   319

   320

    def LoadCSV(self,path):

   321

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

   322

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

   323

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

   324

            for direction, model in self.iteritems():

   325

                self[direction][:] = []

   326

            for row in reader:

   327

                direction = row[0]

   328

                # avoids calling change callback when loading CSV

   329

                l = self[direction]

   330

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

   331

                if v is not None:

   332

                    list.append(l,v)

   333

                # TODO be verbose in case of malformed CSV

   334

   335

    def SaveCSV(self,path):

   336

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

   337

            for direction, data in self.items():

   338

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

   339

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

   340

                for row in data:

   341

                    writer.writerow([direction] + row)

   342

   343

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

   344

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

   345

        c_template_file = open(c_template_filepath , 'rb')

   346

        c_template = c_template_file.read()

   347

        c_template_file.close()

   348

   349

        json_types = OD()

   350

   351

        formatdict = dict(

   352

            locstr          = locstr,

   353

            uri             = config["URI"],

   354

            clientID        = config["clientID"],

   355

            decl            = "",

   356

            topics          = "",

   357

            cleanup         = "",

   358

            init            = "",

   359

            init_pubsub     = "",

   360

            retrieve        = "",

   361

            publish         = "",

   362

            publish_changes = "",

   363

            json_decl       = ""

   364

        )

   365

   366

   367

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

   368

        if config["UseMQTT5"]:

   369

            formatdict["decl"] += """

   370

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

   371

   372

        AuthType = config["AuthType"]

   373

        if AuthType == "x509":

   374

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

   375

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

   376

            formatdict["init"] += """

   377

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

   378

        if AuthType == "PSK":

   379

            formatdict["init"] += """

   380

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

   381

        elif AuthType == "UserPassword":

   382

            formatdict["init"] += """

   383

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

   384

        else:

   385

            formatdict["init"] += """

   386

    INIT_NoAuth()"""

   387

   388

        for row in self["output"]:

   389

            Topic, QoS, _Retained, iec_type, iec_number = row

   390

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

   391

            if iec_type in MQTT_IEC_types:

   392

                C_type, iec_size_prefix = MQTT_IEC_types[iec_type]

   393

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

   394

                encoding = "SIMPLE"

   395

            else:

   396

                C_type = iec_type.upper();

   397

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

   398

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

   399

                encoding = "JSON"

   400

   401

   402

            formatdict["decl"] += """

   403

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

   404

            formatdict["init_pubsub"] += """

   405

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

   406

            formatdict["publish"] += """

   407

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

   408

            formatdict["publish_changes"] += """

   409

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

   410

   411

        # inputs need to be sorted for bisection search

   412

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

   413

            Topic, QoS, iec_type, iec_number = row

   414

            if iec_type in MQTT_IEC_types:

   415

                C_type, iec_size_prefix = MQTT_IEC_types[iec_type]

   416

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

   417

                init_topic_call = "INIT_TOPIC"

   418

            else:

   419

                C_type = iec_type.upper();

   420

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

   421

                init_topic_call = "INIT_JSON_TOPIC"

   422

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

   423

   424

            formatdict["decl"] += """

   425

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

   426

            formatdict["topics"] += """

   427

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

   428

            formatdict["init_pubsub"] += """

   429

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

   430

            formatdict["retrieve"] += """

   431

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

   432

   433

        def recurseJsonTypes(datatype, basetypes):

   434

            basetypes.append(datatype)

   435

            # add derivated type first fo we can expect the list to be sorted

   436

            # with base types in last position

   437

            infos = datatype_info_getter(datatype)

   438

            for element in infos["elements"]:

   439

                field_datatype = element["Type"]

   440

                if field_datatype not in MQTT_IEC_types:

   441

                    recurseJsonTypes(field_datatype, basetypes)

   442

   443

        print(json_types)

   444

   445

        # collect all type dependencies

   446

        basetypes=[]  # use a list to keep them ordered

   447

        for iec_type,_instances in json_types.items():

   448

            recurseJsonTypes(iec_type, basetypes)

   449

   450

        done_types = set()

   451

        # go backard to get most derivated type definition last

   452

        # so that CPP can always find base type deinition before

   453

        for iec_type in reversed(basetypes):

   454

            # avoid repeating type definition

   455

            if iec_type in done_types:

   456

                continue

   457

            done_types.add(iec_type)

   458

   459

            C_type = iec_type.upper()

   460

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

   461

   462

            infos = datatype_info_getter(iec_type)

   463

   464

            elements = infos["elements"]

   465

            last = len(elements) - 1

   466

            for idx, element in enumerate(elements):

   467

                field_iec_type = element["Type"]

   468

                field_C_type = field_iec_type.upper()

   469

                field_name = element["Name"].upper()

   470

                if field_iec_type in MQTT_IEC_types:

   471

                    decl_type = "SIMPLE"

   472

                else:

   473

                    decl_type = "OBJECT"

   474

   475

                json_decl += "    _P##_"+decl_type+"(" + field_C_type + ", " + field_name + ", _A)"

   476

                if idx != last:

   477

                    json_decl += " _P##_separator \\"

   478

                else:

   479

                    json_decl += "\n"

   480

                json_decl += "\n"

   481

   482

   483

            formatdict["json_decl"] += json_decl

   484

   485

        for iec_type, instances in json_types.items():

   486

            C_type = iec_type.upper()

   487

            for direction, instance_list in instances.items():

   488

                for c_loc_name in instance_list:

   489

                    formatdict["json_decl"] += "DECL_JSON_"+direction+"("+C_type+", "+c_loc_name+")\n"

   490

   491

        Ccode = c_template.format(**formatdict)

   492

   493

        return Ccode

   494