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]

    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

    78

        else:

    92

    93

    def PlugRequestSave(self):

    94

        # If plugin do not have corresponding directory

    95

        plugpath = self.PlugPath()

    96

        if not os.path.isdir(plugpath):

    97

            # Create it

    98

            os.mkdir(plugpath)

    99

   100

        # generate XML for base XML parameters controller of the plugin

   101

        basexmlfilepath = self.PluginBaseXmlFilePath()

   102

        if basexmlfilepath:

   103

            BaseXMLFile = open(basexmlfilepath,'w')

   104

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

   105

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

   106

            BaseXMLFile.close()

   107

   108

        # generate XML for XML parameters controller of the plugin

   109

        xmlfilepath = self.PluginXmlFilePath()

   110

        if xmlfilepath:

   111

            XMLFile = open(xmlfilepath,'w')

   112

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

   113

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

   114

            XMLFile.close()

   115

   116

        # Call the plugin specific OnPlugSave method

   117

        result = self.OnPlugSave()

   118

        if not result:

   119

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

   120

   121

        # go through all childs and do the same

   122

        for PlugChild in self.IterChilds():

   123

            result = PlugChild.PlugRequestSave()

   124

            if result:

   125

                return result

   126

        return None

   127

   128

    def PlugImport(self, src_PlugPath):

   129

        shutil.copytree(src_PlugPath, self.PlugPath)

   130

        return True

   131

   132

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

   133

        """

   134

        Generate C code

   135

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

   136

        @param locations: List of complete variables locations \

   137

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

   138

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

   139

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

   140

        """

   141

        logger.write_warning(".".join(map(lambda x:str(x), current_location)) + " -> Nothing yo do")

   142

        return [],""

   143

   144

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

   145

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

   146

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

   147

        # recurse through all childs, and stack their results

   148

        for PlugChild in self.IterChilds():

   149

            # Compute child's IEC location

   150

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

   151

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

   152

            CFilesAndCFLAGS, LDFLAGS = \

   153

                PlugChild._Generate_C(

   154

                    #keep the same path

   155

                    buildpath,

   156

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

   157

                    new_location,

   158

                    # filter locations that start with current IEC location

   159

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

   160

                    #propagete logger

   161

                    logger)

   162

            # stack the result

   163

            PlugCFilesAndCFLAGS += CFilesAndCFLAGS

   164

            PlugLDFLAGS += LDFLAGS

   165

   166

        return PlugCFilesAndCFLAGS,PlugLDFLAGS

   167

   168

    def BlockTypesFactory(self):

   169

        return []

   170

   171

    def STLibraryFactory(self):

   172

        return ""

   173

   174

    def IterChilds(self):

   175

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

   176

            for PlugInstance in PluggedChilds:

   177

                   yield PlugInstance

   178

   179

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

   180

        toks = matching.split(sep,1)

   181

        for PlugInstance in self.IterChilds():

   182

            # if match component of the name

   183

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

   184

                # if Name have other components

   185

                if len(toks) == 2:

   186

                    # Recurse in order to find the latest object

   187

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

   188

                # No sub name -> found

   189

                return PlugInstance

   190

        # Not found

   191

        return None

   192

   193

    def GetChildByName(self, Name):

   194

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

   195

   196

    def GetChildByIECLocation(self, Location):

   197

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

   198

   199

    def GetPlugInfos(self):

   200

        childs = []

   201

        for child in self.IterChilds():

   202

            childs.append(child.GetPlugInfos())

   203

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

   204

   205

    def FindNewIEC_Channel(self, DesiredChannel):

   206

        """

   207

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

   208

        @param DesiredChannel: The desired IEC channel (int)

   209

        """

   210

        # Get Current IEC channel

   211

        CurrentChannel = self.BaseParams.getIEC_Channel()

   212

        # Do nothing if no change

   213

        if CurrentChannel == DesiredChannel: return CurrentChannel

   214

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

   215

        AllChannels=[]

   216

        for PlugInstance in self.PlugParent.IterChilds():

   217

            if PlugInstance != self:

   218

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

   219

        AllChannels.sort()

   220

   221

        # Now, try to guess the nearest available channel

   222

        res = DesiredChannel

   223

        while res in AllChannels: # While channel not free

   224

            if res < CurrentChannel: # Want to go down ?

   225

                res -=  1 # Test for n-1

   226

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

   227

            else : # Want to go up ?

   228

                res +=  1 # Test for n-1

   229

        # Finally set IEC Channel

   230

        self.BaseParams.setIEC_Channel(res)

   231

        return res

   232

   233

    def OnPlugClose(self):

   234

        return True

   235

   236

    def _doRemoveChild(self, PlugInstance):

   237

        # Remove all childs of child

   238

        for SubPlugInstance in PlugInstance.IterChilds():

   239

            PlugInstance._doRemoveChild(SubPlugInstance)

   240

        # Call the OnCloseMethod

   241

        PlugInstance.OnPlugClose()

   242

        # Delete plugin dir

   243

        shutil.rmtree(PlugInstance.PlugPath())

   244

        # Remove child of PluggedChilds

   245

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

   246

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

   247

   248

    def PlugRemoveChild(self, PlugName):

   249

        # Fetch the plugin

   250

        PlugInstance = self.GetChildByName(PlugName)

   251

        # Ask to his parent to remove it

   252

        PlugInstance.PlugParent._doRemoveChild(PlugInstance)

   253

   254

    def PlugAddChild(self, PlugName, PlugType):

   255

        """

   256

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

   257

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

   258

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

   259

        """

   260

        PlugChildsTypes = dict(self.PlugChildsTypes)

   261

        # Check that adding this plugin is allowed

   262

        try:

   263

            PlugClass = PlugChildsTypes[PlugType]

   264

        except KeyError:

   265

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

   266

   267

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

   268

        if type(PlugClass) == types.FunctionType:

   269

            PlugClass = PlugClass()

   270

   271

        # Eventualy Initialize child instance list for this class of plugin

   272

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

   273

        # Check count

   274

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

   275

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

   276

   277

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

   278

        class FinalPlugClass(PlugClass, PlugTemplate):

   279

            """

   280

            Plugin class is derivated into FinalPlugClass before being instanciated

   281

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

   282

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

   283

            """

   284

            def __init__(_self):

   285

                # self is the parent

   286

                _self.PlugParent = self

   287

                # Keep track of the plugin type name

   288

                _self.PlugType = PlugType

   289

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

   290

                PlugTemplate.__init__(_self)

   291

                # If dir have already be made, and file exist

   292

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

   293

                    #Load the plugin.xml file into parameters members

   294

                    _self.LoadXMLParams(PlugName)

   295

                    # Check that IEC_Channel is not already in use.

   296

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

   297

                    # Call the plugin real __init__

   298

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

   299

                        PlugClass.__init__(_self)

   300

                    #Load and init all the childs

   301

                    _self.LoadChilds()

   302

                else:

   303

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

   304

                    # Set plugin name

   305

                    _self.BaseParams.setName(PlugName)

   306

                    os.mkdir(_self.PlugPath())

   307

                    # Find an IEC number

   308

                    _self.FindNewIEC_Channel(0)

   309

                    # Call the plugin real __init__

   310

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

   311

                        PlugClass.__init__(_self)

   312

                    _self.PlugRequestSave()

   313

   314

        # Create the object out of the resulting class

   315

        newPluginOpj = FinalPlugClass()

   316

        # Store it in PluggedChils

   317

        PluggedChildsWithSameClass.append(newPluginOpj)

   318

   319

        return newPluginOpj

   320

   321

   322

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

   323

        # Get the base xml tree

   324

        basexmlfilepath = self.PluginBaseXmlFilePath(PlugName)

   325

        if basexmlfilepath:

   326

            basexmlfile = open(basexmlfilepath, 'r')

   327

            basetree = minidom.parse(basexmlfile)

   328

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

   329

            basexmlfile.close()

   330

   331

        # Get the xml tree

   332

        xmlfilepath = self.PluginXmlFilePath(PlugName)

   333

        if xmlfilepath:

   334

            xmlfile = open(xmlfilepath, 'r')

   335

            tree = minidom.parse(xmlfile)

   336

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

   337

            xmlfile.close()

   338

   339

        if test:

   340

            # Basic check. Better to fail immediately.

   341

            if not PlugName:

   342

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

   343

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

   344

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

   345

            # Now, self.PlugPath() should be OK

   346

   347

    def LoadChilds(self):

   348

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

   349

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

   350

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

   351

               PlugDir.count(NameTypeSeparator) == 1:

   352

                try:

   353

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

   354

                except Exception, e:

   355

                    print e

   356

   357

def _GetClassFunction(name):

   358

    def GetRootClass():

   359

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

   360

    return GetRootClass

   361

   362

class PluginsRoot(PlugTemplate):

   363

   364

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

   365

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

   366

   367

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

   368

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

   369

      <xsd:simpleType name="Win32Compiler">

   370

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

   371

          <xsd:enumeration value="Cygwin"/>

   372

          <xsd:enumeration value="MinGW"/>

   373

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

   374

        </xsd:restriction>

   375

      </xsd:simpleType>

   376

      <xsd:element name="BeremizRoot">

   377

        <xsd:complexType>

   378

          <xsd:element name="TargetType">

   379

            <xsd:complexType>

   380

              <xsd:choice>

   381

                <xsd:element name="Win32">

   382

                  <xsd:complexType>

   383

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

   384

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

   385

                  </xsd:complexType>

   386

                </xsd:element>

   387

                <xsd:element name="Linux">

   388

                  <xsd:complexType>

   389

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

   390

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

   391

                  </xsd:complexType>

   392

                </xsd:element>

   393

                <xsd:element name="Xenomai">

   394

                  <xsd:complexType>

   395

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

   396

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

   397

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

   398

                  </xsd:complexType>

   399

                </xsd:element>

   400

                <xsd:element name="RTAI">

   401

                  <xsd:complexType>

   402

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

   403

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

   404

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

   405

                  </xsd:complexType>

   406

                </xsd:element>

   407

                <xsd:element name="Library">

   408

                  <xsd:complexType>

   409

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

   410

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

   411

                  </xsd:complexType>

   412

                </xsd:element>

   413

              </xsd:choice>

   414

            </xsd:complexType>

   415

          </xsd:element>

   416

        </xsd:complexType>

   417

      </xsd:element>

   418

    </xsd:schema>

   419

    """

   420

   421

    def __init__(self):

   422

        PlugTemplate.__init__(self)

   423

        # self is the parent

   424

        self.PlugParent = None

   425

        # Keep track of the plugin type name

   426

        self.PlugType = "Beremiz"

   427

   428

        self.ProjectPath = ""

   429

        self.PLCManager = None

   430

   431

    def HasProjectOpened(self):

   432

        """

   433

        Return if a project is actually opened

   434

        """

   435

        return self.ProjectPath != ""

   436

   437

    def GetProjectPath(self):

   438

        return self.ProjectPath

   439

   440

    def NewProject(self, ProjectPath, PLCParams):

   441

        """

   442

        Create a new project in an empty folder

   443

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

   444

        @param PLCParams: properties of the PLCOpen program created

   445

        """

   446

        # Verify that choosen folder is empty

   447

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

   448

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

   449

        # Create Controler for PLCOpen program

   450

        self.PLCManager = PLCControler()

   451

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

   452

        self.PLCManager.SetProjectProperties(properties = PLCParams)

   453

        # Change XSD into class members

   454

        self._AddParamsMembers()

   455

        self.PluggedChilds = {}

   456

        # No IEC channel, name, etc...

   457

        self.MandatoryParams = []

   458

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

   459

        self.ProjectPath = ProjectPath

   460

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

   461

        return None

   462

   463

    def LoadProject(self, ProjectPath):

   464

        """

   465

        Load a project contained in a folder

   466

        @param ProjectPath: path of the project folder

   467

        """

   468

        # Verify that project contains a PLCOpen program

   469

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

   470

        if not os.path.isfile(plc_file):

   471

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

   472

        # Create Controler for PLCOpen program

   473

        self.PLCManager = PLCControler()

   474

        # Load PLCOpen file

   475

        result = self.PLCManager.OpenXMLFile(plc_file)

   476

        if result:

   477

            return result

   478

        # Change XSD into class members

   479

        self._AddParamsMembers()

   480

        self.PluggedChilds = {}

   481

        # No IEC channel, name, etc...

   482

        self.MandatoryParams = None

   483

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

   484

        self.ProjectPath = ProjectPath

   485

        # If dir have already be made, and file exist

   486

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

   487

            #Load the plugin.xml file into parameters members

   488

            result = self.LoadXMLParams(test = False)

   489

            if result:

   490

                return result

   491

            #Load and init all the childs

   492

            self.LoadChilds()

   493

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

   494

        return None