1

"""

     2

Base definitions for beremiz plugins

     3

"""

     4

     5

import os

     6

import plugins

     7

import types

     8

import shutil

     9

from xml.dom import minidom

    10

from xmlclass import GenerateClassesFromXSDstring

    11

    12

from PLCControler import PLCControler

    13

    14

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

    15

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

    16

          <xsd:element name="BaseParams">

    17

            <xsd:complexType>

    18

              <xsd:attribute name="Name" type="xsd:string" use="required"/>

    19

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

    20

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

    21

            </xsd:complexType>

    22

          </xsd:element>

    23

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

    24

    25

NameTypeSeparator = '@'

    26

    27

class PlugTemplate:

    28

    """

    29

    This class is the one that define plugins.

    30

    """

    31

    32

    XSD = None

    33

    PlugChildsTypes = []

    34

    PlugMaxCount = None

    35

    PluginMethods = []

    36

    37

    def _AddParamsMembers(self):

    38

        Classes = GenerateClassesFromXSDstring(self.XSD)[0]

    39

        self.PlugParams = []

    40

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

    41

        if len(Classes) == 1:

    42

            name, XSDclass = Classes[0]

    43

            obj = XSDclass()

    44

            self.PlugParams = (name, obj)

    45

            setattr(self, name, obj)

    46

    47

    def __init__(self):

    48

        # Create BaseParam 

    49

        self.BaseParams = _BaseParamsClass()

    50

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

    51

        self._AddParamsMembers()

    52

        self.PluggedChilds = {}

    53

    54

    def PluginBaseXmlFilePath(self, PlugName=None):

    55

        return os.path.join(self.PlugPath(PlugName), "baseplugin.xml")

    56

    57

    def PluginXmlFilePath(self, PlugName=None):

    58

        return os.path.join(self.PlugPath(PlugName), "plugin.xml")

    59

    60

    def PlugPath(self,PlugName=None):

    61

        if not PlugName:

    62

            PlugName = self.BaseParams.getName()

    63

        return os.path.join(self.PlugParent.PlugPath(), PlugName + NameTypeSeparator + self.PlugType)

    64

    65

    def PlugTestModified(self):

    66

        return False

    67

    68

    def OnPlugSave(self):

    69

        return True

    70

    71

    def GetPlugParamsAttributes(self):

    72

        return self.PlugParams[1].getElementAttributes()

    73

    74

    def SetPlugParamsAttribute(self, name, value):

    75

        attr = getattr(self.PlugParams[1], name, None)

    76

        if isinstance(attr, types.ClassType):

    77

            attr.SetValue(value)

    78

        else:

    79

            setattr(self.PlugParams[1], name, value)

    80

    81

    def PlugRequestSave(self):

    82

        # If plugin do not have corresponding directory

    83

        plugpath = self.PlugPath()

    84

        if not os.path.isdir(plugpath):

    85

            # Create it

    86

            os.mkdir(plugpath)

    87

    88

        # generate XML for base XML parameters controller of the plugin

    89

        basexmlfilepath = self.PluginBaseXmlFilePath()

    90

        if basexmlfilepath:

    91

            BaseXMLFile = open(basexmlfilepath,'w')

    92

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

    93

            BaseXMLFile.write(self.MandatoryParams[1].generateXMLText(self.MandatoryParams[0], 0))

    94

            BaseXMLFile.close()

    95

    96

        # generate XML for XML parameters controller of the plugin

    97

        xmlfilepath = self.PluginXmlFilePath()

    98

        if xmlfilepath:

    99

            XMLFile = open(xmlfilepath,'w')

   100

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

   101

            XMLFile.write(self.PlugParams[1].generateXMLText(self.PlugParams[0], 0))

   102

            XMLFile.close()

   103

   104

        # Call the plugin specific OnPlugSave method

   105

        result = self.OnPlugSave()

   106

        if not result:

   107

            return "Error while saving \"%s\""%self.PlugPath()

   108

   109

        # go through all childs and do the same

   110

        for PlugChild in self.IterChilds():

   111

            result = PlugChild.PlugRequestSave()

   112

            if result:

   113

                return result

   114

        return None

   115

   116

    def PlugImport(self, src_PlugPath):

   117

        shutil.copytree(src_PlugPath, self.PlugPath)

   118

        return True

   119

   121

        """

   122

        Generate C code

   123

        @param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)

   124

        @param locations: List of complete variables locations \

   125

            [(IEC_loc, IEC_Direction, IEC_Type, Name)]\

   126

            ex: [((0,0,4,5),'I','STRING','__IX_0_0_4_5'),...]

   130

        return [],""

   131

   133

        # Generate plugins [(Cfiles, CFLAGS)], LDFLAGS

   135

        # recurse through all childs, and stack their results

   136

        for PlugChild in self.IterChilds():

   138

            new_location = current_location + (self.BaseParams.getIEC_Channel())

   139

            # Get childs [(Cfiles, CFLAGS)], LDFLAGS

   140

            CFilesAndCFLAGS, LDFLAGS = \

   141

                PlugChild._Generate_C(

   142

                    #keep the same path

   143

                    buildpath,

   144

                    # but update location (add curent IEC channel at the end)

   145

                    new_location,

   146

                    # filter locations that start with current IEC location

   150

            # stack the result

   151

            PlugCFilesAndCFLAGS += CFilesAndCFLAGS

   152

            PlugLDFLAGS += LDFLAGS

   153

   154

        return PlugCFilesAndCFLAGS,PlugLDFLAGS

   155

   156

    def BlockTypesFactory(self):

   157

        return []

   158

   159

    def STLibraryFactory(self):

   160

        return ""

   161

   162

    def IterChilds(self):

   163

        for PlugType, PluggedChilds in self.PluggedChilds.items():

   164

            for PlugInstance in PluggedChilds:

   165

                   yield PlugInstance

   166

   167

    def _GetChildBySomething(self, sep, something, matching):

   168

        toks = matching.split(sep,1)

   169

        for PlugInstance in self.IterChilds():

   170

            # if match component of the name

   171

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

   172

                # if Name have other components

   173

                if len(toks) == 2:

   174

                    # Recurse in order to find the latest object

   175

                    return PlugInstance._GetChildBySomething( sep, something, toks[1])

   176

                # No sub name -> found

   177

                return PlugInstance

   178

        # Not found

   179

        return None

   180

   181

    def GetChildByName(self, Name):

   182

        return self._GetChildBySomething('.',"Name", Name)

   183

   184

    def GetChildByIECLocation(self, Location):

   185

        return self._GetChildBySomething('_',"IEC_Channel", Name)

   186

   187

    def GetPlugInfos(self):

   188

        childs = []

   189

        for child in self.IterChilds():

   190

            childs.append(child.GetPlugInfos())

   191

        return {"name" : self.BaseParams.getName(), "type" : None, "values" : childs}

   192

   193

    def FindNewIEC_Channel(self, DesiredChannel):

   194

        """

   195

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

   196

        @param DesiredChannel: The desired IEC channel (int)

   197

        """

   198

        # Get Current IEC channel

   199

        CurrentChannel = self.BaseParams.getIEC_Channel()

   200

        # Do nothing if no change

   201

        if CurrentChannel == DesiredChannel: return CurrentChannel

   202

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

   203

        AllChannels=[]

   204

        for PlugInstance in self.PlugParent.IterChilds():

   205

            if PlugInstance != self:

   206

                AllChannels.append(PlugInstance.BaseParams.getIEC_Channel())

   207

        AllChannels.sort()

   208

   209

        # Now, try to guess the nearest available channel

   210

        res = DesiredChannel

   211

        while res in AllChannels: # While channel not free

   212

            if res < CurrentChannel: # Want to go down ?

   213

                res -=  1 # Test for n-1

   214

                if res < 0 : return CurrentChannel # Can't go bellow 0, do nothing

   215

            else : # Want to go up ?

   216

                res +=  1 # Test for n-1

   217

        # Finally set IEC Channel

   218

        self.BaseParams.setIEC_Channel(res)

   219

        return res

   220

   221

    def OnPlugClose(self):

   222

        return True

   223

   224

    def _doRemoveChild(self, PlugInstance):

   225

        # Remove all childs of child

   226

        for SubPlugInstance in PlugInstance.IterChilds():

   227

            PlugInstance._doRemoveChild(SubPlugInstance)

   228

        # Call the OnCloseMethod

   229

        PlugInstance.OnPlugClose()

   230

        # Delete plugin dir

   231

        shutil.rmtree(PlugInstance.PlugPath())

   232

        # Remove child of PluggedChilds

   233

        self.PluggedChilds[PlugInstance.PlugType].remove(PlugInstance)

   234

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

   235

   236

    def PlugRemoveChild(self, PlugName):

   237

        # Fetch the plugin

   238

        PlugInstance = self.GetChildByName(PlugName)

   239

        # Ask to his parent to remove it

   240

        PlugInstance.PlugParent._doRemoveChild(PlugInstance)

   241

   242

    def PlugAddChild(self, PlugName, PlugType):

   243

        """

   244

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

   245

        @param PlugType: string desining the plugin class name (get name from PlugChildsTypes)

   246

        @param PlugName: string for the name of the plugin instance

   247

        """

   248

        PlugChildsTypes = dict(self.PlugChildsTypes)

   249

        # Check that adding this plugin is allowed

   250

        try:

   251

            PlugClass = PlugChildsTypes[PlugType]

   252

        except KeyError:

   253

            raise Exception, "Cannot create child %s of type %s "%(PlugName, PlugType)

   254

   255

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

   256

        if type(PlugClass) == types.FunctionType:

   257

            PlugClass = PlugClass()

   258

   259

        # Eventualy Initialize child instance list for this class of plugin

   260

        PluggedChildsWithSameClass = self.PluggedChilds.setdefault(PlugType, list())

   261

        # Check count

   262

        if getattr(PlugClass, "PlugMaxCount", None) and len(PluggedChildsWithSameClass) >= PlugClass.PlugMaxCount:

   263

            raise Exception, "Max count (%d) reached for this plugin of type %s "%(PlugClass.PlugMaxCount, PlugType)

   264

   265

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

   266

        class FinalPlugClass(PlugClass, PlugTemplate):

   267

            """

   268

            Plugin class is derivated into FinalPlugClass before being instanciated

   269

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

   270

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

   271

            """

   272

            def __init__(_self):

   273

                # self is the parent

   274

                _self.PlugParent = self

   275

                # Keep track of the plugin type name

   276

                _self.PlugType = PlugType

   277

                # Call the base plugin template init - change XSD into class members

   278

                PlugTemplate.__init__(_self)

   279

                # If dir have already be made, and file exist

   280

                if os.path.isdir(_self.PlugPath(PlugName)) and os.path.isfile(_self.PluginXmlFilePath(PlugName)):

   281

                    #Load the plugin.xml file into parameters members

   282

                    _self.LoadXMLParams(PlugName)

   283

                    # Check that IEC_Channel is not already in use.

   284

                    self.FindNewIEC_Channel(self.BaseParams.getIEC_Channel())

   285

                    # Call the plugin real __init__

   286

                    if getattr(PlugClass, "__init__", None):

   287

                        PlugClass.__init__(_self)

   288

                    #Load and init all the childs

   289

                    _self.LoadChilds()

   290

                else:

   291

                    # If plugin do not have corresponding file/dirs - they will be created on Save

   292

                    # Set plugin name

   293

                    _self.BaseParams.setName(PlugName)

   294

                    os.mkdir(_self.PlugPath())

   295

                    # Find an IEC number

   296

                    _self.FindNewIEC_Channel(0)

   297

                    # Call the plugin real __init__

   298

                    if getattr(PlugClass, "__init__", None):

   299

                        PlugClass.__init__(_self)

   300

                    _self.PlugRequestSave()

   301

   302

        # Create the object out of the resulting class

   303

        newPluginOpj = FinalPlugClass()

   304

        # Store it in PluggedChils

   305

        PluggedChildsWithSameClass.append(newPluginOpj)

   306

   307

        return newPluginOpj

   308

   309

   310

    def LoadXMLParams(self, PlugName = None, test = True):

   311

        # Get the base xml tree

   312

        basexmlfilepath = self.PluginBaseXmlFilePath(PlugName)

   313

        if basexmlfilepath:

   314

            basexmlfile = open(basexmlfilepath, 'r')

   315

            basetree = minidom.parse(basexmlfile)

   316

            self.MandatoryParams[1].loadXMLTree(basetree.childNodes[0])

   317

            basexmlfile.close()

   318

   319

        # Get the xml tree

   320

        xmlfilepath = self.PluginXmlFilePath(PlugName)

   321

        if xmlfilepath:

   322

            xmlfile = open(xmlfilepath, 'r')

   323

            tree = minidom.parse(xmlfile)

   324

            self.PlugParams[1].loadXMLTree(tree.childNodes[0])

   325

            xmlfile.close()

   326

   327

        if test:

   328

            # Basic check. Better to fail immediately.

   329

            if not PlugName:

   330

                PlugName = os.path.split(self.PlugPath())[1].split(NameTypeSeparator)[0]

   331

            if (self.BaseParams.getName() != PlugName):

   332

                raise Exception, "Project tree layout do not match plugin.xml %s!=%s "%(PlugName, self.BaseParams.getName())

   333

            # Now, self.PlugPath() should be OK

   334

   335

    def LoadChilds(self):

   336

        # Iterate over all PlugName@PlugType in plugin directory, and try to open them

   337

        for PlugDir in os.listdir(self.PlugPath()):

   338

            if os.path.isdir(os.path.join(self.PlugPath(), PlugDir)) and \

   339

               PlugDir.count(NameTypeSeparator) == 1:

   340

                try:

   341

                    self.PlugAddChild(*PlugDir.split(NameTypeSeparator))

   342

                except Exception, e:

   343

                    print e

   344

   345

def _GetClassFunction(name):

   346

    def GetRootClass():

   347

        return getattr(__import__("plugins." + name), name).RootClass

   348

    return GetRootClass

   349

   350

class PluginsRoot(PlugTemplate):

   351

   352

    # For root object, available Childs Types are modules of the plugin packages.

   353

    PlugChildsTypes = [(name, _GetClassFunction(name)) for name in plugins.__all__]

   354

   355

    XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

   356

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

   357

      <xsd:simpleType name="Win32Compiler">

   358

        <xsd:restriction base="xsd:string">

   359

          <xsd:enumeration value="Cygwin"/>

   360

          <xsd:enumeration value="MinGW"/>

   361

          <xsd:enumeration value="VC++"/>

   362

        </xsd:restriction>

   363

      </xsd:simpleType>

   364

      <xsd:element name="BeremizRoot">

   365

        <xsd:complexType>

   366

          <xsd:element name="TargetType">

   367

            <xsd:complexType>

   368

              <xsd:choice>

   369

                <xsd:element name="Win32">

   370

                  <xsd:complexType>

   371

                    <xsd:attribute name="ToolChain" type="ppx:Win32Compiler" use="required" default="MinGW"/>

   372

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

   373

                  </xsd:complexType>

   374

                </xsd:element>

   375

                <xsd:element name="Linux">

   376

                  <xsd:complexType>

   377

                    <xsd:attribute name="Compiler" type="xsd:string" use="required" default="gcc"/>

   378

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

   379

                  </xsd:complexType>

   380

                </xsd:element>

   381

                <xsd:element name="Xenomai">

   382

                  <xsd:complexType>

   383

                    <xsd:attribute name="xeno-config" type="xsd:string" use="required" default="/usr/xenomai/"/>

   384

                    <xsd:attribute name="Compiler" type="xsd:string" use="required"/>

   385

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

   386

                  </xsd:complexType>

   387

                </xsd:element>

   388

                <xsd:element name="RTAI">

   389

                  <xsd:complexType>

   390

                    <xsd:attribute name="xeno-config" type="xsd:string" use="required"/>

   391

                    <xsd:attribute name="Compiler" type="xsd:string" use="required"/>

   392

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

   393

                  </xsd:complexType>

   394

                </xsd:element>

   395

                <xsd:element name="Library">

   396

                  <xsd:complexType>

   397

                    <xsd:attribute name="Dynamic" type="xsd:boolean" use="required" default="true"/>

   398

                    <xsd:attribute name="Compiler" type="xsd:string" use="required"/>

   399

                  </xsd:complexType>

   400

                </xsd:element>

   401

              </xsd:choice>

   402

            </xsd:complexType>

   403

          </xsd:element>

   404

        </xsd:complexType>

   405

      </xsd:element>

   406

    </xsd:schema>

   407

    """

   408

   409

    def __init__(self):

   410

        PlugTemplate.__init__(self)

   411

        # self is the parent

   412

        self.PlugParent = None

   413

        # Keep track of the plugin type name

   414

        self.PlugType = "Beremiz"

   415

   416

        self.ProjectPath = ""

   417

        self.PLCManager = None

   418

   419

    def HasProjectOpened(self):

   420

        """

   421

        Return if a project is actually opened

   422

        """

   423

        return self.ProjectPath != ""

   424

   425

    def GetProjectPath(self):

   426

        return self.ProjectPath

   427

   428

    def GetTargetTypes(self):

   429

        return self.BeremizRoot.TargetType.getChoices().keys()

   430

   431

    def ChangeTargetType(self, target_type):

   432

        self.BeremizRoot.TargetType.addContent(target_type)

   433

   434

    def GetTargetAttributes(self):

   435

        content = self.BeremizRoot.TargetType.getContent()

   436

        if content:

   437

            return content["value"].getElementAttributes()

   438

        else:

   439

            return []

   440

   441

    def SetTargetAttribute(self, name, value):

   442

        content = self.BeremizRoot.TargetType.getContent()

   443

        if content:

   444

            attr = getattr(content["value"], name, None)

   445

            if isinstance(attr, types.ClassType):

   446

                attr.SetValue(value)

   447

            else:

   448

                setattr(content["value"], name, value)

   449

   450

    def GetTargetType(self):

   451

        content = self.BeremizRoot.TargetType.getContent()

   452

        if content:

   453

            return content["name"]

   454

        else:

   455

            return ""

   456

   457

    def NewProject(self, ProjectPath, PLCParams):

   458

        """

   459

        Create a new project in an empty folder

   460

        @param ProjectPath: path of the folder where project have to be created

   461

        @param PLCParams: properties of the PLCOpen program created

   462

        """

   463

        # Verify that choosen folder is empty

   464

        if not os.path.isdir(ProjectPath) or len(os.listdir(ProjectPath)) > 0:

   465

            return "Folder choosen isn't empty. You can't use it for a new project!"

   466

        # Create Controler for PLCOpen program

   467

        self.PLCManager = PLCControler()

   468

        self.PLCManager.CreateNewProject(PLCParams.pop("projectName"))

   469

        self.PLCManager.SetProjectProperties(properties = PLCParams)

   470

        # Change XSD into class members

   471

        self._AddParamsMembers()

   472

        self.PluggedChilds = {}

   473

        # No IEC channel, name, etc...

   474

        self.MandatoryParams = []

   475

        # Keep track of the root plugin (i.e. project path)

   476

        self.ProjectPath = ProjectPath

   477

        self.BaseParams.setName(os.path.split(ProjectPath)[1])

   478

        return None

   479

   480

    def LoadProject(self, ProjectPath):

   481

        """

   482

        Load a project contained in a folder

   483

        @param ProjectPath: path of the project folder

   484

        """

   485

        # Verify that project contains a PLCOpen program

   486

        plc_file = os.path.join(ProjectPath, "plc.xml")

   487

        if not os.path.isfile(plc_file):

   488

            return "Folder choosen doesn't contain a program. It's not a valid project!"

   489

        # Create Controler for PLCOpen program

   490

        self.PLCManager = PLCControler()

   491

        # Load PLCOpen file

   492

        result = self.PLCManager.OpenXMLFile(plc_file)

   493

        if result:

   494

            return result