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

     8

import wx

     9

import wx.dataview as dv

    10

    11

from perfect_hash import generate_code, IntSaltHash

    12

    13

MQTT_IEC_types = dict(

    14

# IEC61131|  C  type   | sz

    15

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

    16

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

    17

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

    18

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

    19

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

    20

    DINT  = ("uint32_t", "D"),

    21

    UDINT = ("int32_t" , "D"),

    22

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

    23

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

    24

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

    25

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

    26

)

    27

    28

"""

    29

 QoS - Quality of Service

    30

  0  : "At most one delivery"

    31

  1  : "At least one delivery"

    32

  2  : "Exactly one delivery"

    33

"""

    34

QoS_values = [0, 1, 2]

    35

    36

def boolean(v):

    37

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

    38

        return False

    39

    else:

    40

        return bool(v)

    41

    42

lstcolnames  = [ "Topic",  "QoS",  "Retain", "Type", "Location"]

    43

lstcolwidths = [     100,     50,       100,    100,         50]

    44

lstcoltypess = [     str,    int,   boolean,    str,        int]

    45

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

    46

Location_column = lstcolnames.index("Location")

    47

    48

directions = ["input", "output"]

    49

    50

authParams = {

    51

    "x509":[

    52

        ("Certificate", "certificate.der"),

    53

        ("PrivateKey", "private_key.pem")],

    54

    "UserPassword":[

    55

        ("User", None),

    56

        ("Password", None)]}

    57

    58

class MQTTTopicListModel(dv.PyDataViewIndexListModel):

    59

    def __init__(self, data, log):

    60

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

    61

        self.data = data

    62

        self.log = log

    63

    64

    def GetColumnType(self, col):

    65

        return "string"

    66

    67

    def GetValueByRow(self, row, col):

    68

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

    69

    70

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

    71

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

    72

        expectedtype = lstcoltypess[col]

    73

    74

        try:

    75

            v = expectedtype(value)

    76

        except ValueError: 

    77

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

    78

            return False

    79

    80

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

    81

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

    82

            return False

    83

    84

        self.data[row][col] = v

    85

        return True

    86

    87

    # Report how many columns this model provides data for.

    88

    def GetColumnCount(self):

    89

        return len(lstcolnames)

    90

    91

    # Report the number of rows in the model

    92

    def GetCount(self):

    93

        #self.log.write('GetCount')

    94

        return len(self.data)

    95

    96

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

    97

    # cell at (row, col)

    98

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

    99

        if col == Location_column:

   100

            attr.SetColour('blue')

   101

            attr.SetBold(True)

   102

            return True

   103

        return False

   104

   105

   106

    def DeleteRows(self, rows):

   107

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

   108

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

   109

        rows = sorted(rows, reverse=True)

   110

   111

        for row in rows:

   112

            # remove it from our data structure

   113

            del self.data[row]

   114

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

   115

            self.RowDeleted(row)

   116

   117

   118

    def AddRow(self, value):

   119

        if self.data.append(value):

   120

            # notify views

   121

            self.RowAppended()

   122

   123

    def InsertDefaultRow(self, row):

   124

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

   125

        # notify views

   126

        self.RowInserted(row)

   127

   128

    def ResetData(self):

   129

        self.Reset(len(self.data))

   130

   131

class MQTTTopicListPanel(wx.Panel):

   132

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

   133

        self.log = log

   134

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

   135

   136

        self.dvc = dv.DataViewCtrl(self,

   137

                                   style=wx.BORDER_THEME

   138

                                   | dv.DV_ROW_LINES

   139

                                   | dv.DV_HORIZ_RULES

   140

                                   | dv.DV_VERT_RULES

   141

                                   | dv.DV_MULTIPLE

   142

                                   )

   143

   144

        self.model = model

   145

   146

        self.dvc.AssociateModel(self.model)

   147

   148

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

   149

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

   150

   151

   152

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

   153

   154

        self.direction =  direction

   155

        titlestr = direction + " variables"

   156

   157

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

   158

   159

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

   160

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

   161

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

   162

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

   163

   164

        topsizer = wx.BoxSizer(wx.HORIZONTAL)

   165

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

   166

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

   167

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

   168

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

   169

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

   170

   171

   172

    def OnAddRow(self, evt):

   173

        items = self.dvc.GetSelections()

   174

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

   175

        self.model.InsertDefaultRow(row)

   176

   177

    def OnDeleteRows(self, evt):

   178

        items = self.dvc.GetSelections()

   179

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

   180

        self.model.DeleteRows(rows)

   181

   182

   183

class MQTTClientPanel(wx.Panel):

   184

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

   185

        self.log = log

   186

        wx.Panel.__init__(self, parent)

   187

   188

        # TODO replace FlexGridSizer with a simpler one

   189

        self.inout_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=0)

   190

        self.inout_sizer.AddGrowableCol(0)

   191

        self.inout_sizer.AddGrowableRow(0)

   192

   193

        self.config_getter = config_getter

   194

   195

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

   196

   197

        self.selected_datas = modeldata

   198

        self.selected_models = { direction:MQTTTopicListModel(self.selected_datas[direction], log) for direction in directions }

   199

        self.selected_lists = { direction:MQTTTopicListPanel(

   200

                self.selected_splitter, log, 

   201

                self.selected_models[direction], direction) 

   202

            for direction in directions }

   203

   204

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

   205

   206

        self.inout_sizer.Add(self.selected_splitter, flag=wx.GROW)

   207

        self.inout_sizer.Layout()

   208

        self.SetAutoLayout(True)

   209

        self.SetSizer(self.inout_sizer)

   210

   211

    def OnClose(self):

   212

        pass

   213

   214

    def __del__(self):

   215

        self.OnClose()

   216

   217

    def Reset(self):

   218

        for direction in directions:

   219

            self.selected_models[direction].ResetData() 

   220

   221

   222

class MQTTClientList(list):

   223

    def __init__(self, log, change_callback):

   224

        super(MQTTClientList, self).__init__(self)

   225

        self.log = log

   226

        self.change_callback = change_callback

   227

   228

    def append(self, value):

   229

        v = dict(list(zip(lstcolnames, value)))

   230

   231

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

   232

            if len(self) == 0:

   233

                v["Location"] = 0

   234

            else:

   235

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

   236

                greatest = max(iecnums)

   237

                holes = set(range(greatest)) - iecnums

   238

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

   239

   240

        if v["QoS"] not in QoS_values:

   241

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

   242

            return False

   243

   244

        try:

   245

            for t,n in zip(lstcoltypess, lstcolnames):

   246

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

   247

        except ValueError: 

   248

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

   249

            return False

   250

   251

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

   252

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

   253

            return False

   254

   255

        list.append(self, [v[n] for n in lstcolnames])

   256

   257

        self.change_callback()

   258

   259

        return True

   260

   261

    def __delitem__(self, index):

   262

        list.__delitem__(self, index)

   263

        self.change_callback()

   264

   265

class MQTTClientModel(dict):

   266

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

   267

        super(MQTTClientModel, self).__init__()

   268

        for direction in directions:

   269

            self[direction] = MQTTClientList(log, change_callback)

   270

   271

    def LoadCSV(self,path):

   272

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

   273

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

   274

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

   275

            for direction, model in self.iteritems():

   276

                self[direction][:] = []

   277

            for row in reader:

   278

                direction = row[0]

   279

                # avoids calling change callback when loading CSV

   280

                list.append(self[direction],row[1:])

   281

   282

    def SaveCSV(self,path):

   283

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

   284

            for direction, data in self.items():

   285

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

   286

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

   287

                for row in data:

   288

                    writer.writerow([direction] + row)

   289

   290

    def _TopicsPerfectHash(self, topics):

   291

        template = """

   292

#define NK  $NK       /* number of keys */

   293

#define NG  $NG       /* number of vertices */

   294

#define NS  $NS       /* length of array T1 and T2 */

   295

   296

int S1[] = {$S1};

   297

int S2[] = {$S2};

   298

int G[] = {$G};

   299

char *K[] = {$K};

   300

"""

   301

		code = generate_code(topics, Hash=IntSaltHash, template=template)

   302

        code += """

   303

/* return index of key in K if key is found, -1 otherwise */

   304

int MQTT_Topic_index(const char *key)

   305

{

   306

    int i, f1 = 0, f2 = 0;

   307

   308

    for (i = 0; key[i] != '\\0' && i < NS; i++) {

   309

        f1 += S1[i] * key[i];

   310

        f2 += S2[i] * key[i];

   311

        f1 %= NG;

   312

        f2 %= NG;

   313

    }

   314

    i = (G[f1] + G[f2]) % NG;

   315

    if (i < NK && strcmp(key, K[i]) == 0)

   316

        return i;

   317

   318

    return -1;

   319

}

   320

""" 

   321

		return code

   322

   323

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

   324

        template = """/* code generated by beremiz MQTT extension */

   325

   326

#include "MQTTAsync.h"

   327

#include "MQTTClientPersistence.h"

   328

   329

#define _Log(level, ...)                                                                           \\

   330

    {{                                                                                             \\

   331

        char mstr[256];                                                                            \\

   332

        snprintf(mstr, 255, __VA_ARGS__);                                                          \\

   333

        LogMessage(level, mstr, strlen(mstr));                                                     \\

   334

    }}

   335

   336

#define LogInfo(...) _Log(LOG_INFO, __VA_ARGS__);

   337

#define LogError(...) _Log(LOG_CRITICAL, __VA_ARGS__);

   338

#define LogWarning(...) _Log(LOG_WARNING, __VA_ARGS__);

   339

   340

static inline void* loadFile(const char *const path) {{

   341

   342

    FILE *fp = fopen(path, "rb");

   343

    if(!fp) {{

   344

        errno = 0;

   345

        LogError("MQTT could not open %s", path);

   346

        return NULL;

   347

    }}

   348

   349

    fseek(fp, 0, SEEK_END);

   350

    size_t length = (size_t)ftell(fp);

   351

    void* data = malloc(length);

   352

    if(data) {{

   353

        fseek(fp, 0, SEEK_SET);

   354

        size_t read = fread(data, 1, fileContents.length, fp);

   355

        if(read != length){{

   356

            free(data);

   357

            LogError("MQTT could not read %s", path);

   358

        }}

   359

    }} else {{

   360

        LogError("MQTT Not enough memoty to load %s", path);

   361

    }}

   362

    fclose(fp);

   363

   364

    return data;

   365

}}

   366

   367

static MQTTClient client;

   368

static MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer;

   369

   370

void trace_callback(enum MQTTASYNC_TRACE_LEVELS level, char* message)

   371

{

   372

	LogWarning("Paho MQTT Trace : %d, %s\n", level, message);

   373

}

   374

   375

#define DECL_VAR(iec_type, C_type, c_loc_name)                                                       \\

   376

static C_type c_loc_name##_buf = 0;                                                                 \\

   377

C_type *c_loc_name = &c_loc_name##_buf;

   378

   379

{decl}

   380

   381

#define INIT_TOPIC(topic, iec_type, c_loc_name)                                                  \\

   382

{topic, &c_loc_name##_buf, iec_type##_ENUM},

   383

   384

ststic struct {

   385

	const char *topic; //null terminated topic string

   386

	void *pdata; //pointer to data

   387

	__IEC_types_enum vartype;

   388

} topics [] = {

   389

{topics}

   390

}

   391

   392

void __cleanup_{locstr}(void)

   393

{{

   394

    MQTT_Client_disconnect(client);

   395

    MQTT_Client_delete(client);

   396

}}

   397

   398

#define INIT_NoAuth()                                                                              \\

   399

    LogInfo("MQTT Init no auth");                                                                \\

   400

    MQTT_ClientConfig_setDefault(cc);                                                                \\

   401

    retval = MQTT_Client_connect(client, uri);

   402

   403

/* Note : Single policy is enforced here, by default open62541 client supports all policies */

   404

#define INIT_x509(Policy, UpperCaseMode, PrivateKey, Certificate)                                  \\

   405

    LogInfo("MQTT Init x509 %s,%s,%s,%s", #Policy, #UpperCaseMode, PrivateKey, Certificate);     \\

   406

                                                                                                   \\

   407

    MQTT_ByteString certificate = loadFile(Certificate);                                             \\

   408

    MQTT_ByteString privateKey  = loadFile(PrivateKey);                                              \\

   409

                                                                                                   \\

   410

    cc->securityMode = MQTT_MESSAGESECURITYMODE_##UpperCaseMode;                                     \\

   411

                                                                                                   \\

   412

    /* replacement for default behaviour */                                                        \\

   413

    /* MQTT_ClientConfig_setDefaultEncryption(cc, certificate, privateKey, NULL, 0, NULL, 0); */     \\

   414

    do{{                                                                                           \\

   415

        retval = MQTT_ClientConfig_setDefault(cc);                                                   \\

   416

        if(retval != MQTT_STATUSCODE_GOOD)                                                           \\

   417

            break;                                                                                 \\

   418

                                                                                                   \\

   419

        MQTT_SecurityPolicy *sp = (MQTT_SecurityPolicy*)                                               \\

   420

            MQTT_realloc(cc->securityPolicies, sizeof(MQTT_SecurityPolicy) * 2);                       \\

   421

        if(!sp){{                                                                                  \\

   422

            retval = MQTT_STATUSCODE_BADOUTOFMEMORY;                                                 \\

   423

            break;                                                                                 \\

   424

        }}                                                                                         \\

   425

        cc->securityPolicies = sp;                                                                 \\

   426

                                                                                                   \\

   427

        retval = MQTT_SecurityPolicy_##Policy(&cc->securityPolicies[cc->securityPoliciesSize],       \\

   428

                                                 certificate, privateKey, &cc->logger);            \\

   429

        if(retval != MQTT_STATUSCODE_GOOD) {{                                                        \\

   430

            MQTT_LOG_WARNING(&cc->logger, MQTT_LOGCATEGORY_USERLAND,                                   \\

   431

                           "Could not add SecurityPolicy Policy with error code %s",               \\

   432

                           MQTT_StatusCode_name(retval));                                            \\

   433

            MQTT_free(cc->securityPolicies);                                                         \\

   434

            cc->securityPolicies = NULL;                                                           \\

   435

            break;                                                                                 \\

   436

        }}                                                                                         \\

   437

                                                                                                   \\

   438

        ++cc->securityPoliciesSize;                                                                \\

   439

    }} while(0);                                                                                   \\

   440

                                                                                                   \\

   441

    retval = MQTT_Client_connect(client, uri);                                                       \\

   442

                                                                                                   \\

   443

    MQTT_ByteString_clear(&certificate);                                                             \\

   444

    MQTT_ByteString_clear(&privateKey);

   445

   446

#define INIT_UserPassword(User, Password)                                                          \\

   447

    LogInfo("MQTT Init UserPassword %s,%s", User, Password);                                     \\

   448

    MQTT_ClientConfig_setDefault(cc);                                                                \\

   449

    retval = MQTT_Client_connectUsername(client, uri, User, Password);

   450

   451

#define INIT_READ_VARIANT(ua_type, c_loc_name)                                                     \\

   452

    MQTT_Variant_init(&c_loc_name##_variant);

   453

   454

#define INIT_WRITE_VARIANT(ua_type, ua_type_enum, c_loc_name)                                      \\

   455

    MQTT_Variant_setScalar(&c_loc_name##_variant, (ua_type*)c_loc_name, &MQTT_TYPES[ua_type_enum]);

   456

   457

int __init_{locstr}(int argc,char **argv)

   458

{{

   459

    char *uri = "{uri}";

   460

    char *clientID = "{clientID}";

   461

    int rc;

   462

    conn_opts = MQTTClient_connectOptions_initializer;

   463

   464

    if ((rc = MQTTClient_create(&client, uri, clientID,

   465

        MQTTCLIENT_PERSISTENCE_NONE, NULL)) != MQTTCLIENT_SUCCESS)

   466

    {

   467

        printf("Failed to create client, return code %d\n", rc);

   468

        rc = EXIT_FAILURE;

   469

        goto exit;

   470

    }

   471

   472

{init}

   473

   474

    if(retval != MQTT_STATUSCODE_GOOD) {{

   475

        LogError("MQTT Init Failed %d", retval);

   476

        MQTT_Client_delete(client);

   477

        return EXIT_FAILURE;

   478

    }}

   479

    return 0;

   480

}}

   481

   482

#define READ_VALUE(ua_type, ua_type_enum, c_loc_name, ua_nodeid_type, ua_nsidx, ua_node_id)        \\

   483

    retval = MQTT_Client_readValueAttribute(                                                         \\

   484

        client, ua_nodeid_type(ua_nsidx, ua_node_id), &c_loc_name##_variant);                      \\

   485

    if(retval == MQTT_STATUSCODE_GOOD && MQTT_Variant_isScalar(&c_loc_name##_variant) &&               \\

   486

       c_loc_name##_variant.type == &MQTT_TYPES[ua_type_enum]) {{                                    \\

   487

            c_loc_name##_buf = *(ua_type*)c_loc_name##_variant.data;                               \\

   488

            MQTT_Variant_clear(&c_loc_name##_variant);  /* Unalloc requiered on each read ! */       \\

   489

    }}

   490

   491

void __retrieve_{locstr}(void)

   492

{{

   493

    MQTT_StatusCode retval;

   494

{retrieve}

   495

}}

   496

   497

#define WRITE_VALUE(ua_type, c_loc_name, ua_nodeid_type, ua_nsidx, ua_node_id)                     \\

   498

    MQTT_Client_writeValueAttribute(                                                                 \\

   499

        client, ua_nodeid_type(ua_nsidx, ua_node_id), &c_loc_name##_variant);

   500

   501

void __publish_{locstr}(void)

   502

{{

   503

{publish}

   504

}}

   505

   506

"""

   507

   508

        formatdict = dict(

   509

            locstr   = locstr,

   510

            uri      = config["URI"],

   511

            clientID = config["clientID"],

   512

            decl     = "",

   513

            topics   = "",

   514

            cleanup  = "",

   515

            init     = "",

   516

            retrieve = "",

   517

            publish  = "" 

   518

        )

   519

   520

        AuthType = config["AuthType"]