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 xml.dom import minidom

    13

    14

from xmlclass import GenerateClassesFromXSDstring

    15

from util import opjimg, GetClassImporter

    16

    17

from PLCControler import PLCControler, LOCATION_CONFNODE

    18

    19

_BaseParamsClass = GenerateClassesFromXSDstring("""<?xml version="1.0" encoding="ISO-8859-1" ?>

    20

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

    21

          <xsd:element name="BaseParams">

    22

            <xsd:complexType>

    23

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

    24

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

    25

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

    26

            </xsd:complexType>

    27

          </xsd:element>

    28

        </xsd:schema>""")["BaseParams"]

    29

    30

NameTypeSeparator = '@'

    31

    32

class ConfigTreeNode:

    33

    """

    34

    This class is the one that define confnodes.

    35

    """

    36

    37

    XSD = None

    38

    CTNChildrenTypes = []

    39

    CTNMaxCount = None

    40

    ConfNodeMethods = []

    41

    LibraryControler = None

    42

    EditorType = None

    43

    44

    def _AddParamsMembers(self):

    45

        self.CTNParams = None

    46

        if self.XSD:

    47

            self.Classes = GenerateClassesFromXSDstring(self.XSD)

    48

            Classes = [(name, XSDclass) for name, XSDclass in self.Classes.items() if XSDclass.IsBaseClass]

    49

            if len(Classes) == 1:

    50

                name, XSDclass = Classes[0]

    51

                obj = XSDclass()

    52

                self.CTNParams = (name, obj)

    53

                setattr(self, name, obj)

    54

    55

    def __init__(self):

    56

        # Create BaseParam 

    57

        self.BaseParams = _BaseParamsClass()

    58

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

    59

        self._AddParamsMembers()

    60

        self.Children = {}

    61

        self._View = None

    62

        # copy ConfNodeMethods so that it can be later customized

    63

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

    64

    65

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    66

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

    67

    68

    def ConfNodeXmlFilePath(self, CTNName=None):

    69

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

    70

    71

    def ConfNodePath(self):

    72

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

    73

    74

    def CTNPath(self,CTNName=None):

    75

        if not CTNName:

    76

            CTNName = self.CTNName()

    77

        return os.path.join(self.CTNParent.CTNPath(),

    78

                            CTNName + NameTypeSeparator + self.CTNType)

    79

    80

    def CTNName(self):

    81

        return self.BaseParams.getName()

    82

    83

    def CTNEnabled(self):

    84

        return self.BaseParams.getEnabled()

    85

    86

    def CTNFullName(self):

    87

        parent = self.CTNParent.CTNFullName()

    88

        if parent != "":

    89

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

    90

        return self.BaseParams.getName()

    91

    92

    def GetIconPath(self, name):

    93

        return opjimg(name)

    94

    95

    def CTNTestModified(self):

    96

        return self.ChangesToSave

    97

    98

    def ProjectTestModified(self):

    99

        """

   100

        recursively check modified status

   101

        """

   102

        if self.CTNTestModified():

   103

            return True

   104

   105

        for CTNChild in self.IterChildren():

   106

            if CTNChild.ProjectTestModified():

   107

                return True

   108

   109

        return False

   110

   111

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

   112

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

   113

   114

    def OnCTNSave(self):

   115

        #Default, do nothing and return success

   116

        return True

   117

   118

    def GetParamsAttributes(self, path = None):

   119

        if path:

   120

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

   121

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

   122

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

   123

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

   124

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

   125

        else:

   126

            params = []

   127

            if self.CTNParams:

   128

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

   129

            return params

   130

   131

    def SetParamsAttribute(self, path, value):

   132

        self.ChangesToSave = True

   133

        # Filter IEC_Channel and Name, that have specific behavior

   134

        if path == "BaseParams.IEC_Channel":

   135

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

   136

            new_value = self.FindNewIEC_Channel(value)

   137

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

   138

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

   139

            return new_value, True

   140

        elif path == "BaseParams.Name":

   141

            res = self.FindNewName(value)

   142

            self.CTNRequestSave()

   143

            return res, True

   144

   145

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

   146

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

   147

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

   148

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

   149

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

   150

        return value, False

   151

   152

    def CTNMakeDir(self):

   153

        os.mkdir(self.CTNPath())

   154

   155

    def CTNRequestSave(self):

   156

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

   157

            # If confnode do not have corresponding directory

   158

            ctnpath = self.CTNPath()

   159

            if not os.path.isdir(ctnpath):

   160

                # Create it

   161

                os.mkdir(ctnpath)

   162

   163

            # generate XML for base XML parameters controller of the confnode

   164

            if self.MandatoryParams:

   165

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

   166

                BaseXMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")

   167

                BaseXMLFile.write(self.MandatoryParams[1].generateXMLText(self.MandatoryParams[0], 0).encode("utf-8"))

   168

                BaseXMLFile.close()

   169

   170

            # generate XML for XML parameters controller of the confnode

   171

            if self.CTNParams:

   172

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

   173

                XMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")

   174

                XMLFile.write(self.CTNParams[1].generateXMLText(self.CTNParams[0], 0).encode("utf-8"))

   175

                XMLFile.close()

   176

   177

            # Call the confnode specific OnCTNSave method

   178

            result = self.OnCTNSave()

   179

            if not result:

   180

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

   181

   182

            # mark confnode as saved

   183

            self.ChangesToSave = False

   184

            # go through all children and do the same

   185

            for CTNChild in self.IterChildren():

   186

                result = CTNChild.CTNRequestSave()

   187

                if result:

   188

                    return result

   189

        return None

   190

   191

    def CTNImport(self, src_CTNPath):

   192

        shutil.copytree(src_CTNPath, self.CTNPath)

   193

        return True

   194

   195

    def CTNGenerate_C(self, buildpath, locations):

   196

        """

   197

        Generate C code

   198

        @param locations: List of complete variables locations \

   199

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

   200

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

   201

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

   202

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

   203

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

   204

            }, ...]

   205

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

   206

        """

   207

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

   208

        return [],"",False

   209

   210

    def _Generate_C(self, buildpath, locations):

   211

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

   212

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

   213

        gen_result = self.CTNGenerate_C(buildpath, locations)

   214

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   215

        extra_files = gen_result[3:]

   216

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

   217

        if CTNCFilesAndCFLAGS:

   218

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

   219

        else:

   220

            LocationCFilesAndCFLAGS = []

   221

   222

        # confnode asks for some LDFLAGS

   223

        if CTNLDFLAGS:

   224

            # LDFLAGS can be either string

   225

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

   226

                LDFLAGS=[CTNLDFLAGS]

   227

            #or list of strings

   228

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

   229

                LDFLAGS=CTNLDFLAGS[:]

   230

        else:

   231

            LDFLAGS=[]

   232

   233

        # recurse through all children, and stack their results

   234

        for CTNChild in self.IECSortedChildren():

   235

            new_location = CTNChild.GetCurrentLocation()

   236

            # How deep are we in the tree ?

   237

            depth=len(new_location)

   238

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   239

                CTNChild._Generate_C(

   240

                    #keep the same path

   241

                    buildpath,

   242

                    # filter locations that start with current IEC location

   243

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

   244

            # stack the result

   245

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   246

            LDFLAGS += _LDFLAGS

   247

            extra_files += _extra_files

   248

   249

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   250

   251

    def IterChildren(self):

   252

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

   253

            for CTNInstance in Children:

   254

                yield CTNInstance

   255

   256

    def IECSortedChildren(self):

   257

        # reorder children by IEC_channels

   258

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

   259

        if ordered:

   260

            ordered.sort()

   261

            return zip(*ordered)[1]

   262

        else:

   263

            return []

   264

   265

    def _GetChildBySomething(self, something, toks):

   266

        for CTNInstance in self.IterChildren():

   267

            # if match component of the name

   268

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

   269

                # if Name have other components

   270

                if len(toks) >= 2:

   271

                    # Recurse in order to find the latest object

   272

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

   273

                # No sub name -> found

   274

                return CTNInstance

   275

        # Not found

   276

        return None

   277

   278

    def GetChildByName(self, Name):

   279

        if Name:

   280

            toks = Name.split('.')

   281

            return self._GetChildBySomething("Name", toks)

   282

        else:

   283

            return self

   284

   285

    def GetChildByIECLocation(self, Location):

   286

        if Location:

   287

            return self._GetChildBySomething("IEC_Channel", Location)

   288

        else:

   289

            return self

   290

   291

    def GetCurrentLocation(self):

   292

        """

   293

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

   294

        """

   295

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

   296

   297

    def GetCurrentName(self):

   298

        """

   299

        @return:  String "ParentParentName.ParentName.Name"

   300

        """

   301

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

   302

   303

    def _GetCurrentName(self):

   304

        """

   305

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

   306

        """

   307

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

   308

   309

    def GetCTRoot(self):

   310

        return self.CTNParent.GetCTRoot()

   311

   312

    def GetFullIEC_Channel(self):

   313

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

   314

   315

    def GetLocations(self):

   316

        location = self.GetCurrentLocation()

   317

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

   318

   319

    def GetVariableLocationTree(self):

   320

        '''

   321

        This function is meant to be overridden by confnodes.

   322

   323

        It should returns an list of dictionaries

   324

   325

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

   326

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

   327

        '''

   328

        children = []

   329

        for child in self.IECSortedChildren():

   330

            children.append(child.GetVariableLocationTree())

   331

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

   332

                "type": LOCATION_CONFNODE,

   333

                "location": self.GetFullIEC_Channel(),

   334

                "children": children}

   335

   336

    def FindNewName(self, DesiredName):

   337

        """

   338

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

   339

        @param DesiredName: The desired Name (string)

   340

        """

   341

        # Get Current Name

   342

        CurrentName = self.BaseParams.getName()

   343

        # Do nothing if no change

   344

        #if CurrentName == DesiredName: return CurrentName

   345

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

   346

        AllNames=[]

   347

        for CTNInstance in self.CTNParent.IterChildren():

   348

            if CTNInstance != self:

   349

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

   350

   351

        # Find a free name, eventually appending digit

   352

        res = DesiredName

   353

        suffix = 1

   354

        while res in AllNames:

   355

            res = "%s-%d"%(DesiredName, suffix)

   356

            suffix += 1

   357

   358

        # Get old path

   359

        oldname = self.CTNPath()

   360

        # Check previous confnode existance

   361

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

   362

        # Set the new name

   363

        self.BaseParams.setName(res)

   364

        # Rename confnode dir if exist

   365

        if not dontexist:

   366

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

   367

        # warn user he has two left hands

   368

        if DesiredName != res:

   369

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

   370

        return res

   371

   372

    def GetAllChannels(self):

   373

        AllChannels=[]

   374

        for CTNInstance in self.CTNParent.IterChildren():

   375

            if CTNInstance != self:

   376

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

   377

        AllChannels.sort()

   378

        return AllChannels

   379

   380

    def FindNewIEC_Channel(self, DesiredChannel):

   381

        """

   382

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

   383

        @param DesiredChannel: The desired IEC channel (int)

   384

        """

   385

        # Get Current IEC channel

   386

        CurrentChannel = self.BaseParams.getIEC_Channel()

   387

        # Do nothing if no change

   388

        #if CurrentChannel == DesiredChannel: return CurrentChannel

   389

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

   390

        AllChannels = self.GetAllChannels()

   391

   392

        # Now, try to guess the nearest available channel

   393

        res = DesiredChannel

   394

        while res in AllChannels: # While channel not free

   395

            if res < CurrentChannel: # Want to go down ?

   396

                res -=  1 # Test for n-1

   397

                if res < 0 :

   398

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

   399

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

   400

            else : # Want to go up ?

   401

                res +=  1 # Test for n-1

   402

        # Finally set IEC Channel

   403

        self.BaseParams.setIEC_Channel(res)

   404

        return res

   405

   406

    def _OpenView(self, name=None):

   407

        if self.EditorType is not None and self._View is None:

   408

            app_frame = self.GetCTRoot().AppFrame

   409

   410

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

   411

   412

            app_frame.EditProjectElement(self._View, self.CTNName())

   413

   414

            return self._View

   415

        return None

   416

   417

    def OnCloseEditor(self, view):

   418

        if self._View == view:

   419

            self._View = None

   420

   421

    def OnCTNClose(self):

   422

        if self._View is not None:

   423

            app_frame = self.GetCTRoot().AppFrame

   424

            if app_frame is not None:

   425

                app_frame.DeletePage(self._View)

   426

        return True

   427

   428

    def _doRemoveChild(self, CTNInstance):

   429

        # Remove all children of child

   430

        for SubCTNInstance in CTNInstance.IterChildren():

   431

            CTNInstance._doRemoveChild(SubCTNInstance)

   432

        # Call the OnCloseMethod

   433

        CTNInstance.OnCTNClose()

   434

        # Delete confnode dir

   435

        shutil.rmtree(CTNInstance.CTNPath())

   436

        # Remove child of Children

   437

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

   438

        # Forget it... (View have to refresh)

   439

   440

    def CTNRemove(self):

   441

        # Fetch the confnode

   442

        #CTNInstance = self.GetChildByName(CTNName)

   443

        # Ask to his parent to remove it

   444

        self.CTNParent._doRemoveChild(self)

   445

   446

    def CTNAddChild(self, CTNName, CTNType, IEC_Channel=0):

   447

        """

   448

        Create the confnodes that may be added as child to this node self

   449

        @param CTNType: string desining the confnode class name (get name from CTNChildrenTypes)

   450

        @param CTNName: string for the name of the confnode instance

   451

        """

   452

        # reorganize self.CTNChildrenTypes tuples from (name, CTNClass, Help)

   453

        # to ( name, (CTNClass, Help)), an make a dict

   454

        transpose = zip(*self.CTNChildrenTypes)

   455

        CTNChildrenTypes = dict(zip(transpose[0],zip(transpose[1],transpose[2])))

   456

        # Check that adding this confnode is allowed

   457

        try:

   458

            CTNClass, CTNHelp = CTNChildrenTypes[CTNType]

   459

        except KeyError:

   460

            raise Exception, _("Cannot create child %s of type %s ")%(CTNName, CTNType)

   461

   462

        # if CTNClass is a class factory, call it. (prevent unneeded imports)

   463

        if type(CTNClass) == types.FunctionType:

   464

            CTNClass = CTNClass()

   465

   466

        # Eventualy Initialize child instance list for this class of confnode

   467

        ChildrenWithSameClass = self.Children.setdefault(CTNType, list())

   468

        # Check count

   469

        if getattr(CTNClass, "CTNMaxCount", None) and len(ChildrenWithSameClass) >= CTNClass.CTNMaxCount:

   470

            raise Exception, _("Max count (%d) reached for this confnode of type %s ")%(CTNClass.CTNMaxCount, CTNType)

   471

   472

        # create the final class, derived of provided confnode and template

   473

        class FinalCTNClass(CTNClass, ConfigTreeNode):

   474

            """

   475

            ConfNode class is derivated into FinalCTNClass before being instanciated

   476

            This way __init__ is overloaded to ensure ConfigTreeNode.__init__ is called 

   477

            before CTNClass.__init__, and to do the file related stuff.

   478

            """

   479

            def __init__(_self):

   480

                # self is the parent