hrr_rb_netconf 0.1.0

data/lib/hrr_rb_netconf/server/filter/xpath.rb

@@ -0,0 +1,59 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'rexml/document'
+
+module HrrRbNetconf
+  class Server
+    class Filter
+      class Xpath < Filter
+        TYPE = 'xpath'
+
+        class << self
+          def filter raw_output_e, filter_e
+            xpath = filter_e.attributes['select']
+            unless xpath
+              raise Error['missing-attribute'].new('protocol', 'error', info: {'bad-attribute' => 'select', 'bad-element' => 'filter'})
+            end
+            raw_output_xml_doc = REXML::Document.new 
+            raw_output_xml_doc.add raw_output_e.deep_clone
+            selected_element_xpaths = []
+            output_xml_doc = REXML::Document.new 
+            raw_output_xml_doc.each_element(xpath){ |e|
+              ctx_output_e = add_ancestors_recursively selected_element_xpaths, output_xml_doc, e
+              e.children.each{ |c|
+                case c
+                when REXML::Parent
+                  ctx_output_e.add c.deep_clone
+                else
+                  ctx_output_e.add c.clone
+                end
+              }
+            }
+            output_xml_doc.root
+          end
+
+          def add_elem selected_element_xpaths, output_e, raw_output_e
+            xpath, elem = selected_element_xpaths.find{ |xpath, elem| xpath == raw_output_e.xpath }
+            unless xpath
+              child_output_e = output_e.add raw_output_e.clone
+              selected_element_xpaths.push [raw_output_e.xpath, child_output_e]
+              child_output_e
+            else
+              elem
+            end
+          end
+
+          def add_ancestors_recursively selected_element_xpaths, output_e, raw_output_e
+            if raw_output_e == raw_output_e.root_node
+              output_e
+            else
+              parent_e = add_ancestors_recursively selected_element_xpaths, output_e, raw_output_e.parent
+              add_elem selected_element_xpaths, parent_e, raw_output_e
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/model.rb

@@ -0,0 +1,123 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'rexml/document'
+require 'hrr_rb_netconf/server/error'
+require 'hrr_rb_netconf/server/model/node'
+
+module HrrRbNetconf
+  class Server
+    class Model
+      def initialize operation
+        @operation = operation
+        @tree = Node.new nil, operation, 'root', {}
+      end
+
+      def add_recursively capability, node, path, stmt, options
+        name = path.shift
+        case path.size
+        when 0
+          node.children.push Node.new capability, name, stmt, options
+        else
+          child_node = node.children.find{|n| name == n.name}
+          add_recursively capability, child_node, path, stmt, options
+        end
+      end
+
+      def add capability, path, stmt, options
+        if path.size > 0
+          add_recursively capability, @tree, path.dup, stmt, options
+        end
+      end
+
+      def validate_recursively node, xml_e, parent_xml_e: nil, validated: []
+        case node.stmt
+        when 'root', 'container'
+          case xml_e
+          when nil
+            true
+          else
+            node.children.all?{ |c|
+              case c.stmt
+              when 'container'
+                validated.push c.name
+                validate_recursively c, xml_e.elements[c.name]
+              when 'leaf'
+                validated.push c.name
+                if xml_e.elements[c.name].nil? && c.options['default'].nil?
+                  if c.options['validation'].nil?
+                    true
+                  else
+                    raise Error['operation-failed'].new('application', 'error', message: 'Not implemented')
+                  end
+                else
+                  validate_recursively c, xml_e.elements[c.name], parent_xml_e: xml_e
+                end
+              when 'choice'
+                validate_recursively c, xml_e, validated: validated
+              else
+                raise Error['unknown-element'].new('application', 'error', info: {'bad-element' => "#{c.name}: #{c.stmt}"}, message: 'Not implemented')
+              end
+            }
+          end && (xml_e.elements.to_a.map{|e| e.name} - validated).empty?
+        when 'leaf'
+          case node.options['type']
+          when 'empty'
+            xml_e != nil && xml_e.has_text?.!
+          when 'enumeration'
+            if xml_e == nil && node.options['default']
+              parent_xml_e.add_element(node.name).text = node.options['default']
+            else
+              xml_e != nil && node.options['enum'].include?(xml_e.text)
+            end
+          when 'anyxml'
+            xml_e != nil && (REXML::Document.new(xml_e.text) rescue false)
+          when 'inet:uri'
+            xml_e != nil
+            raise Error['unknown-element'].new('application', 'error', info: {'bad-element' => "#{node.name}: #{node.stmt}"}, message: 'Not implemented: type inet:uri')
+          when 'integer'
+            if xml_e == nil && node.options['default']
+              parent_xml_e.add_element(node.name).text = node.options['default']
+            else
+              value = (Integer(xml_e.text) rescue false)
+              if node.options['range']
+                min, max = node.options['range']
+                xml_e != nil && value && min <= value && value <= max
+              else
+                xml_e != nil && value
+              end
+            end
+          when 'string'
+            if xml_e == nil && node.options['default']
+              parent_xml_e.add_element(node.name).text = node.options['default']
+            else
+              if node.options['validation'].nil?
+                xml_e != nil && xml_e.has_text?
+              else
+                xml_e != nil && xml_e.has_text? && node.options['validation'].call(node.capability, xml_e)
+              end
+            end
+          end
+        when 'choice'
+          if node.options['mandatory']
+            node.children.any?{ |c|
+              validated.push c.name
+              validate_recursively c, xml_e.elements[c.name]
+            }
+          else
+            node.children.empty? || node.children.any?{ |c|
+              validated.push c.name
+              validate_recursively c, xml_e.elements[c.name]
+            }
+          end
+        else
+          raise Error['unknown-element'].new('application', 'error', info: {'bad-element' => "#{c.name}: #{c.stmt}"}, message: 'Not implemented')
+        end
+      end
+
+      def validate input_e
+        validate_recursively @tree, input_e
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/model/node.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+module HrrRbNetconf
+  class Server
+    class Model
+      class Node
+        attr_reader :capability, :name, :stmt, :options, :children
+        def initialize capability, name, stmt, options
+          @capability = capability
+          @name = name
+          @stmt = stmt
+          @options = options
+          @children = Array.new
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/operation.rb

@@ -0,0 +1,92 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_netconf/logger'
+require 'hrr_rb_netconf/server/model'
+require 'hrr_rb_netconf/server/filter'
+
+module HrrRbNetconf
+  class Server
+    class Operation
+      def initialize session, capabilities, datastore_session, strict_capabilities
+        @logger = Logger.new self.class.name
+        @session = session
+        @capabilities = capabilities
+        @datastore_session = datastore_session
+        @strict_capabilities = strict_capabilities
+        @models = Hash.new
+        @oper_procs = Hash.new
+
+        load_capabilities
+      end
+
+      def load_capabilities
+        @capabilities.each_loadable{ |c|
+          @logger.debug { "Load capability: #{c.id}" }
+          c.oper_procs.each{ |k, v|
+            @oper_procs[k] = v
+          }
+          if @strict_capabilities
+            c.models.each{ |m|
+              oper_name, path, stmt, options = m
+              @models[oper_name] ||= Model.new oper_name
+              @models[oper_name].add c, path, stmt, options
+            }
+          end
+        }
+      end
+
+      def validate input_e
+        oper_name = input_e.name
+        model = @models[oper_name]
+        if model
+          model.validate input_e
+        else
+          false
+        end
+      end
+
+      def run xml_doc
+        unless xml_doc.root.name == 'rpc'
+          @logger.error { "Invalid root tag: must be rpc, but got #{xml_doc.root.name}" }
+          raise Error['operation-not-supported'].new('protocol', 'error')
+        end
+
+        message_id = xml_doc.attributes['message-id']
+        unless message_id
+          raise Error['missing-attribute'].new('rpc', 'error', info: {'bad-attribute' => 'message-id', 'bad-element' => 'rpc'})
+        end
+
+        input_e = xml_doc.elements[1]
+
+        unless @oper_procs.has_key? input_e.name
+          raise Error['operation-not-supported'].new('protocol', 'error')
+        end
+
+        if @strict_capabilities
+          unless validate input_e
+            raise Error['operation-not-supported'].new('application', 'error')
+          end
+        end
+
+        raw_output = @oper_procs[input_e.name].call(@session, @datastore_session, input_e)
+
+        raw_output_e = case raw_output
+                       when String
+                         REXML::Document.new(raw_output, {:ignore_whitespace_nodes => :all}).root
+                       when REXML::Document
+                         raw_output.root
+                       when REXML::Element
+                         raw_output
+                       else
+                         raise "Unexpected output: #{raw_output.inspect}"
+                       end
+        output_e = Filter.filter(raw_output_e, input_e)
+        rpc_reply_e = xml_doc.clone
+        rpc_reply_e.name = "rpc-reply"
+        rpc_reply_e.add output_e
+        rpc_reply_e
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/session.rb

@@ -0,0 +1,177 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'rexml/document'
+require 'hrr_rb_netconf/logger'
+require 'hrr_rb_netconf/server/capability'
+require 'hrr_rb_netconf/server/operation'
+
+module HrrRbNetconf
+  class Server
+    class Session
+      attr_reader :session_id
+
+      def initialize server, capabilities, datastore, session_id, io, strict_capabilities
+        @logger = Logger.new self.class.name
+        @server = server
+        @local_capabilities = capabilities
+        @remote_capabilities = Array.new
+        @datastore = datastore
+        @session_id = session_id
+        @io_r, @io_w = case io
+                       when IO
+                         [io, io]
+                       when Array
+                         [io[0], io[1]]
+                       else
+                         raise ArgumentError, "io must be an instance of IO or Array"
+                       end
+        @strict_capabilities = strict_capabilities
+        @closed = false
+      end
+
+      def start
+        begin
+          exchange_hello
+          negotiate_capabilities
+          initialize_sender_and_receiver
+          operation_loop
+        rescue
+          raise
+        ensure
+          close
+        end
+      end
+
+      def close
+        @logger.info { "Being closed" }
+        @closed = true
+        begin
+          @io_r.close_read
+        rescue
+        end
+      end
+
+      def closed?
+        @closed
+      end
+
+      def exchange_hello
+        send_hello
+        receive_hello
+      end
+
+      def send_hello
+        @logger.info { "Local capabilities: #{@local_capabilities}" }
+        xml_doc = REXML::Document.new
+        hello_e = xml_doc.add_element 'hello'
+        hello_e.add_namespace('urn:ietf:params:xml:ns:netconf:base:1.0')
+        capabilities_e = hello_e.add_element 'capabilities'
+        @local_capabilities.list_loadable.each{ |c|
+          capability_e = capabilities_e.add_element 'capability'
+          capability_e.text = c
+        }
+        session_id_e = hello_e.add_element 'session-id'
+        session_id_e.text = @session_id.to_s
+
+        buf = String.new
+        formatter = REXML::Formatters::Pretty.new(2)
+        formatter.compact = true
+        formatter.write(xml_doc, buf)
+        @logger.debug { "Sending hello message: #{buf.inspect}" }
+        @io_w.write "#{buf}\n]]>]]>\n"
+      end
+
+      def receive_hello
+        buf = String.new
+        loop do
+          buf += @io_r.read(1)
+          if buf[-6..-1] == ']]>]]>'
+            break
+          end
+        end
+        @logger.debug { "Received hello message: #{buf[0..-7].inspect}" }
+        remote_capabilities_xml_doc = REXML::Document.new(buf[0..-7], {:ignore_whitespace_nodes => :all})
+        remote_capabilities_xml_doc.each_element('/hello/capabilities/capability'){ |c| @remote_capabilities.push c.text }
+        @logger.info { "Remote capabilities: #{@remote_capabilities}" }
+      end
+
+      def negotiate_capabilities
+        @capabilities = @local_capabilities.negotiate @remote_capabilities
+        @logger.info { "Negotiated capabilities: #{@capabilities.list_loadable}" }
+        unless @capabilities.list_loadable.any?{ |c| /^urn:ietf:params:netconf:base:\d+\.\d+$/ =~ c }
+          @logger.error { "No base NETCONF capability negotiated" }
+          raise  "No base NETCONF capability negotiated"
+        end
+      end
+
+      def initialize_sender_and_receiver
+        base_capability = @capabilities.list_loadable.select{ |c| /^urn:ietf:params:netconf:base:\d+\.\d+$/ =~ c }.sort.last
+        @logger.info { "Base NETCONF capability: #{base_capability}" }
+        @sender   = Capability[base_capability]::Sender.new   @io_w
+        @receiver = Capability[base_capability]::Receiver.new @io_r
+      end
+
+      def operation_loop
+        datastore_session = @datastore.new_session self
+        operation = Operation.new self, @capabilities, datastore_session, @strict_capabilities
+
+        begin
+          loop do
+            if closed?
+              break
+            end
+
+            begin
+              begin
+                received_message = @receiver.receive_message
+                break unless received_message
+                rpc_reply_e = operation.run received_message
+              rescue Error => e
+                if received_message
+                  rpc_reply_e = received_message.clone
+                  rpc_reply_e.name = "rpc-reply"
+                else
+                  rpc_reply_e = REXML::Element.new("rpc-reply")
+                  rpc_reply_e.add_namespace("urn:ietf:params:xml:ns:netconf:base:1.0")
+                end
+                rpc_reply_e.add e.to_rpc_error
+              end
+
+              begin
+                @sender.send_message rpc_reply_e
+              rescue IOError
+                break
+              end
+            rescue => e
+              @logger.error { e.message }
+              raise
+            end
+          end
+        ensure
+          begin
+            datastore_session.close
+          rescue
+          end
+          begin
+            @io_w.close_write
+          rescue
+          end
+        end
+        @logger.info { "Exit operation_loop" }
+      end
+
+      def close_other session_id
+        @server.close_session session_id
+      end
+
+      def lock target
+        @server.lock target, @session_id
+      end
+
+      def unlock target
+        @server.unlock target, @session_id
+      end
+    end
+  end
+end