hrr_rb_netconf 0.1.0

data/lib/hrr_rb_netconf/server/error/operation_not_supported.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_netconf/server/error/rpc_errorable'
+
+module HrrRbNetconf
+  class Server
+    class Error
+      class OperationNotSupported < Error
+        include RpcErrorable
+
+        TAG      = 'operation-not-supported'
+        TYPE     = ['protocol', 'application']
+        SEVERITY = ['error']
+        INFO     = []
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/error/partial_operation.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_netconf/server/error/rpc_errorable'
+
+module HrrRbNetconf
+  class Server
+    class Error
+      class PartialOperation < Error
+        include RpcErrorable
+
+        TAG      = 'partial-operation'
+        TYPE     = ['application']
+        SEVERITY = ['error']
+        INFO     = ['ok-element', 'err-element', 'noop-element']
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/error/resource_denied.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_netconf/server/error/rpc_errorable'
+
+module HrrRbNetconf
+  class Server
+    class Error
+      class ResourceDenied < Error
+        include RpcErrorable
+
+        TAG      = 'resource-denied'
+        TYPE     = ['transport', 'rpc', 'protocol', 'application']
+        SEVERITY = ['error']
+        INFO     = []
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/error/rollback_failed.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_netconf/server/error/rpc_errorable'
+
+module HrrRbNetconf
+  class Server
+    class Error
+      class RollbackFailed < Error
+        include RpcErrorable
+
+        TAG      = 'rollback-failed'
+        TYPE     = ['protocol', 'application']
+        SEVERITY = ['error']
+        INFO     = []
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/error/rpc_errorable.rb

@@ -0,0 +1,138 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'rexml/document'
+
+module HrrRbNetconf
+  class Server
+    class Error < StandardError
+      module RpcErrorable
+        def initialize type, severity, info: nil, app_tag: nil, path: nil, message: nil
+          @logger   = Logger.new self.class.name
+
+          @tag      = self.class::TAG
+          @type     = type
+          @severity = severity
+          @info     = info
+          @app_tag  = app_tag
+          @path     = path
+          @message  = message
+
+          validate
+        end
+
+        def validate
+          validate_type
+          validate_severity
+          validate_info
+          validate_app_tag
+          validate_path
+          validate_message
+        end
+
+        def validate_type
+          unless self.class::TYPE.include? @type
+            raise ArgumentError.new "error-type arg must be one of #{self.class::TYPE}, but given #{@type}"
+          end
+        end
+
+        def validate_severity
+          unless self.class::SEVERITY.include? @severity
+            raise ArgumentError.new "error-severity arg must be one of #{self.class::SEVERITY}, but given #{@severity}"
+          end
+        end
+
+        def validate_info
+          unless self.class::INFO.empty?
+            unless @info.kind_of? Hash
+              raise ArgumentError.new "error-info arg must be a kind of Hash, but given #{@info.class}"
+            end
+            unless self.class::INFO.all?{ |e| @info[e] }
+              raise ArgumentError.new "error-info arg must contain #{self.class::INFO} as keys, but given #{@info}"
+            end
+          end
+        end
+
+        def validate_app_tag
+          # Pass
+        end
+
+        def validate_path
+          if @path
+            case @path
+            when Hash
+              unless @path['value']
+                raise ArgumentError.new "error-path arg must contain 'value' key if Hash"
+              end
+            end
+          end
+        end
+
+        def validate_message
+          if @message
+            case @message
+            when Hash
+              unless @message['value']
+                raise ArgumentError.new "error-message arg must contain \"value\" key if Hash"
+              end
+              unless @message.fetch('attributes', {}).keys.include?('xml:lang')
+                @logger.warn { "error-message arg does not contain \"xml:lang\" attribute, so assuming \"en\"" }
+              end
+            else
+              @logger.warn { "error-message arg does not contain \"xml:lang\" attribute, so assuming \"en\"" }
+            end
+          end
+        end
+
+        def to_rpc_error
+          xml_doc = REXML::Document.new
+          rpc_error_e = xml_doc.add_element 'rpc-error'
+          tag_e = rpc_error_e.add_element 'error-tag'
+          tag_e.text = @tag
+          type_e = rpc_error_e.add_element 'error-type'
+          type_e.text = @type
+          severity_e = rpc_error_e.add_element 'error-severity'
+          severity_e.text = @severity
+          if @info
+            info_e = rpc_error_e.add_element 'error-info'
+            case @info
+            when Hash
+              @info.each{ |k, v|
+                child_e = info_e.add_element k
+                child_e.text = v
+              }
+            else
+              info_e.text = @info
+            end
+          end
+          if @app_tag
+            app_tag_e = rpc_error_e.add_element 'error-app-tag'
+            app_tag_e.text = @app_tag
+          end
+          if @path
+            path_e = rpc_error_e.add_element 'error-path'
+            case @path
+            when Hash
+              path_e.add_attributes @path['attributes']
+              path_e.text = @path['value']
+            else
+              path_e.text = @path
+            end
+          end
+          if @message
+            message_e = rpc_error_e.add_element 'error-message'
+            message_e.add_attribute 'xml:lang', 'en'
+            case @message
+            when Hash
+              message_e.add_attributes @message['attributes']
+              message_e.text = @message['value']
+            else
+              message_e.text = @message
+            end
+          end
+          xml_doc.root
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/error/too_big.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_netconf/server/error/rpc_errorable'
+
+module HrrRbNetconf
+  class Server
+    class Error
+      class TooBig < Error
+        include RpcErrorable
+
+        TAG      = 'too-big'
+        TYPE     = ['transport', 'rpc', 'protocol', 'application']
+        SEVERITY = ['error']
+        INFO     = []
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/error/unknown_attribute.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_netconf/server/error/rpc_errorable'
+
+module HrrRbNetconf
+  class Server
+    class Error
+      class UnknownAttribute < Error
+        include RpcErrorable
+
+        TAG      = 'unknown-attribute'
+        TYPE     = ['rpc', 'protocol', 'application']
+        SEVERITY = ['error']
+        INFO     = ['bad-attribute', 'bad-element']
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/error/unknown_element.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_netconf/server/error/rpc_errorable'
+
+module HrrRbNetconf
+  class Server
+    class Error
+      class UnknownElement < Error
+        include RpcErrorable
+
+        TAG      = 'unknown-element'
+        TYPE     = ['protocol', 'application']
+        SEVERITY = ['error']
+        INFO     = ['bad-element']
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/error/unknown_namespace.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_netconf/server/error/rpc_errorable'
+
+module HrrRbNetconf
+  class Server
+    class Error
+      class UnknownNamespace < Error
+        include RpcErrorable
+
+        TAG      = 'unknown-namespace'
+        TYPE     = ['protocol', 'application']
+        SEVERITY = ['error']
+        INFO     = ['bad-element', 'bad-namespace']
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/errors.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'hrr_rb_netconf/server/error'
+
+module HrrRbNetconf
+  class Server
+    class Errors < StandardError
+      include Enumerable
+
+      def initialize *errors
+        @errors = errors.flatten
+        validate_errors
+      end
+
+      def validate_errors
+        unless @errors.all?{ |e| e.kind_of? HrrRbNetconf::Server::Error }
+          given = @errors.reject{ |e| e.kind_of? HrrRbNetconf::Server::Error }.map{ |e| e.class }
+          raise ArgumentError.new "Wrong argument type: given #{given}, expected HrrRbNetconf::Server::Error"
+        end
+      end
+
+      def each &blk
+        @errors.each &blk
+      end
+    end
+  end
+end

data/lib/hrr_rb_netconf/server/filter.rb

@@ -0,0 +1,48 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+module HrrRbNetconf
+  class Server
+    class Filter
+      @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::TYPE == key }
+        end
+
+        def list
+          __subclass_list__(__method__).map{ |klass| klass::TYPE }
+        end
+
+        def __subclass_list__ method_name
+          send(:method_missing, method_name) unless @subclass_list
+          @subclass_list
+        end
+
+        def filter raw_output_e, input_e
+          filter_e = input_e.elements['filter']
+          if filter_e
+            filter_type = filter_e.attributes['type']
+            if self[filter_type]
+              self[filter_type].filter raw_output_e, filter_e
+            else
+              raise Error['bad-attribute'].new('protocol', 'error', info: {'bad-attribute' => filter_type, 'bad-element' => 'filter'})
+            end
+          else
+            raw_output_e
+          end
+        end
+
+        private :__subclass_list__
+      end
+    end
+  end
+end
+
+require 'hrr_rb_netconf/server/filter/subtree'
+require 'hrr_rb_netconf/server/filter/xpath'

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

@@ -0,0 +1,135 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'rexml/document'
+
+module HrrRbNetconf
+  class Server
+    class Filter
+      class Subtree < Filter
+        TYPE = 'subtree'
+
+        class << self
+          def filter raw_output_e, filter_e
+            selected_element_xpaths = []
+            output_xml_doc = REXML::Document.new 
+            subtree_e = filter_e.elements[1]
+            filter_recursively(selected_element_xpaths, output_xml_doc, raw_output_e, subtree_e)
+            output_xml_doc.root
+          end
+
+          def content_match_nodes_match_all? content_match_nodes, raw_output_e
+            content_match_nodes.all?{ |child_filter_e|
+              child_filter_attributes = child_filter_e.attributes.to_a.reject{ |attr| (attr.prefix =='' && attr.name == 'xmlns') || attr.prefix == 'xmlns' }
+              raw_output_e.elements.to_a.any?{ |child_raw_output_e|
+                (child_filter_e.namespace == "" || child_filter_e.namespace == child_raw_output_e.namespace) && child_filter_e.name == child_raw_output_e.name && child_filter_e.text == child_raw_output_e.text && (
+                  child_filter_attributes.empty? || child_filter_attributes.reject{ |child_filter_attr|
+                    child_raw_output_e.attributes.to_a.reject{ |attr| (attr.prefix =='' && attr.name == 'xmlns') || attr.prefix == 'xmlns' }.any?{ |child_raw_output_attr|
+                      (child_filter_attr.namespace == "" || child_filter_attr.namespace == child_raw_output_attr.namespace) && child_filter_attr.name == child_raw_output_attr.name && child_filter_attr.value == child_raw_output_attr.value
+                    }
+                  }
+                )
+              }
+            }
+          end
+
+          def add_elem selected_element_xpaths, output_e, raw_output_e, output_e_duplicated
+            if output_e_duplicated
+              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, false]
+              else
+                [elem, true]
+              end
+            else
+              child_output_e = output_e.add raw_output_e.clone
+              selected_element_xpaths.push [raw_output_e.xpath, child_output_e]
+              [child_output_e, false]
+            end
+          end
+
+          def filter_recursively selected_element_xpaths, output_e, raw_output_e, filter_e, options={}
+            if filter_e
+              if raw_output_e.name == filter_e.name
+                # Namespace Selection
+                filter_namespace = options['namespace'] || filter_e.namespace
+                if filter_namespace == nil || filter_namespace == "" || raw_output_e.namespace == filter_namespace
+                  # Attribute Match Expressions
+                  filter_attributes = filter_e.attributes.to_a.reject{ |attr| (attr.prefix =='' && attr.name == 'xmlns') || attr.prefix == 'xmlns' }
+                  if filter_attributes.empty? || filter_attributes.reject{ |filter_attr|
+                    raw_output_e.attributes.to_a.reject{ |attr| (attr.prefix =='' && attr.name == 'xmlns') || attr.prefix == 'xmlns' }.any?{ |raw_output_attr|
+                      filter_attr.namespace == raw_output_attr.namespace && filter_attr.name == raw_output_attr.name && filter_attr.value == raw_output_attr.value
+                    }
+                  }.empty?
+                    if filter_e.has_elements?
+                      # Containment Nodes
+                      if filter_e.elements.to_a.select{ |c| c.has_text? }.empty?
+                        child_output_e, child_output_e_duplicated = add_elem selected_element_xpaths, output_e, raw_output_e, options['output_e_duplicated']
+                        raw_output_e.each_element{ |child_raw_output_e|
+                          filter_e.elements.to_a.select{ |c| c.name == child_raw_output_e.name && (c.namespace == "" || c.namespace == child_raw_output_e.namespace) }.each{ |child_filter_e|
+                              unless child_output_e_duplicated
+                                if selected_element_xpaths.any?{ |xpath, elem| xpath == child_raw_output_e.xpath }
+                                  child_output_e_duplicated = true
+                                end
+                              end
+                            filter_recursively selected_element_xpaths, child_output_e, child_raw_output_e, child_filter_e, {'namespace' => filter_namespace, 'output_e_duplicated' => child_output_e_duplicated}
+                          }
+                        }
+                      # Content Match Nodes
+                      else
+                        content_match_nodes = filter_e.elements.to_a.select{ |c| c.has_text? }
+                        not_content_match_nodes = filter_e.elements.to_a.reject{ |c| c.has_text? }
+                        if content_match_nodes_match_all? content_match_nodes, raw_output_e
+                          child_output_e, child_output_e_duplicated = add_elem selected_element_xpaths, output_e, raw_output_e, options['output_e_duplicated']
+                          if not_content_match_nodes.empty?
+                            raw_output_e.each_element{ |child_raw_output_e|
+                              child_filter_e = filter_e.elements.to_a.find{ |c| (c.namespace == "" || child_raw_output_e.namespace == c.namespace) && child_raw_output_e.name == c.name }
+                              if child_filter_e
+                                filter_recursively selected_element_xpaths, child_output_e, child_raw_output_e, child_filter_e, {'namespace' => filter_namespace, 'output_e_duplicated' => child_output_e_duplicated}
+                              else
+                                filter_recursively selected_element_xpaths, child_output_e, child_raw_output_e, child_filter_e, {'namespace' => filter_namespace, 'in_filter' => true, 'output_e_duplicated' => child_output_e_duplicated}
+                              end
+                            }
+                          else
+                            raw_output_e.each_element{ |child_raw_output_e|
+                              child_filter_e = filter_e.elements.to_a.find{ |c| (c.namespace == "" || child_raw_output_e.namespace == c.namespace) && child_raw_output_e.name == c.name }
+                              filter_recursively selected_element_xpaths, child_output_e, child_raw_output_e, child_filter_e, {'namespace' => filter_namespace, 'output_e_duplicated' => child_output_e_duplicated}
+                            }
+                          end
+                        else
+                        end
+                      end
+                    else
+                      child_output_e, child_output_e_duplicated = add_elem selected_element_xpaths, output_e, raw_output_e, options['output_e_duplicated']
+                      if raw_output_e.has_text?
+                        child_output_e.text = raw_output_e.text
+                      else
+                        raw_output_e.each_element{ |child_raw_output_e|
+                          filter_recursively selected_element_xpaths, child_output_e, child_raw_output_e, nil, {'namespace' => filter_namespace, 'in_filter' => true, 'output_e_duplicated' => child_output_e_duplicated}
+                        }
+                      end
+                    end
+                  end
+                end
+              end
+            elsif options['in_filter']
+              # Namespace Selection
+              filter_namespace = options['namespace']
+              if filter_namespace == nil || filter_namespace == "" || raw_output_e.namespace == filter_namespace
+                child_output_e, child_output_e_duplicated = add_elem selected_element_xpaths, output_e, raw_output_e, options['output_e_duplicated']
+                if raw_output_e.has_text?
+                  child_output_e.text = raw_output_e.text
+                end
+                raw_output_e.each_element{ |child_raw_output_e|
+                  filter_recursively selected_element_xpaths, child_output_e, child_raw_output_e, filter_e, {'namespace' => filter_namespace, 'in_filter' => true, 'outout_e_duplicated' => child_output_e_duplicated}
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end