1

"""

     2

Config Tree Node base class.

     3

     4

- A Beremiz project is organized in a tree each node derivate from ConfigTreeNode

     5

- Project tree organization match filesystem organization of project directory.

     6

- Each node of the tree have its own xml configuration, whose grammar is defined for each node type, as XSD

     7

- ... TODO : document

     8

"""

     9

    10

import os,traceback,types

    11

import shutil

    12

from lxml import etree

    13

    14

from xmlclass import GenerateParserFromXSDstring

    15

from util.misc import GetClassImporter

    16

    17

from PLCControler import PLCControler, LOCATION_CONFNODE

    18

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    19

    20

_BaseParamsParser = GenerateParserFromXSDstring("""<?xml version="1.0" encoding="ISO-8859-1" ?>

    21

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

    22

          <xsd:element name="BaseParams">

    23

            <xsd:complexType>

    24

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

    25

              <xsd:attribute name="IEC_Channel" type="xsd:integer" use="required"/>

    26

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

    27

            </xsd:complexType>

    28

          </xsd:element>

    29

        </xsd:schema>""")

    30

    31

NameTypeSeparator = '@'

    32

XSDSchemaErrorMessage = _("%s XML file doesn't follow XSD schema at line %d:\n%s")

    33

    34

class ConfigTreeNode:

    35

    """

    36

    This class is the one that define confnodes.

    37

    """

    38

    39

    XSD = None

    40

    CTNChildrenTypes = []

    41

    CTNMaxCount = None

    42

    ConfNodeMethods = []

    43

    LibraryControler = None

    44

    EditorType = ConfTreeNodeEditor

    45

    IconPath = None

    46

    47

    def _AddParamsMembers(self):

    48

        self.CTNParams = None

    49

        if self.XSD:

    50

            self.Parser = GenerateParserFromXSDstring(self.XSD)

    51

            obj = self.Parser.CreateRoot()

    52

            name = obj.getLocalTag()

    53

            self.CTNParams = (name, obj)

    54

            setattr(self, name, obj)

    55

    56

    def __init__(self):

    57

        # Create BaseParam 

    58

        self.BaseParams = _BaseParamsParser.CreateRoot()

    59

        self.MandatoryParams = ("BaseParams", self.BaseParams)

    60

        self._AddParamsMembers()

    61

        self.Children = {}

    62

        self._View = None

    63

        # copy ConfNodeMethods so that it can be later customized

    64

        self.ConfNodeMethods = [dic.copy() for dic in self.ConfNodeMethods]

    65

    66

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    67

        return os.path.join(self.CTNPath(CTNName), "baseconfnode.xml")

    68

    69

    def ConfNodeXmlFilePath(self, CTNName=None):

    70

        return os.path.join(self.CTNPath(CTNName), "confnode.xml")

    71

    72

    def ConfNodePath(self):

    73

        return os.path.join(self.CTNParent.ConfNodePath(), self.CTNType)

    74

    75

    def CTNPath(self,CTNName=None,project_path=None):

    76

        if not CTNName:

    77

            CTNName = self.CTNName()

    78

        if not project_path:

    79

            project_path = self.CTNParent.CTNPath()

    80

        return os.path.join(project_path,

    81

                            CTNName + NameTypeSeparator + self.CTNType)

    82

    83

    def CTNName(self):

    84

        return self.BaseParams.getName()

    85

    86

    def CTNEnabled(self):

    87

        return self.BaseParams.getEnabled()

    88

    89

    def CTNFullName(self):

    90

        parent = self.CTNParent.CTNFullName()

    91

        if parent != "":

    92

            return parent + "." + self.CTNName()

    93

        return self.BaseParams.getName()

    94

    95

    def GetIconName(self):

    96

        return None

    97

    98

    def CTNTestModified(self):

    99

        return self.ChangesToSave

   100

   101

    def ProjectTestModified(self):

   102

        """

   103

        recursively check modified status

   104

        """

   105

        if self.CTNTestModified():

   106

            return True

   107

   108

        for CTNChild in self.IterChildren():

   109

            if CTNChild.ProjectTestModified():

   110

                return True

   111

   112

        return False

   113

   114

    def RemoteExec(self, script, **kwargs):

   115

        return self.CTNParent.RemoteExec(script, **kwargs)

   116

   117

    def OnCTNSave(self, from_project_path=None):

   118

        #Default, do nothing and return success

   119

        return True

   120

   121

    def GetParamsAttributes(self, path = None):

   122

        if path:

   123

            parts = path.split(".", 1)

   124

            if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

   125

                return self.MandatoryParams[1].getElementInfos(parts[0], parts[1])

   126

            elif self.CTNParams and parts[0] == self.CTNParams[0]:

   127

                return self.CTNParams[1].getElementInfos(parts[0], parts[1])

   128

        else:

   129

            params = []

   130

            if self.CTNParams:

   131

                params.append(self.CTNParams[1].getElementInfos(self.CTNParams[0]))

   132

            return params

   133

   134

    def SetParamsAttribute(self, path, value):

   135

        self.ChangesToSave = True

   136

        # Filter IEC_Channel and Name, that have specific behavior

   137

        if path == "BaseParams.IEC_Channel":

   138

            old_leading = ".".join(map(str, self.GetCurrentLocation()))

   139

            new_value = self.FindNewIEC_Channel(value)

   140

            if new_value != value:

   141

                new_leading = ".".join(map(str, self.CTNParent.GetCurrentLocation() + (new_value,)))

   142

                self.GetCTRoot().UpdateProjectVariableLocation(old_leading, new_leading)

   143

            return new_value, True

   144

        elif path == "BaseParams.Name":

   145

            res = self.FindNewName(value)

   146

            self.CTNRequestSave()

   147

            return res, True

   148

   149

        parts = path.split(".", 1)

   150

        if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

   151

            self.MandatoryParams[1].setElementValue(parts[1], value)

   152

            value = self.MandatoryParams[1].getElementInfos(parts[0], parts[1])["value"]

   153

        elif self.CTNParams and parts[0] == self.CTNParams[0]:

   154

            self.CTNParams[1].setElementValue(parts[1], value)

   155

            value = self.CTNParams[1].getElementInfos(parts[0], parts[1])["value"]

   156

        return value, False

   157

   158

    def CTNMakeDir(self):

   159

        os.mkdir(self.CTNPath())

   160

   161

    def CTNRequestSave(self, from_project_path=None):

   162

        if self.GetCTRoot().CheckProjectPathPerm(False):

   163

            # If confnode do not have corresponding directory

   164

            ctnpath = self.CTNPath()

   165

            if not os.path.isdir(ctnpath):

   166

                # Create it

   167

                os.mkdir(ctnpath)

   168

   169

            # generate XML for base XML parameters controller of the confnode

   170

            if self.MandatoryParams:

   171

                BaseXMLFile = open(self.ConfNodeBaseXmlFilePath(),'w')

   172

                BaseXMLFile.write(etree.tostring(

   173

                    self.MandatoryParams[1], 

   174

                    pretty_print=True, 

   175

                    xml_declaration=True, 

   176

                    encoding='utf-8'))

   177

                BaseXMLFile.close()

   178

   179

            # generate XML for XML parameters controller of the confnode

   180

            if self.CTNParams:

   181

                XMLFile = open(self.ConfNodeXmlFilePath(),'w')

   182

                XMLFile.write(etree.tostring(

   183

                    self.CTNParams[1], 

   184

                    pretty_print=True, 

   185

                    xml_declaration=True, 

   186

                    encoding='utf-8'))

   187

                XMLFile.close()

   188

   189

            # Call the confnode specific OnCTNSave method

   190

            result = self.OnCTNSave(from_project_path)

   191

            if not result:

   192

                return _("Error while saving \"%s\"\n")%self.CTNPath()

   193

   194

            # mark confnode as saved

   195

            self.ChangesToSave = False

   196

            # go through all children and do the same

   197

            for CTNChild in self.IterChildren():

   198

                CTNChildPath = None

   199

                if from_project_path is not None:

   200

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   201

                result = CTNChild.CTNRequestSave(CTNChildPath)

   202

                if result:

   203

                    return result

   204

        return None

   205

   206

    def CTNImport(self, src_CTNPath):

   207

        shutil.copytree(src_CTNPath, self.CTNPath)

   208

        return True

   209

   210

    def CTNGlobalInstances(self):

   211

        """

   212

        @return: [(instance_name, instance_type),...]

   213

        """

   214

        return []

   215

   216

    def _GlobalInstances(self):

   217

        instances = self.CTNGlobalInstances()

   218

        for CTNChild in self.IECSortedChildren():

   219

            instances.extend(CTNChild._GlobalInstances())

   220

        return instances

   221

   222

    def CTNGenerate_C(self, buildpath, locations):

   223

        """

   224

        Generate C code

   225

        @param locations: List of complete variables locations \

   226

            [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

   227

            "NAME" : name of the variable (generally "__IW0_1_2" style)

   228

            "DIR" : direction "Q","I" or "M"

   229

            "SIZE" : size "X", "B", "W", "D", "L"

   230

            "LOC" : tuple of interger for IEC location (0,1,2,...)

   231

            }, ...]

   232

        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   233

        """

   234

        self.GetCTRoot().logger.write_warning(".".join(map(lambda x:str(x), self.GetCurrentLocation())) + " -> Nothing to do\n")

   235

        return [],"",False

   236

   237

    def _Generate_C(self, buildpath, locations):

   238

        # Generate confnodes [(Cfiles, CFLAGS)], LDFLAGS, DoCalls, extra_files

   239

        # extra_files = [(fname,fobject), ...]

   240

        gen_result = self.CTNGenerate_C(buildpath, locations)

   241

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   242

        extra_files = gen_result[3:]

   243

        # if some files have been generated put them in the list with their location

   244

        if CTNCFilesAndCFLAGS:

   245

            LocationCFilesAndCFLAGS = [(self.GetCurrentLocation(), CTNCFilesAndCFLAGS, DoCalls)]

   246

        else:

   247

            LocationCFilesAndCFLAGS = []

   248

   249

        # confnode asks for some LDFLAGS

   250

        if CTNLDFLAGS:

   251

            # LDFLAGS can be either string

   252

            if type(CTNLDFLAGS)==type(str()):

   253

                LDFLAGS=[CTNLDFLAGS]

   254

            #or list of strings

   255

            elif type(CTNLDFLAGS)==type(list()):

   256

                LDFLAGS=CTNLDFLAGS[:]

   257

        else:

   258

            LDFLAGS=[]

   259

   260

        # recurse through all children, and stack their results

   261

        for CTNChild in self.IECSortedChildren():

   262

            new_location = CTNChild.GetCurrentLocation()

   263

            # How deep are we in the tree ?

   264

            depth=len(new_location)

   265

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   266

                CTNChild._Generate_C(

   267

                    #keep the same path

   268

                    buildpath,

   269

                    # filter locations that start with current IEC location

   270

                    [loc for loc in locations if loc["LOC"][0:depth] == new_location ])

   271

            # stack the result

   272

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   273

            LDFLAGS += _LDFLAGS

   274

            extra_files += _extra_files

   275

   276

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   277

   278

    def IterChildren(self):

   279

        for CTNType, Children in self.Children.items():

   280

            for CTNInstance in Children:

   281

                yield CTNInstance

   282

   283

    def IECSortedChildren(self):

   284

        # reorder children by IEC_channels

   285

        ordered = [(chld.BaseParams.getIEC_Channel(),chld) for chld in self.IterChildren()]

   286

        if ordered:

   287

            ordered.sort()

   288

            return zip(*ordered)[1]

   289

        else:

   290

            return []

   291

   292

    def _GetChildBySomething(self, something, toks):

   293

        for CTNInstance in self.IterChildren():

   294

            # if match component of the name

   295

            if getattr(CTNInstance.BaseParams, something) == toks[0]:

   296

                # if Name have other components

   297

                if len(toks) >= 2:

   298

                    # Recurse in order to find the latest object

   299

                    return CTNInstance._GetChildBySomething( something, toks[1:])

   300

                # No sub name -> found

   301

                return CTNInstance

   302

        # Not found

   303

        return None

   304

   305

    def GetChildByName(self, Name):

   306

        if Name:

   307

            toks = Name.split('.')

   308

            return self._GetChildBySomething("Name", toks)

   309

        else:

   310

            return self

   311

   312

    def GetChildByIECLocation(self, Location):

   313

        if Location:

   314

            return self._GetChildBySomething("IEC_Channel", Location)

   315

        else:

   316

            return self

   317

   318

    def GetCurrentLocation(self):

   319

        """

   320

        @return:  Tupple containing confnode IEC location of current confnode : %I0.0.4.5 => (0,0,4,5)

   321

        """

   322

        return self.CTNParent.GetCurrentLocation() + (self.BaseParams.getIEC_Channel(),)

   323

   324

    def GetCurrentName(self):

   325

        """

   326

        @return:  String "ParentParentName.ParentName.Name"

   327

        """

   328

        return  self.CTNParent._GetCurrentName() + self.BaseParams.getName()

   329

   330

    def _GetCurrentName(self):

   331

        """

   332

        @return:  String "ParentParentName.ParentName.Name."

   333

        """

   334

        return  self.CTNParent._GetCurrentName() + self.BaseParams.getName() + "."

   335

   336

    def GetCTRoot(self):

   337

        return self.CTNParent.GetCTRoot()

   338

   339

    def GetFullIEC_Channel(self):

   340

        return ".".join([str(i) for i in self.GetCurrentLocation()]) + ".x"

   341

   342

    def GetLocations(self):

   343

        location = self.GetCurrentLocation()

   344

        return [loc for loc in self.CTNParent.GetLocations() if loc["LOC"][0:len(location)] == location]

   345

   346

    def GetVariableLocationTree(self):

   347

        '''

   348

        This function is meant to be overridden by confnodes.

   349

   350

        It should returns an list of dictionaries

   351

   352

        - IEC_type is an IEC type like BOOL/BYTE/SINT/...

   353

        - location is a string of this variable's location, like "%IX0.0.0"

   354

        '''

   355

        children = []

   356

        for child in self.IECSortedChildren():

   357

            children.append(child.GetVariableLocationTree())

   358

        return {"name": self.BaseParams.getName(),

   359

                "type": LOCATION_CONFNODE,

   360

                "location": self.GetFullIEC_Channel(),

   361

                "children": children}

   362

   363

    def FindNewName(self, DesiredName):

   364

        """

   365

        Changes Name to DesiredName if available, Name-N if not.

   366

        @param DesiredName: The desired Name (string)

   367

        """

   368

        # Get Current Name

   369

        CurrentName = self.BaseParams.getName()

   370

        # Do nothing if no change

   371

        #if CurrentName == DesiredName: return CurrentName

   372

        # Build a list of used Name out of parent's Children

   373

        AllNames=[]

   374

        for CTNInstance in self.CTNParent.IterChildren():

   375

            if CTNInstance != self:

   376

                AllNames.append(CTNInstance.BaseParams.getName())

   377

   378

        # Find a free name, eventually appending digit

   379

        res = DesiredName

   380

        if DesiredName.endswith("_0"):

   381

            BaseDesiredName = DesiredName[:-2]

   382

        else:

   383

            BaseDesiredName = DesiredName

   384

        suffix = 1

   385

        while res in AllNames:

   386

            res = "%s_%d"%(BaseDesiredName, suffix)

   387

            suffix += 1

   388

   389

        # Get old path

   390

        oldname = self.CTNPath()

   391

        # Check previous confnode existance

   392

        dontexist = self.BaseParams.getName() == "__unnamed__"

   393

        # Set the new name

   394

        self.BaseParams.setName(res)

   395

        # Rename confnode dir if exist

   396

        if not dontexist:

   397

            shutil.move(oldname, self.CTNPath())

   398

        # warn user he has two left hands

   399

        if DesiredName != res:

   400

            self.GetCTRoot().logger.write_warning(_("A child named \"%s\" already exist -> \"%s\"\n")%(DesiredName,res))

   401

        return res

   402

   403

    def GetAllChannels(self):

   404

        AllChannels=[]

   405

        for CTNInstance in self.CTNParent.IterChildren():

   406

            if CTNInstance != self:

   407

                AllChannels.append(CTNInstance.BaseParams.getIEC_Channel())

   408

        AllChannels.sort()

   409

        return AllChannels

   410

   411

    def FindNewIEC_Channel(self, DesiredChannel):

   412

        """

   413

        Changes IEC Channel number to DesiredChannel if available, nearest available if not.

   414

        @param DesiredChannel: The desired IEC channel (int)

   415

        """

   416

        # Get Current IEC channel

   417

        CurrentChannel = self.BaseParams.getIEC_Channel()

   418

        # Do nothing if no change

   419

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   420

        # Build a list of used Channels out of parent's Children

   421

        AllChannels = self.GetAllChannels()

   422

   423

        # Now, try to guess the nearest available channel

   424

        res = DesiredChannel

   425

        while res in AllChannels: # While channel not free

   426

            if res < CurrentChannel: # Want to go down ?

   427

                res -=  1 # Test for n-1

   428

                if res < 0 :

   429

                    self.GetCTRoot().logger.write_warning(_("Cannot find lower free IEC channel than %d\n")%CurrentChannel)

   430

                    return CurrentChannel # Can't go bellow 0, do nothing

   431

            else : # Want to go up ?

   432

                res +=  1 # Test for n-1

   433

        # Finally set IEC Channel

   434

        self.BaseParams.setIEC_Channel(res)

   435

        return res

   436

   437

    def GetContextualMenuItems(self):

   438

        return None

   439

   440

    def _OpenView(self, name=None, onlyopened=False):

   441

        if self.EditorType is not None:

   442

            app_frame = self.GetCTRoot().AppFrame

   443

            if self._View is None and not onlyopened:

   444

   445

                self._View = self.EditorType(app_frame.TabsOpened, self, app_frame)

   446

   447

            if self._View is not None:

   448

                if name is None:

   449

                    name = self.CTNFullName()

   450

                app_frame.EditProjectElement(self._View, name)

   451

   452

            return self._View

   453

        return None

   454

   455

    def _CloseView(self, view):

   456

        app_frame = self.GetCTRoot().AppFrame

   457

        if app_frame is not None:

   458

            app_frame.DeletePage(view)

   459

   460

    def OnCloseEditor(self, view):

   461

        if self._View == view:

   462

            self._View = None

   463

   464

    def OnCTNClose(self):

   465

        if self._View is not None:

   466

            self._CloseView(self._View)

   467

            self._View = None

   468

        return True

   469

   470

    def _doRemoveChild(self, CTNInstance):

   471

        # Remove all children of child

   472

        for SubCTNInstance in CTNInstance.IterChildren():

   473

            CTNInstance._doRemoveChild(SubCTNInstance)

   474

        # Call the OnCloseMethod

   475

        CTNInstance.OnCTNClose()

   476

        # Delete confnode dir

   477

        shutil.rmtree(CTNInstance.CTNPath())

   478

        # Remove child of Children

   479

        self.Children[CTNInstance.CTNType].remove(CTNInstance)

   480

        if len(self.Children[CTNInstance.CTNType]) == 0: