hrr_rb_netconf 0.1.0

data/lib/hrr_rb_netconf/server.rb

@@ -0,0 +1,109 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'thread'
+require 'hrr_rb_netconf/logger'
+require 'hrr_rb_netconf/server/error'
+require 'hrr_rb_netconf/server/errors'
+require 'hrr_rb_netconf/server/datastore'
+require 'hrr_rb_netconf/server/capabilities'
+require 'hrr_rb_netconf/server/session'
+
+module HrrRbNetconf
+  class Server
+    SESSION_ID_UNALLOCATED = "UNALLOCATED"
+    SESSION_ID_MIN = 1
+    SESSION_ID_MAX = 2**32 - 1
+    SESSION_ID_MODULO = SESSION_ID_MAX - SESSION_ID_MIN + 1
+
+    def initialize datastore, capabilities: nil, strict_capabilities: false
+      @logger = Logger.new self.class.name
+      @datastore = datastore
+      @capabilities = capabilities || Capabilities.new
+      @strict_capabilities = strict_capabilities
+      @mutex = Mutex.new
+      @sessions = Hash.new
+      @locks = Hash.new
+      @lock_mutex = Mutex.new
+      @last_session_id = SESSION_ID_MIN - 1
+    end
+
+    def allocate_session_id
+      session_id = (SESSION_ID_MODULO).times.lazy.map{ |idx| (@last_session_id + 1 + idx - SESSION_ID_MIN) % SESSION_ID_MODULO + SESSION_ID_MIN }.reject{ |sid| @sessions.has_key? sid }.first
+      unless session_id
+        @logger.error { "Failed allocating Session ID" }
+        raise "Failed allocating Session ID"
+      end
+      @last_session_id = session_id
+    end
+
+    def delete_session session_id
+      if @sessions.has_key? session_id
+        @sessions.delete session_id
+      end
+    end
+
+    def start_session io
+      @logger.info { "Starting session" }
+      session_id = SESSION_ID_UNALLOCATED
+      begin
+        @mutex.synchronize do
+          session_id = allocate_session_id
+          @logger.info { "Session ID: #{session_id}" }
+          @sessions[session_id] = Session.new self, @capabilities, @datastore, session_id, io, @strict_capabilities
+        end
+        t = Thread.new {
+          @sessions[session_id].start
+        }
+        @logger.info { "Session started: Session ID: #{session_id}" }
+        t.join
+      rescue => e
+        @logger.error { "Session terminated: Session ID: #{session_id}" }
+        raise
+      else
+        @logger.info { "Session closed: Session ID: #{session_id}" }
+      ensure
+        @lock_mutex.synchronize do
+          @locks.delete_if{ |tgt, sid| sid == session_id }
+        end
+        @mutex.synchronize do
+          delete_session session_id
+        end
+      end
+    end
+
+    def close_session session_id
+      @logger.info { "Close session: Session ID: #{session_id}" }
+      @sessions[session_id].close
+    end
+
+    def lock target, session_id
+      @logger.info { "Lock: Target: #{target}, Session ID: #{session_id}" }
+      @lock_mutex.synchronize do
+        if @locks.has_key? target
+          @logger.info { "Lock failed, lock is already held by session-id: #{@locks[target]}" }
+          raise Error['lock-denied'].new('protocol', 'error', info: {'session-id' => @locks[target].to_s}, message: 'Lock failed, lock is already held')
+        else
+          @locks[target] = session_id
+        end
+      end
+    end
+
+    def unlock target, session_id
+      @logger.info { "Unlock: Target: #{target}, Session ID: #{session_id}" }
+      @lock_mutex.synchronize do
+        if @locks.has_key? target
+          if @locks[target] == session_id
+            @locks.delete target
+          else
+            @logger.info { "Unlock failed, lock is held by session-id: #{@locks[target]}" }
+            raise Error['operation-failed'].new('protocol', 'error')
+          end
+        else
+          @logger.info { "Unlock failed, lock is not held" }
+          raise Error['operation-failed'].new('protocol', 'error')
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/capabilities.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'tsort'
+require 'hrr_rb_netconf/server/capability'
+
+module HrrRbNetconf
+  class Server
+    class Capabilities
+      def initialize features=nil, capabilities_h=nil
+        @features = features
+        unless capabilities_h
+          @caps = Capability.list.inject({}){ |a, b| a.merge({b => Capability[b].new}) }
+        else
+          @caps = capabilities_h
+        end
+      end
+
+      def negotiate remote_capabilities
+        filtered_by_features = @caps.select{ |k, v| if @features.nil? then true else (v.if_features - @features).empty? end }
+        capabilities_h = filtered_by_features.values.group_by{ |c| c.keyword }.map{ |k, cs|
+          cs.map{ |c|
+            remote_capabilities.lazy.map{ |rc| c.negotiate rc }.select{ |nc| nc }.first
+          }.compact.max
+        }.compact.inject({}){ |a, c|
+          a.merge({c.uri => c})
+        }
+        features = if @features.nil? then nil else @features.dup end
+        Capabilities.new features, capabilities_h
+      end
+
+      def register_capability name, &blk
+        cap = Capability.new(name)
+        blk.call cap
+        @caps[name] = cap
+      end
+
+      def unregister_capability name
+        @caps.delete name
+      end
+
+      def list_all
+        @caps.keys
+      end
+
+      def list_supported
+        @caps.select{ |k, v| if @features.nil? then true else (v.if_features - @features).empty? end }.map{ |k, v| v.id }
+      end
+
+      def list_loadable
+        filtered_by_features = @caps.select{ |k, v| if @features.nil? then true else (v.if_features - @features).empty? end }
+        @filtered_by_dependencies = filtered_by_features.select{ |k, v| v.dependencies.all?{ |d| filtered_by_features.has_key? d } }
+        tsort.map{ |k| @filtered_by_dependencies[k].id }
+      end
+
+      def each_loadable
+        filtered_by_features = @caps.select{ |k, v| if @features.nil? then true else (v.if_features - @features).empty? end }
+        @filtered_by_dependencies = filtered_by_features.select{ |k, v| v.dependencies.all?{ |d| filtered_by_features.has_key? d } }
+        tsort.each do|k|
+          yield @filtered_by_dependencies[k]
+        end
+      end
+
+      include TSort
+
+      def tsort_each_node &blk
+        @filtered_by_dependencies.each_key(&blk)
+      end
+
+      def tsort_each_child node, &blk
+        @filtered_by_dependencies[node].dependencies.each(&blk)
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/capability.rb

@@ -0,0 +1,206 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'uri'
+
+module HrrRbNetconf
+  class Server
+    class Capability
+      @subclass_list = Array.new
+
+      class << self
+        def inherited klass
+          @subclass_list.push klass if @subclass_list
+        end
+
+        def [] key
+          __subclass_list__(__method__).find{ |klass| klass::ID == key }
+        end
+
+        def list
+          __subclass_list__(__method__).map{ |klass| klass::ID }
+        end
+
+        def __subclass_list__ method_name
+          send(:method_missing, method_name) unless @subclass_list
+          @subclass_list
+        end
+
+        private :__subclass_list__
+      end
+
+      class << self
+        def oper_procs
+          @oper_procs || {}
+        end
+
+        def oper_proc oper_name, &blk
+          @oper_procs ||= Hash.new
+          @oper_procs[oper_name] = blk
+        end
+
+        def models
+          @models || []
+        end
+
+        def model oper_name, path, stmt=nil, attrs={}
+          @models ||= Array.new
+          @models.push [oper_name, path, stmt, attrs]
+        end
+
+        private :oper_proc, :model
+      end
+
+      attr_accessor :if_features, :dependencies, :queries
+
+      def initialize id=nil
+        @id           = id || self.class::ID
+        @queries      = (self.class::QUERIES rescue {})
+        @if_features  = (self.class::IF_FEATURES rescue [])
+        @dependencies = (self.class::DEPENDENCIES rescue [])
+        @oper_procs   = self.class.oper_procs.dup
+        @models       = (self.class.models rescue [])
+        @uri_proc     = Proc.new { |id| id.split('?').first }
+        @keyword_proc = Proc.new { |id| id.split('?').first.match(/^((?:.+(?:\/|:))+.+)(?:\/|:)(.+)$/)[1] }
+        @version_proc = Proc.new { |id| id.split('?').first.match(/^((?:.+(?:\/|:))+.+)(?:\/|:)(.+)$/)[2] }
+        @decode_queries_proc = Proc.new { |qs_s| URI.decode_www_form(qs_s).inject({}){|a,(k,v)| a.merge({k=>(v.split(','))})} }
+        @encode_queries_proc = Proc.new { |qs_h| URI.encode_www_form(qs_h.map{|k,v| [k, v.join(',')]}) }
+      end
+
+      def oper_procs
+        @oper_procs
+      end
+
+      def oper_proc oper_name, &blk
+        if blk
+          @oper_procs[oper_name] = blk
+        end
+        @oper_procs[oper_name]
+      end
+
+      def models
+        @models
+      end
+
+      def model oper_name, path, stmt=nil, attrs={}
+        @models.push [oper_name, path, stmt, attrs]
+      end
+
+      def id
+        if @queries.empty?
+          @id
+        else
+          [@id, @encode_queries_proc.call(@queries)].join('?')
+        end
+      end
+
+      def uri
+        @uri_proc.call id
+      end
+
+      def keyword
+        @keyword_proc.call id
+      end
+
+      def version
+        @version_proc.call id
+      end
+
+      def uri_proc &blk
+        if blk
+          @uri_proc = blk
+        else
+          raise ArgumentError, "block not given"
+        end
+      end
+
+      def keyword_proc &blk
+        if blk
+          @keyword_proc = blk
+        else
+          raise ArgumentError, "block not given"
+        end
+      end
+
+      def version_proc &blk
+        if blk
+          @version_proc = blk
+        else
+          raise ArgumentError, "block not given"
+        end
+      end
+
+      def decode_queries_proc &blk
+        if blk
+          @decode_queries_proc = blk
+        else
+          raise ArgumentError, "block not given"
+        end
+      end
+
+      def encode_queries_proc &blk
+        if blk
+          @encode_queries_proc = blk
+        else
+          raise ArgumentError, "block not given"
+        end
+      end
+
+      def negotiate other_id
+        other_keyword = @keyword_proc.call(other_id)
+        unless keyword == other_keyword
+          nil
+        else
+          other_version = @version_proc.call(other_id)
+          case version <=> other_version
+          when 0
+            c = self.dup
+            c.queries = negotiate_queries(other_id)
+            c
+          else
+            nil
+          end
+        end
+      end
+
+      def negotiate_queries other_id
+        other_queries = @decode_queries_proc.call((other_id.split('?') + [''])[1])
+        queries.inject({}){ |a, (k, v)|
+          if other_queries.has_key?(k)
+            values = v & other_queries[k]
+            if values.empty?
+              a
+            else
+              a.merge({k => values})
+            end
+          else
+            a
+          end
+        }
+      end
+
+      include Comparable
+
+      def <=> other
+        unless keyword == other.keyword
+          nil
+        else
+          version <=> other.version
+        end
+      end
+    end
+  end
+end
+
+require 'hrr_rb_netconf/server/capability/base_1_0'
+require 'hrr_rb_netconf/server/capability/base_1_1'
+require 'hrr_rb_netconf/server/capability/writable_running_1_0'
+require 'hrr_rb_netconf/server/capability/candidate_1_0'
+require 'hrr_rb_netconf/server/capability/confirmed_commit_1_0'
+require 'hrr_rb_netconf/server/capability/confirmed_commit_1_1'
+require 'hrr_rb_netconf/server/capability/rollback_on_error_1_0'
+require 'hrr_rb_netconf/server/capability/startup_1_0'
+require 'hrr_rb_netconf/server/capability/validate_1_0'
+require 'hrr_rb_netconf/server/capability/validate_1_1'
+require 'hrr_rb_netconf/server/capability/url_1_0'
+require 'hrr_rb_netconf/server/capability/xpath_1_0'

data/lib/hrr_rb_netconf/server/capability/base_1_0.rb

@@ -0,0 +1,183 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'rexml/document'
+require 'hrr_rb_netconf/logger'
+
+module HrrRbNetconf
+  class Server
+    class Capability
+      class Base_1_0 < Capability
+        ID = 'urn:ietf:params:netconf:base:1.0'
+        DEPENDENCIES = []
+        IF_FEATURES  = []
+
+        oper_proc('get'){ |session, datastore, input_e|
+          datastore.run 'get', input_e
+        }
+
+        oper_proc('get-config'){ |session, datastore, input_e|
+          datastore.run 'get-config', input_e
+        }
+
+        oper_proc('edit-config'){ |session, datastore, input_e|
+          datastore.run 'edit-config', input_e
+          '<ok />'
+        }
+
+        oper_proc('copy-config'){ |session, datastore, input_e|
+          datastore.run 'copy-config', input_e
+          '<ok />'
+        }
+
+        oper_proc('delete-config'){ |session, datastore, input_e|
+          datastore.run 'delete-config', input_e
+          '<ok />'
+        }
+
+        oper_proc('lock'){ |session, datastore, input_e|
+          target = input_e.elements['target'].elements[1].name
+          session.lock target
+          begin
+            datastore.run 'lock', input_e
+            '<ok />'
+          rescue
+            session.unlock target
+            raise
+          end
+        }
+
+        oper_proc('unlock'){ |session, datastore, input_e|
+          datastore.run 'unlock', input_e
+          target = input_e.elements['target'].elements[1].name
+          session.unlock target
+          '<ok />'
+        }
+
+        oper_proc('close-session'){ |session, datastore, input_e|
+          datastore.run 'close-session', input_e
+          session.close
+          '<ok />'
+        }
+
+        oper_proc('kill-session'){ |session, datastore, input_e|
+          session.close_other Integer(input_e.elements['session-id'].text)
+          '<ok />'
+        }
+
+        model 'get',           ['filter'],                             'leaf',     'type' => 'anyxml'
+        model 'get-config',    ['source'],                             'container'
+        model 'get-config',    ['source', 'config-source'],            'choice',   'mandatory' => true
+        model 'get-config',    ['source', 'config-source', 'running'], 'leaf',     'type' => 'empty'
+        model 'get-config',    ['filter'],                             'leaf',     'type' => 'anyxml'
+        model 'edit-config',   ['target'],                             'container'
+        model 'edit-config',   ['target', 'config-target'],            'choice',   'mandatory' => true
+        model 'edit-config',   ['default-operation'],                  'leaf',     'type' => 'enumeration', 'enum' => ['merge', 'replace', 'none'], 'default' => 'merge'
+        model 'edit-config',   ['error-option'],                       'leaf',     'type' => 'enumeration', 'enum' => ['stop-on-error', 'continue-on-error', 'rollback-on-error'], 'default' => 'stop-on-error'
+        model 'edit-config',   ['edit-content'],                       'choice',   'mandatory' => true
+        model 'edit-config',   ['edit-content', 'config'],             'leaf',     'type' => 'anyxml'
+        model 'copy-config',   ['target'],                             'container'
+        model 'copy-config',   ['target', 'config-target'],            'choice',   'mandatory' => true
+        model 'copy-config',   ['source'],                             'container'
+        model 'copy-config',   ['source', 'config-source'],            'choice',   'mandatory' => true
+        model 'copy-config',   ['source', 'config-source', 'running'], 'leaf',     'type' => 'empty'
+        model 'copy-config',   ['source', 'config-source', 'config'],  'leaf',     'type' => 'anyxml'
+        model 'delete-config', ['target'],                             'container'
+        model 'delete-config', ['target', 'config-target'],            'choice',   'mandatory' => true
+        model 'lock',          ['target'],                             'container'
+        model 'lock',          ['target', 'config-target'],            'choice',   'mandatory' => true
+        model 'lock',          ['target', 'config-target', 'running'], 'leaf',     'type' => 'empty'
+        model 'unlock',        ['target'],                             'container'
+        model 'unlock',        ['target', 'config-target'],            'choice',   'mandatory' => true
+        model 'unlock',        ['target', 'config-target', 'running'], 'leaf',     'type' => 'empty'
+        model 'close-session', []
+        model 'kill-session',  ['session-id'],                         'leaf',     'type' => 'integer', 'range' => [1, 2**32-1]
+
+        class Sender
+          def initialize io_w
+            @logger = Logger.new self.class.name
+            @io_w = io_w
+            @formatter = REXML::Formatters::Pretty.new(2)
+            @formatter.compact = true
+          end
+
+          def send_message msg
+            buf = String.new
+            case msg
+            when String
+              begin
+                @formatter.write(REXML::Document.new(msg, {:ignore_whitespace_nodes => :all}).root, buf)
+              rescue => e
+                @logger.error { "Invalid sending message: #{msg.inspect}: #{e.message}" }
+                raise "Invalid sending message: #{msg.inspect}: #{e.message}"
+              end
+            when REXML::Document
+              @formatter.write(msg.root, buf)
+            when REXML::Element
+              @formatter.write(msg, buf)
+            else
+              @logger.error { "Unexpected sending message: #{msg.inspect}" }
+              raise ArgumentError, "Unexpected sending message: #{msg.inspect}"
+            end
+            @logger.debug { "Sending message: #{buf.inspect}" }
+            begin
+              @io_w.write "#{buf}\n]]>]]>\n"
+            rescue => e
+              @logger.info { "Sender IO closed: #{e.class}: #{e.message}" }
+              raise IOError, "Sender IO closed: #{e.class}: #{e.message}"
+            end
+          end
+        end
+
+        class Receiver
+          def initialize io_r
+            @logger = Logger.new self.class.name
+            @io_r = io_r
+          end
+
+          def receive_message
+            buf = String.new
+            loop do
+              begin
+                tmp = @io_r.read(1)
+              rescue => e
+                @logger.info { "Receiver IO closed: #{e.class}: #{e.message}" }
+                return nil
+              end
+              if tmp.nil?
+                @logger.info { "Receiver IO closed" }
+                return nil
+              end
+              buf += tmp
+              if buf[-6..-1] == ']]>]]>'
+                break
+              end
+            end
+            @logger.debug { "Received message: #{buf[0..-7].inspect}" }
+            begin
+              received_msg = REXML::Document.new(buf[0..-7], {:ignore_whitespace_nodes => :all}).root
+              validate_received_msg received_msg
+              received_msg
+            rescue => e
+              info = "Invalid received message: #{e.message.split("\n").first}: #{buf[0..-7].inspect}"
+              @logger.info { info }
+              raise info
+            end
+          end
+
+          def validate_received_msg received_msg
+            unless received_msg
+              raise "No valid root tag interpreted"
+            end
+            unless "rpc" == received_msg.name
+              raise "Invalid message: expected #{"rpc".inspect}, but got #{received_msg.name.inspect}"
+            end
+            unless "urn:ietf:params:xml:ns:netconf:base:1.0" == received_msg.namespace
+              raise "Invalid namespace: expected #{"urn:ietf:params:xml:ns:netconf:base:1.0".inspect}, but got #{received_msg.namespace.inspect}"
+            end
+          end
+        end
+      end
+    end
+  end
+end