<?xml version="1.0" encoding="UTF-8"?>

<schema xmlns="http://www.w3.org/2001/XMLSchema"
	elementFormDefault="qualified"
	targetNamespace="urn:madynes:tennis:soft"
	xmlns:tennis="urn:madynes:tennis:soft"
	xmlns:ext="urn:madynes:address:humaninfo"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	
  <import namespace="urn:madynes:address:humaninfo" schemaLocation="humaninfo.xsd"/>
  
  <simpleType name="rankingType">
      <restriction base="string">
        <enumeration value="NC"/>
        <enumeration value="30/5"/>
        <enumeration value="30/4"/>
        <enumeration value="30/3"/>
        <enumeration value="30/2"/>
        <enumeration value="30/1"/>
        <enumeration value="30"/>
        <enumeration value="15/5"/>
        <enumeration value="15/4"/>
        <enumeration value="15/3"/>
        <enumeration value="15/2"/>
        <enumeration value="15/1"/>
        <enumeration value="15"/>
        <enumeration value="5/6"/>
        <enumeration value="4/6"/>
        <enumeration value="3/6"/>
        <enumeration value="2/6"/>
        <enumeration value="1/6"/>
        <enumeration value="0"/>
        <enumeration value="-2/6"/>
        <enumeration value="-4/6"/>
        <enumeration value="-15"/>
        <enumeration value="-30"/>
      </restriction>
  </simpleType>
  
  <complexType name="playerType">
    <complexContent>
      <extension base="ext:personType">
        <sequence>
          <element name="birthday" type="string"/>
          <element name="certifying-doctor" type="ext:personType"/>
        </sequence>
    	<attribute name="id_player" type="integer" use="required"/>
    	<attribute name="ref_club" type="integer" use="required"/>
    	<attribute name="ranking" type="tennis:rankingType" use="required"/>
      </extension>
    </complexContent>
  </complexType>
  
  <complexType name="playersType">
    <sequence>
      <element name="player" type="tennis:playerType" minOccurs="0" maxOccurs="unbounded"/>
    </sequence>
  </complexType>
  
  <complexType name="clubType">
    <sequence>
      <element name="name" type="string"/>
      <element name="address" type="ext:addressType"/>
    </sequence>
    <attribute name="id_club" type="integer" use="required"/>
  </complexType>
  
  <complexType name="clubsType">
    <sequence>
      <element name="club" type="tennis:clubType" minOccurs="0" maxOccurs="unbounded"/>
    </sequence>
  </complexType>
  
  <element name="tennis">
    <complexType>
      <sequence>
        <element name="players" type="tennis:playersType"/>
        <element name="clubs" type="tennis:clubsType"/>
      </sequence>
     </complexType>
  </element>
</schema>

from Ft.Xml import EMPTY_NAMESPACE
from Ft.Xml.Domlette import NonvalidatingReader, PrettyPrint, implementation
from Ft.Xml.XPath import Evaluate, Compile
from Ft.Xml.XPath.Context import Context
from Ft.Xml import XPath, EMPTY_NAMESPACE
from xml.dom import Node
URI = "http://madynes.org"

doc = NonvalidatingReader.parseString(
"""
<rpc message-id='3' xmlns='urn:ietf:params:xml:ns:netconf:base:1.0'>
	<get-config>
		<filter>
			<netconf>
				<network xmlns="urn:ietf:params:xml:ns:netconf:yencap">
					<ifs:interfaces ifs:toto="789" xmlns:ifs="urn:ietf:params:xml:ns:netconf:yencap:module:Interfaces">
						<ifs:interface>
							<ifs:name>eth0</ifs:name>
						</ifs:interface>
					</ifs:interfaces>
				</network>
			</netconf>
		</filter>
	</get-config>
</rpc>"""
,URI)

URI = "http://madynes.org"
doc = NonvalidatingReader.parseUri("file:./tmp.xml", URI)

PrettyPrint(doc)
PrettyPrint(node)

NS = "urn:ietf:params:xml:ns:netconf:yencap:module:Interfaces"
doc = implementation.createDocument(NS, None, None)
interfacesNode = doc.createElementNS(NS,"interfaces")
textNode = doc.createTextNode("foo")
interfacesNode.appendChild(textNode)
doc.appendChild(interfacesNode)

# operation here is a node
for child in operation.childNodes:
   if child.nodeType==Node.ELEMENT_NODE:
      if child.tagName == C.SOURCE:
	 for node in child.childNodes:
	    if node.nodeType==Node.ELEMENT_NODE:
	       if node.tagName in [C.RUNNING, C.CANDIDATE, C.STARTUP]:
	          self.source = node.tagName
	       else:
	          return
      elif child.tagName == C.FILTER:
         self.filter = child
	 for att in self.filter.attributes.values():
	    if att.name == "type":
	       if att.value == C.SUBTREE:
	          self.filterType = C.SUBTREE
	       elif att.value == C.XPATH:
	          self.filterType = C.XPATH

NS_Netconf = "urn:ietf:params:xml:ns:netconf:base:1.0"
NS_YencaP = "urn:ietf:params:xml:ns:netconf:yencap"
NS_Interface_Module = "urn:ietf:params:xml:ns:netconf:yencap:module:Interfaces"
NS_BGP_Module = "urn:ietf:params:xml:ns:netconf:yencap:module:BGP"

NSS = {u"ns": NS_Netconf, u"yp": NS_YencaP, u"ifs": NS_Interface_Module, u"bgp": NS_BGP_Module }
ctx = Context(doc, processorNss = NSS)
nodes = Evaluate(u"//ns:rpc/ns:get-config/ns:filter/ns:netconf/yp:network/ifs:interfaces",ctx)

import amara
doc = amara.parse('conf/agents.xml')
for elem in doc.agents.agent:
	print "agent:"
	print elem.ipaddress.type
	print elem.ipaddress
	print elem.publickey.type
	print elem.publickey

e = doc.xml_create_element(u'agent')
f = doc.xml_create_element(u'ipaddress', attributes={u'type': u'4'}, content=u'192.168.0.14')
g = doc.xml_create_element(u'publickey', attributes={u'type': u'rsa'}, content=u'z5er54ze5s54x5fds5df')
e.xml_append(f)
e.xml_append(g)
doc.agents.xml_append(e)

RSA_TYPE = 'rsa'
DSA_TYPE = 'dsa'
IP_VERSION_4 = 4
IP_VERSION_6 = 6
TYPE = 'type'
IPADDRESS = 'ipaddress'
AGENT = 'agent'
PUBLICKEY = 'publickey'

def create_agent(ipaddress, ipaddresstype, publickey, publickeytype):
   e = doc.xml_create_element(u'agent')
   f = doc.xml_create_element(unicode(IPADDRESS), attributes={unicode(TYPE): unicode(ipaddresstype)}, content=unicode(ipaddress))
   g = doc.xml_create_element(unicode(PUBLICKEY), attributes={unicode(TYPE): unicode(publickeytype)}, content=unicode(publickey))
   e.xml_append(f)
   e.xml_append(g)
   doc.agents.xml_append(e)

print doc.xml()

<?xml version="1.0" encoding="UTF-8"?>
<modules xmlns:ycp="urn:loria:madynes:ensuite:yencap:1.0"
        xmlns:ifs="urn:loria:madynes:ensuite:yencap:module:Interfaces:1.0"
	xmlns:my="urn:loria:madynes:ensuite:yencap:module:MyModule:1.0">
  <module>
    <name>Interfaces</name>
    <xpath>/ycp:netconf/ycp:network/ifs:interfaces</xpath>
    <namespace>urn:loria:madynes:ensuite:yencap:module:Interfaces:1.0</namespace>
    <cache-lifetime>10000</cache-lifetime>
  </module>
  <module>
    <name>MyModule</name>
    <xpath>/ycp:netconf/ycp:sample/my:mymodule</xpath>
    <namespace>urn:loria:madynes:ensuite:yencap:module:MyModule:1.0</namespace>
    <cache-lifetime>1000</cache-lifetime>
  </module>
</modules>

cd ${YENCAP_HOME}/modules
	    
# Create a new directory with the name of your module:
mkdir MyModule

# Change to the new directory:
cd MyModule

# Create a file that says you are doing a python package:
touch __init__.py

# Create the main file of your module. The name must match the module name and finish with "_Module":
touch MyModule_Module.py

from Modules.module import Module
from Modules.modulereply import ModuleReply 
from Ft.Xml.Domlette import NonvalidatingReader, implementation, PrettyPrint
from Ft.Xml.XPath.Context import Context
from Ft.Xml import XPath, EMPTY_NAMESPACE
from xml.dom import Node
from Ft.Xml.XPath import Evaluate

import string
class MyModule_Module(Module):
def __init__(self, name, path, namespace, cacheLifetime, parameters):
		"""
		Create an instance and initialize the structure needed by it.
		@type  parameters: dictionary
		@param parameters : should be a dictionary containning the follow keys
		"""
		Module.__init__(self, name, path, namespace, cacheLifetime)


Here, you can add some code.
		
	def getConfig(self):
		"""
		Get the device configuration of the module. Returns an XML element embedded in a ModuleReply
		"""
		self.doc = implementation.createDocument(self.namespace, None, None)
		mymoduleNode = self.doc.createElementNS(self.namespace,"mymodule")
		fooNode = self.doc.createElementNS(self.namespace,"foo")
		mymoduleNode.appendChild(fooNode)
		self.doc.appendChild(mymoduleNode)
		modulereply = ModuleReply(replynode=self.doc.documentElement)
		return modulereply

	def editConfig(self,defaultoperation,testoption,erroroption,target,confignode,targetnode=None):
		"""
			Apply a ifconfig request from the confignode to the targetnode. delete and create attributes are supported only for iface element. For example, it is not possible to delete the name or the IP address of a network interface. 
			@type defaultoperation: MERGE_OPERATION | REPLACE_OPERATION | NONE_OPERATION 
			@param defaultoperation : as specified in NETCONF protocol
			@type testoption : SET | TEST_AND_SET 
			@param testoption : as specified in NETCONF protocol
			@type erroroption : STOP_ON_ERROR | IGNORE_ERROR | ROLL_BACK_ON_ERROR 
			@param erroroption : as specified in NETCONF protocol
			@type target : RUNNING_TARGET | CANDIDATE_TARGET | STARTUP_TARGET
			@param target : as specified in NETCONF protocol
			@type targetnode : string
			@param targetnode : if the target is RUNNING_TARGET or STARTUP_TARGET it will be ignored otherwise should be the node of the CANDIDATE_TARGET that this module should procees
			@rtype: ModuleReply
			@return: It returns a success or error message.
		"""
		# Apply the request
		error = edit my configuration()
		# returns a ModuleReply
		if (error):
			moduleReply = ModuleReply(
			error_type = ModuleReply.APPLICATION,
			error_tag = ModuleReply.OPERATION_FAILED,
			error_severity = ModuleReply.ERROR,
			error_message = "Sorry, an error occured.")
		else:
			# <ok/>

			moduleReply = ModuleReply()
			return moduleReply

<kernel metric="1" route-map="1"/>

<kernel>
  <metric>1</metric>
  <route-map>1</route-map>
</kernel>

<?xml version="1.0" encoding="UTF-8"?>
<operations>
        <operation>
                <name>get-config</name>
                <mainFileName>base.get_config_operation</mainFileName>
                <className>Get_config_operation</className>
        </operation>
       [...]
        <operation>
                <name>reboot</name>
                <mainFileName>ext.reboot_operation</mainFileName>
                <className>Reboot_operation</className>
        </operation>
</operations>

<reboot>
	<option>saveBeforeShutingDown</option>
</reboot>

from Operations.operation import Operation
from Operations.operationReply import OperationReply
import [...]

class Reboot_operation(Operation):
	"""
		Concrete command (see command design pattern) for the reboot operation.
	"""
	
	def __init__(self):
		"""
			Constructor of a Get_config_operation command.
		"""
		# Default behavior
		self.option = "saveBeforeShutingDown"
		
	def execute(self):
		"""
			Execute the get-config operation.
		"""
		# Do the job
		self.rebootTheDevice()
		if self.operationReply.isError():
		   return self.operationReply
	
	def setParameters(self, operation, NSS = None):
		"""
		Set the source and filter parameters
		@type  operation: Node
		@param operation: The operation node of the current Netconf request.
		"""

		self.prefixes = NSS
		for child in operation.childNodes:
		   if child.nodeType==Node.ELEMENT_NODE:
		      if child.tagName == "option":
		         for node in child.childNodes:
			    if node.nodeType==Node.TEXT_NODE:
			       self.option = node.nodeValue