beremiz: comparison plugger.py

equal deleted inserted replaced

-:b2c02ca6271e
+:ee8cb104dbe0
 """
 Base definitions for beremiz plugins
 """
 import os
+import plugins
 import types
 import shutil
 from xml.dom import minidom
-import plugins
 from xmlclass import GenerateClassesFromXSDstring
+from PLCControler import PLCControler
 _BaseParamsClass = GenerateClassesFromXSDstring("""<?xml version="1.0" encoding="ISO-8859-1" ?>
 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <xsd:element name="BaseParams">
 <xsd:complexType>
 <xsd:attribute name="Name" type="xsd:string" use="required"/>
-<xsd:attribute name="IEC_Channel" type="xsd:integer" use="required"  default="-1"/>
+<xsd:attribute name="IEC_Channel" type="xsd:integer" use="required"/>
 <xsd:attribute name="Enabled" type="xsd:boolean" use="required" default="true"/>
 </xsd:complexType>
 </xsd:element>
 </xsd:schema>""")[0]["BaseParams"]
 PluginMethods = []
 def _AddParamsMembers(self):
 Classes = GenerateClassesFromXSDstring(self.XSD)[0]
 self.PlugParams = []
-for name, XSDclass in Classes.items():
+Classes = [(name, XSDclass) for name, XSDclass in Classes.items() if XSDclass.IsBaseClass]
-if XSDclass.IsBaseClass:
+if len(Classes) == 1:
-obj = XSDclass()
+name, XSDclass = Classes[0]
-self.PlugParams.append( (name, obj) )
+obj = XSDclass()
-setattr(self, name, obj)
+self.PlugParams = (name, obj)
+setattr(self, name, obj)
-def __init__(self, PlugPath):
+def __init__(self):
 # Create BaseParam
 self.BaseParams = _BaseParamsClass()
-self.MandatoryParams = [("BaseParams", self.BaseParams)]
+self.MandatoryParams = ("BaseParams", self.BaseParams)
 self._AddParamsMembers()
 self.PluggedChilds = {}
+def PluginBaseXmlFilePath(self, PlugName=None):
+return os.path.join(self.PlugPath(PlugName), "baseplugin.xml")
 def PluginXmlFilePath(self, PlugName=None):
 return os.path.join(self.PlugPath(PlugName), "plugin.xml")
 def PlugPath(self,PlugName=None):
 return False
 def OnPlugSave(self):
 return True
+def GetPlugParamsAttributes(self):
+return self.PlugParams[1].getElementAttributes()
+def SetPlugParamsAttribute(self, name, value):
+attr = getattr(self.PlugParams[1], name, None)
+if isinstance(attr, types.ClassType):
+attr.SetValue(value)
+else:
+setattr(self.PlugParams[1], name, value)
 def PlugRequestSave(self):
 # If plugin do not have corresponding directory
-if not os.path.isdir(self.PlugPath(PlugName)):
+plugpath = self.PlugPath()
+if not os.path.isdir(plugpath):
 # Create it
-os.mkdir(self.PlugPath(PlugName))
+os.mkdir(plugpath)
-# generate XML for all XML parameters controllers of the plugin
+# generate XML for base XML parameters controller of the plugin
-XMLString = '<?xml version="1.0" encoding="UTF-8"?>'
+basexmlfilepath = self.PluginBaseXmlFilePath()
-for nodeName, XMLController in self.PlugParams + self.MandatoryParams:
+if basexmlfilepath:
-XMLString += XMLController.generateXMLTextMethod(self, nodeName, 0)
+BaseXMLFile = open(basexmlfilepath,'w')
-XMLFile = open(self.PluginXmlFilePath(PlugName),'w')
+BaseXMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
-XMLFile.write(XMLString)
+BaseXMLFile.write(self.MandatoryParams[1].generateXMLText(self.MandatoryParams[0], 0))
-XMLFile.close()
+BaseXMLFile.close()
+# generate XML for XML parameters controller of the plugin
+xmlfilepath = self.PluginXmlFilePath()
+if xmlfilepath:
+XMLFile = open(xmlfilepath,'w')
+XMLFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
+XMLFile.write(self.PlugParams[1].generateXMLText(self.PlugParams[0], 0))
+XMLFile.close()
 # Call the plugin specific OnPlugSave method
-self.OnPlugSave()
+result = self.OnPlugSave()
+if not result:
+return "Error while saving \"%s\""%self.PlugPath()
 # go through all childs and do the same
 for PlugChild in self.IterChilds():
-PlugChild.PlugRequestSave()
+result = PlugChild.PlugRequestSave()
+if result:
+return result
+return None
 def PlugImport(self, src_PlugPath):
 shutil.copytree(src_PlugPath, self.PlugPath)
 return True
 def PlugGenerate_C(self, buildpath, current_location, locations):
 """
 Generate C code
 @param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)
 @param locations: List of complete variables locations \
-[(IEC_loc, IEC_Direction IEC_Type, Name)]\
+[(IEC_loc, IEC_Direction, IEC_Type, Name)]\
 ex: [((0,0,4,5),'I','STRING','__IX_0_0_4_5'),...]
 """
 return [],""
 def _Generate_C(self, buildpath, current_location, locations):
 for PlugInstance in PluggedChilds:
 yield PlugInstance
 def _GetChildBySomething(self, sep, something, matching):
 toks = matching.split(sep,1)
-for PlugInstance in self.IterChilds:
+for PlugInstance in self.IterChilds():
 # if match component of the name
 if getattr(PlugInstance.BaseParams, something) == toks[0]:
 # if Name have other components
 if len(toks) == 2:
 # Recurse in order to find the latest object
 def GetChildByName(self, Name):
 return self._GetChildBySomething('.',"Name", Name)
 def GetChildByIECLocation(self, Location):
 return self._GetChildBySomething('_',"IEC_Channel", Name)
+def GetPlugInfos(self):
+childs = []
+for child in self.IterChilds():
+childs.append(child.GetPlugInfos())
+return {"name" : self.BaseParams.getName(), "type" : None, "values" : childs}
 def FindNewIEC_Channel(self, DesiredChannel):
 """
 Changes IEC Channel number to DesiredChannel if available, nearest available if not.
 @param DesiredChannel: The desired IEC channel (int)
 # if PlugClass is a class factory, call it. (prevent unneeded imports)
 if type(PlugClass) == types.FunctionType:
 PlugClass = PlugClass()
 # Eventualy Initialize child instance list for this class of plugin
-PluggedChildsWithSameClass = self.PluggedChilds.setdefault(PlugType,list())
+PluggedChildsWithSameClass = self.PluggedChilds.setdefault(PlugType, list())
 # Check count
-if PlugClass.MaxCount and len(PluggedChildsWithSameClass) >= PlugClass.MaxCount:
+if getattr(PlugClass, "PlugMaxCount", None) and len(PluggedChildsWithSameClass) >= PlugClass.PlugMaxCount:
-raise Exception, "Max count (%d) reached for this plugin of type %s "%(PlugClass.MaxCount, PlugType)
+raise Exception, "Max count (%d) reached for this plugin of type %s "%(PlugClass.PlugMaxCount, PlugType)
 # create the final class, derived of provided plugin and template
 class FinalPlugClass(PlugClass, PlugTemplate):
 """
 Plugin class is derivated into FinalPlugClass before being instanciated
 # Call the base plugin template init - change XSD into class members
 PlugTemplate.__init__(_self)
 # If dir have already be made, and file exist
 if os.path.isdir(_self.PlugPath(PlugName)) and os.path.isfile(_self.PluginXmlFilePath(PlugName)):
 #Load the plugin.xml file into parameters members
-_self.LoadXMLParams()
+_self.LoadXMLParams(PlugName)
 # Check that IEC_Channel is not already in use.
 self.FindNewIEC_Channel(self.BaseParams.getIEC_Channel())
 # Call the plugin real __init__
-PlugClass.__init__(_self)
+if getattr(PlugClass, "__init__", None):
+PlugClass.__init__(_self)
 #Load and init all the childs
 _self.LoadChilds()
 else:
 # If plugin do not have corresponding file/dirs - they will be created on Save
 # Set plugin name
 _self.BaseParams.setName(PlugName)
+os.mkdir(_self.PlugPath())
 # Find an IEC number
 _self.FindNewIEC_Channel(0)
 # Call the plugin real __init__
-PlugClass.__init__(_self)
+if getattr(PlugClass, "__init__", None):
+PlugClass.__init__(_self)
+_self.PlugRequestSave()
 # Create the object out of the resulting class
 newPluginOpj = FinalPlugClass()
 # Store it in PluggedChils
 PluggedChildsWithSameClass.append(newPluginOpj)
 return newPluginOpj
-def LoadXMLParams(self):
+def LoadXMLParams(self, PlugName = None, test = True):
-# PlugParams have been filled, make a local dict to work with
+# Get the base xml tree
-PlugParams = dict(self.PlugParams + self.MandatoryParams)
+basexmlfilepath = self.PluginBaseXmlFilePath(PlugName)
+if basexmlfilepath:
+basexmlfile = open(basexmlfilepath, 'r')
+basetree = minidom.parse(basexmlfile)
+self.MandatoryParams[1].loadXMLTree(basetree.childNodes[0])
+basexmlfile.close()
 # Get the xml tree
-xmlfile = open(self.PluginXmlFilePath(PlugName), 'r')
+xmlfilepath = self.PluginXmlFilePath(PlugName)
-tree = minidom.parse(xmlfile)
+if xmlfilepath:
-xmlfile.close()
+xmlfile = open(xmlfilepath, 'r')
-# for each root elements
+tree = minidom.parse(xmlfile)
-for subtree in tree.childNodes:
+self.PlugParams[1].loadXMLTree(tree.childNodes[0])
-# if a plugin specific parameter set
+xmlfile.close()
-if subtree.nodeName in PlugParams:
-#Load into associated xmlclass.
+if test:
-PlugParams[subtree.nodeName].loadXMLTree(subtree)
+# Basic check. Better to fail immediately.
+if not PlugName:
-# Basic check. Better to fail immediately.
+PlugName = os.path.split(self.PlugPath())[1].split(NameTypeSeparator)[0]
-if(self.BaseParams.getName() != PlugName):
+if (self.BaseParams.getName() != PlugName):
-raise Exception, "Project tree layout do not match plugin.xml %s!=%s "%(PlugName,self.BaseParams.getName())
+raise Exception, "Project tree layout do not match plugin.xml %s!=%s "%(PlugName, self.BaseParams.getName())
 # Now, self.PlugPath() should be OK
 def LoadChilds(self):
 # Iterate over all PlugName@PlugType in plugin directory, and try to open them
 for PlugDir in os.listdir(self.PlugPath()):
-if os.path.isdir(os.path.join(self.PlugPath(),PlugDir)) and \
+if os.path.isdir(os.path.join(self.PlugPath(), PlugDir)) and \
 PlugDir.count(NameTypeSeparator) == 1:
 try:
-self.PlugAddChild(*PlugDir.split[NameTypeSeparator])
+self.PlugAddChild(*PlugDir.split(NameTypeSeparator))
 except Exception, e:
 print e
+def _GetClassFunction(name):
+def GetRootClass():
+return getattr(__import__("plugins." + name), name).RootClass
+return GetRootClass
 class PluginsRoot(PlugTemplate):
 # For root object, available Childs Types are modules of the plugin packages.
-PlugChildsTypes = [(name,lambda : getattr(__import__("plugins." + name), name).RootClass) for name in plugins.__all__]
+PlugChildsTypes = [(name, _GetClassFunction(name)) for name in plugins.__all__]
 XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>
 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <xsd:simpleType name="Win32Compiler">
 <xsd:restriction base="xsd:string">
 <xsd:complexType>
 <xsd:choice>
 <xsd:element name="Win32">
 <xsd:complexType>
 <xsd:attribute name="ToolChain" type="ppx:Win32Compiler" use="required" default="MinGW"/>
-<xsd:attribute name="Priority" type="xsd:integer" use="required" default="0"/>
+<xsd:attribute name="Priority" type="xsd:integer" use="required"/>
 </xsd:complexType>
 </xsd:element>
 <xsd:element name="Linux">
 <xsd:complexType>
 <xsd:attribute name="Compiler" type="xsd:string" use="required" default="gcc"/>
-<xsd:attribute name="Nice" type="xsd:integer" use="required" default="0"/>
+<xsd:attribute name="Nice" type="xsd:integer" use="required"/>
 </xsd:complexType>
 </xsd:element>
 <xsd:element name="Xenomai">
 <xsd:complexType>
 <xsd:attribute name="xeno-config" type="xsd:string" use="required" default="/usr/xenomai/"/>
-<xsd:attribute name="Compiler" type="xsd:string" use="required" default="0"/>
+<xsd:attribute name="Compiler" type="xsd:string" use="required"/>
-<xsd:attribute name="Priority" type="xsd:integer" use="required" default="0"/>
+<xsd:attribute name="Priority" type="xsd:integer" use="required"/>
 </xsd:complexType>
 </xsd:element>
 <xsd:element name="RTAI">
 <xsd:complexType>
-<xsd:attribute name="xeno-config" type="xsd:string" use="required" default="0"/>
+<xsd:attribute name="xeno-config" type="xsd:string" use="required"/>
-<xsd:attribute name="Compiler" type="xsd:string" use="required" default="0"/>
+<xsd:attribute name="Compiler" type="xsd:string" use="required"/>
-<xsd:attribute name="Priority" type="xsd:integer" use="required" default="0"/>
+<xsd:attribute name="Priority" type="xsd:integer" use="required"/>
 </xsd:complexType>
 </xsd:element>
 <xsd:element name="Library">
 <xsd:complexType>
-<xsd:attribute name="Dynamic" type="xsd:boolean" default="true"/>
+<xsd:attribute name="Dynamic" type="xsd:boolean" use="required" default="true"/>
-<xsd:attribute name="Compiler" type="xsd:string" use="required" default="0"/>
+<xsd:attribute name="Compiler" type="xsd:string" use="required"/>
 </xsd:complexType>
 </xsd:element>
 </xsd:choice>
 </xsd:complexType>
 </xsd:element>
 </xsd:complexType>
 </xsd:element>
 </xsd:schema>
 """
-def __init__(self, ProjectPath):
+def __init__(self):
+PlugTemplate.__init__(self)
 # self is the parent
 self.PlugParent = None
 # Keep track of the plugin type name
 self.PlugType = "Beremiz"
-# Keep track of the root plugin (i.e. project path)
-self.ProjectPath = ProjectPath
+self.ProjectPath = ""
+self.PLCManager = None
+def HasProjectOpened(self):
+"""
+Return if a project is actually opened
+"""
+return self.ProjectPath != ""
+def GetProjectPath(self):
+return self.ProjectPath
+def GetTargetTypes(self):
+return self.BeremizRoot.TargetType.getChoices().keys()
+def ChangeTargetType(self, target_type):
+self.BeremizRoot.TargetType.addContent(target_type)
+def GetTargetAttributes(self):
+content = self.BeremizRoot.TargetType.getContent()
+if content:
+return content["value"].getElementAttributes()
+else:
+return []
+def SetTargetAttribute(self, name, value):
+content = self.BeremizRoot.TargetType.getContent()
+if content:
+attr = getattr(content["value"], name, None)
+if isinstance(attr, types.ClassType):
+attr.SetValue(value)
+else:
+setattr(content["value"], name, value)
+def GetTargetType(self):
+content = self.BeremizRoot.TargetType.getContent()
+if content:
+return content["name"]
+else:
+return ""
+def NewProject(self, ProjectPath, PLCParams):
+"""
+Create a new project in an empty folder
+@param ProjectPath: path of the folder where project have to be created
+@param PLCParams: properties of the PLCOpen program created
+"""
+# Verify that choosen folder is empty
+if not os.path.isdir(ProjectPath) or len(os.listdir(ProjectPath)) > 0:
+return "Folder choosen isn't empty. You can't use it for a new project!"
+# Create Controler for PLCOpen program
+self.PLCManager = PLCControler()
+self.PLCManager.CreateNewProject(PLCParams.pop("projectName"))
+self.PLCManager.SetProjectProperties(properties = PLCParams)
 # Change XSD into class members
 self._AddParamsMembers()
 self.PluggedChilds = {}
 # No IEC channel, name, etc...
 self.MandatoryParams = []
+# Keep track of the root plugin (i.e. project path)
+self.ProjectPath = ProjectPath
+self.BaseParams.setName(os.path.split(ProjectPath)[1])
+return None
+def LoadProject(self, ProjectPath):
+"""
+Load a project contained in a folder
+@param ProjectPath: path of the project folder
+"""
+# Verify that project contains a PLCOpen program
+plc_file = os.path.join(ProjectPath, "plc.xml")
+if not os.path.isfile(plc_file):
+return "Folder choosen doesn't contain a program. It's not a valid project!"
+# Create Controler for PLCOpen program
+self.PLCManager = PLCControler()
+# Load PLCOpen file
+result = self.PLCManager.OpenXMLFile(plc_file)
+if result:
+return result
+# Change XSD into class members
+self._AddParamsMembers()
+self.PluggedChilds = {}
+# No IEC channel, name, etc...
+self.MandatoryParams = None
+# Keep track of the root plugin (i.e. project path)
+self.ProjectPath = ProjectPath
 # If dir have already be made, and file exist
-if os.path.isdir(_self.PlugPath(PlugName)) and os.path.isfile(_self.PluginXmlFilePath(PlugName)):
+if os.path.isdir(self.PlugPath()) and os.path.isfile(self.PluginXmlFilePath()):
 #Load the plugin.xml file into parameters members
-_self.LoadXMLParams()
+result = self.LoadXMLParams(test = False)
+if result:
+return result
 #Load and init all the childs
-_self.LoadChilds()
+self.LoadChilds()
+self.BaseParams.setName(os.path.split(ProjectPath)[1])
-def PlugPath(self,PlugName=None):
+return None
+def SaveProject(self):
+if not self.PLCManager.SaveXMLFile():
+self.PLCManager.SaveXMLFile(os.path.join(self.ProjectPath, 'plc.xml'))
+self.PlugRequestSave()
+def PlugPath(self, PlugName=None):
 return self.ProjectPath
+def PluginBaseXmlFilePath(self, PlugName=None):
+return None
 def PluginXmlFilePath(self, PlugName=None):
 return os.path.join(self.PlugPath(PlugName), "beremiz.xml")

changeset 17	ee8cb104dbe0
parent 16	b2c02ca6271e
child 18	0fac6d621a24