1

"""

     2

Base definitions for beremiz plugins

     3

"""

     4

     5

import os

     7

import types

     8

import shutil

     9

from xml.dom import minidom

    10

from xmlclass import GenerateClassesFromXSDstring

    11

    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"/>

    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 = []

    48

        # Create BaseParam 

    49

        self.BaseParams = _BaseParamsClass()

    51

        self._AddParamsMembers()

    52

        self.PluggedChilds = {}

    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

    81

    def PlugRequestSave(self):

    82

        # If plugin do not have corresponding directory

    85

            # Create it

   103

   104

        # Call the plugin specific OnPlugSave method

   108

   109

        # go through all childs and do the same

   110

        for PlugChild in self.IterChilds():

   115

   116

    def PlugImport(self, src_PlugPath):

   117

        shutil.copytree(src_PlugPath, self.PlugPath)

   118

        return True

   119

   120

    def PlugGenerate_C(self, buildpath, current_location, locations):

   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 \

   126

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

   127

        """

   128

        return [],""

   129

   130

    def _Generate_C(self, buildpath, current_location, locations):

   131

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

   132

        PlugCFilesAndCFLAGS, PlugLDFLAGS = self.PlugGenerate_C(buildpath, current_location, locations)

   133

        # recurse through all childs, and stack their results

   134

        for PlugChild in self.IterChilds():

   135

            # Compute chile IEC location

   136

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

   137

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

   138

            CFilesAndCFLAGS, LDFLAGS = \

   139

                PlugChild._Generate_C(

   140

                    #keep the same path

   141

                    buildpath,

   142

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

   143

                    new_location,

   144

                    # filter locations that start with current IEC location

   145

                    [ (l,d,t,n) for l,d,t,n in locations if l[0:len(new_location)] == new_location ])

   146

            # stack the result

   147

            PlugCFilesAndCFLAGS += CFilesAndCFLAGS

   148

            PlugLDFLAGS += LDFLAGS

   149

   150

        return PlugCFilesAndCFLAGS,PlugLDFLAGS

   151

   152

    def BlockTypesFactory(self):

   153

        return []

   154

   155

    def STLibraryFactory(self):

   156

        return ""

   157

   158

    def IterChilds(self):

   159

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

   160

            for PlugInstance in PluggedChilds:

   161

                   yield PlugInstance

   162

   163

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

   164

        toks = matching.split(sep,1)

   166

            # if match component of the name

   167

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

   168

                # if Name have other components

   169

                if len(toks) == 2:

   170

                    # Recurse in order to find the latest object

   171

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

   172

                # No sub name -> found

   173

                return PlugInstance

   174

        # Not found

   175

        return None

   176

   177

    def GetChildByName(self, Name):

   178

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

   179

   180

    def GetChildByIECLocation(self, Location):

   181

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

   182

   189

    def FindNewIEC_Channel(self, DesiredChannel):

   190

        """

   191

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

   192

        @param DesiredChannel: The desired IEC channel (int)

   193

        """

   194

        # Get Current IEC channel

   195

        CurrentChannel = self.BaseParams.getIEC_Channel()

   196

        # Do nothing if no change

   197

        if CurrentChannel == DesiredChannel: return CurrentChannel

   198

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

   199

        AllChannels=[]

   200

        for PlugInstance in self.PlugParent.IterChilds():

   201

            if PlugInstance != self:

   202

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

   203

        AllChannels.sort()

   204

   205

        # Now, try to guess the nearest available channel

   206

        res = DesiredChannel

   207

        while res in AllChannels: # While channel not free

   208

            if res < CurrentChannel: # Want to go down ?

   209

                res -=  1 # Test for n-1

   210

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

   211

            else : # Want to go up ?

   212

                res +=  1 # Test for n-1

   213

        # Finally set IEC Channel

   214

        self.BaseParams.setIEC_Channel(res)

   215

        return res

   216

   217

    def OnPlugClose(self):

   218

        return True

   219

   220

    def _doRemoveChild(self, PlugInstance):

   221

        # Remove all childs of child

   222

        for SubPlugInstance in PlugInstance.IterChilds():

   223

            PlugInstance._doRemoveChild(SubPlugInstance)

   224

        # Call the OnCloseMethod

   225

        PlugInstance.OnPlugClose()

   226

        # Delete plugin dir

   227

        shutil.rmtree(PlugInstance.PlugPath())

   228

        # Remove child of PluggedChilds

   229

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

   230

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

   231

   232

    def PlugRemoveChild(self, PlugName):

   233

        # Fetch the plugin

   234

        PlugInstance = self.GetChildByName(PlugName)

   235

        # Ask to his parent to remove it

   236

        PlugInstance.PlugParent._doRemoveChild(PlugInstance)

   237

   238

    def PlugAddChild(self, PlugName, PlugType):

   239

        """

   240

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

   241

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

   242

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

   243

        """

   244

        PlugChildsTypes = dict(self.PlugChildsTypes)

   245

        # Check that adding this plugin is allowed

   246

        try:

   247

            PlugClass = PlugChildsTypes[PlugType]

   248

        except KeyError:

   249

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

   250

   251

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

   252

        if type(PlugClass) == types.FunctionType:

   253

            PlugClass = PlugClass()

   254

   255

        # Eventualy Initialize child instance list for this class of plugin

   257

        # Check count

   260

   261

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

   262

        class FinalPlugClass(PlugClass, PlugTemplate):

   263

            """

   264

            Plugin class is derivated into FinalPlugClass before being instanciated

   265

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

   266

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

   267

            """

   268

            def __init__(_self):

   269

                # self is the parent

   270

                _self.PlugParent = self

   271

                # Keep track of the plugin type name

   272

                _self.PlugType = PlugType

   273

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

   274

                PlugTemplate.__init__(_self)

   275

                # If dir have already be made, and file exist

   276

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

   277

                    #Load the plugin.xml file into parameters members

   279

                    # Check that IEC_Channel is not already in use.

   280

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

   281

                    # Call the plugin real __init__

   284

                    #Load and init all the childs

   285

                    _self.LoadChilds()

   286

                else:

   287

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

   288

                    # Set plugin name

   289

                    _self.BaseParams.setName(PlugName)

   291

                    # Find an IEC number

   292

                    _self.FindNewIEC_Channel(0)

   293

                    # Call the plugin real __init__

   297

   298

        # Create the object out of the resulting class

   299

        newPluginOpj = FinalPlugClass()

   300

        # Store it in PluggedChils

   301

        PluggedChildsWithSameClass.append(newPluginOpj)

   302

   303

        return newPluginOpj

   304

   305

   315

        # Get the xml tree

   330

   331

    def LoadChilds(self):

   332

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

   333

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

   335

               PlugDir.count(NameTypeSeparator) == 1:

   336

                try:

   338

                except Exception, e:

   339

                    print e

   340

   346

class PluginsRoot(PlugTemplate):

   347

   348

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

   350

   351

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

   352

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

   353

      <xsd:simpleType name="Win32Compiler">

   354

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

   355

          <xsd:enumeration value="Cygwin"/>

   356

          <xsd:enumeration value="MinGW"/>

   357

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

   358

        </xsd:restriction>

   359

      </xsd:simpleType>

   360

      <xsd:element name="BeremizRoot">

   361

        <xsd:complexType>

   362

          <xsd:element name="TargetType">

   363

            <xsd:complexType>

   364

              <xsd:choice>

   365

                <xsd:element name="Win32">

   366

                  <xsd:complexType>

   367

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

   369

                  </xsd:complexType>

   370

                </xsd:element>

   371

                <xsd:element name="Linux">

   372

                  <xsd:complexType>

   373

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

   375

                  </xsd:complexType>

   376

                </xsd:element>

   377

                <xsd:element name="Xenomai">

   378

                  <xsd:complexType>

   379

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

   382

                  </xsd:complexType>

   383

                </xsd:element>

   384

                <xsd:element name="RTAI">

   385

                  <xsd:complexType>

   389

                  </xsd:complexType>

   390

                </xsd:element>

   391

                <xsd:element name="Library">

   392

                  <xsd:complexType>

   395

                  </xsd:complexType>

   396

                </xsd:element>

   397

              </xsd:choice>

   398

            </xsd:complexType>

   399

          </xsd:element>

   400

        </xsd:complexType>

   401

      </xsd:element>

   402

    </xsd:schema>

   403

    """

   404

   407

        # self is the parent

   408

        self.PlugParent = None

   409

        # Keep track of the plugin type name

   410

        self.PlugType = "Beremiz"

   466

        # Change XSD into class members

   467

        self._AddParamsMembers()

   468

        self.PluggedChilds = {}

   469

        # No IEC channel, name, etc...

   470

        self.MandatoryParams = []