acirb 1.0.4h → 1.0.4.1

data/lib/acirb.rb

@@ -6,7 +6,7 @@ require 'naming'
 require 'restclient'
 require 'version'
 require 'query'
-#require 'events'
+require 'events'
 
 module ACIrb
 end

data/lib/events.rb

@@ -1,27 +1,164 @@
 require 'restclient'
-require 'websocket-eventmachine-client'
+require 'websocket'
+require 'socket'
+require 'openssl'
+require 'nokogiri'
+require 'json'
 
 # rubocop:disable ClassLength
-# rubocop:disable FormatString
 module ACIrb
   # Event channel interface
+
   class EventChannel
-    attr_accessor :websocket
-    def initialize(rest)
+    attr_accessor :rest
+
+    class ApicWebSocketRecvTimeout < StandardError
+    end
+
+    class WebSocketNoHandshake < StandardError
+    end
+
+    def initialize(rest, _options = {})
       @rest = rest
+
       uri = URI.parse(@rest.baseurl)
 
       if uri.scheme == 'https'
         scheme = 'wss'
+        secure = true
       else
         scheme = 'ws'
+        secure = false
+      end
+
+      url = '%s://%s/socket%s' % [scheme, uri.host, rest.auth_cookie]
+
+      @handshake = WebSocket::Handshake::Client.new(url: url)
+      @frame = WebSocket::Frame::Incoming::Server.new(version: @handshake.version)
+
+      @socket = TCPSocket.new(@handshake.host, uri.port)
+
+      if secure
+        puts 'connecting over secure websocket'
+        ctx = OpenSSL::SSL::SSLContext.new
+
+        ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE unless rest.verify
+
+        ssl_sock = OpenSSL::SSL::SSLSocket.new(@socket, ctx)
+        ssl_sock.sync_close = true
+        ssl_sock.connect
+
+        @transport_socket = @socket
+        @socket = ssl_sock
+      else
+        @transport_socket = nil
+      end
+
+      @socket.write(@handshake.to_s)
+      @socket.flush
+
+      loop do
+        data = @socket.getc
+        next if data.nil?
+
+        @handshake << data
+
+        if @handshake.finished?
+          fail @handshake.error.to_s unless @handshake.valid?
+          @handshaked = true
+          break
+        end
+      end
+    end
+
+    def send(data, type = :text)
+      fail WebSocketNoHandshake unless @handshaked
+
+      data = WebSocket::Frame::Outgoing::Client.new(
+        version: @handshake.version,
+        data: data,
+        type: type
+      ).to_s
+      @socket.write data
+      @socket.flush
+    end
+
+    def receive(timeout = nil)
+      fail WebSocketNoHandshake unless @handshaked
+
+      readable, writable, error = IO.select([@socket], nil, nil, timeout)
+      if readable
+        begin
+          data = @socket.read_nonblock(1024)
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK, (IO::WaitReadable if defined?(IO::WaitReadable)) => e
+          puts '%s, retrying' % e
+          retry
+        end
+      else
+        fail ApicWebSocketRecvTimeout, 'Timeout for websocket read'
+      end
+      @frame << data
+
+      messages = []
+      while message = @frame.next
+        if message.type === :ping
+          send(message.data, :pong)
+          return messages
+        end
+        messages << message.to_s
       end
 
-      @websocket = WebSocket::Handshake::Client.new(
-        url: '%s://%s/socket%s' % [scheme, uri.host, rest.auth_cookie])
+      events = []
+      messages.each do |msg|
+        events += MoEvent.parse_event(self, msg.to_s)
+      end
+      events
+    end
+
+    def close
+      @socket.close
+    end
+  end
 
+  class MoEvent
+    def initialize(_options = {})
     end
 
+    def self.parse_event(event_channel, event_str)
+      subscription = nil
+      events = []
+
+      if event_channel.rest.format == 'xml'
+        doc = Nokogiri::XML(event_str)
+        subscription_id = doc.at_css('imdata')['subscriptionId']
+        puts event_str
+        doc.root.elements.each do |xml_obj|
+          event = {
+            type: xml_obj.attributes['status'].to_s,
+            properties: Hash[xml_obj.attributes.map { |k, str| [k, str.value.to_s] }],
+            class: xml_obj.name,
+            subscription_id: subscription_id
+          }
+          events.push(event)
+        end
+      elsif event_channel.rest.format == 'json'
+        doc = JSON.parse(event_str, symbolize_names: false)
+        subscription_id = doc['subscriptionId']
+        imdata = doc['imdata']
+        imdata.each do |obj|
+          cls = obj.keys[0]
+          event = {
+            type: obj[cls]['attributes']['status'].to_s,
+            properties: Hash[obj[cls]['attributes'].map { |k, str| [k, str.to_s] }],
+            class: cls,
+            subscription_id: subscription_id[0]
+          }
+          events.push(event)
+        end
 
+      end
+
+      events
+    end
   end
 end

data/lib/loader.rb

@@ -29,6 +29,7 @@ module ACIrb
       element.attributes.each do |k, v|
         create_attr[k.to_s] = v.to_s
       end
+      create_attr[:mark_dirty] = false
       mo = mo.new(parent_mo, create_attr)
 
       element.elements.each do |e|
@@ -68,12 +69,13 @@ module ACIrb
 
       mo = ACIrb.const_get(ACIrb::CLASSMAP[class_name])
 
-      attributes = {}
+      create_attr = {}
       (values['attributes'] || {}).each do |propName, propVal|
-        attributes[propName.to_s] = propVal
+        create_attr[propName.to_s] = propVal
       end
 
-      mo = mo.new(parent_mo, attributes)
+      create_attr[:mark_dirty] = false
+      mo = mo.new(parent_mo, create_attr)
 
       (values['children'] || []).each do |child|
         mo.add_child(get_mo_from_hash(mo, child))

data/lib/mo.rb

@@ -10,44 +10,66 @@ module ACIrb
     class << self
       # for class variables
       attr_reader :prefix, :class_name, :child_classes, :props,
-                  :naming_props, :prefixes, :ruby_class, :containers
+                  :naming_props, :prefixes, :ruby_class, :containers,
+                  :read_only
     end
 
     # for instance variables
     attr_reader :children, :attributes
-    attr_accessor :parent
+    attr_accessor :parent, :dirty_props
 
+    # Internal: Returns class prefixes
     def prefixes
       self.class.prefixes
     end
 
+    # Internal: Returns child classes
     def child_classes
       self.class.child_classes
     end
 
+    # Internal: Returns containiner classes
     def containers
       self.class.containers
     end
 
+    # Internal: Returns naming properties
     def naming_props
       self.class.naming_props
     end
 
+    # Internal: Returns class properties
     def props
       self.class.props
     end
 
+    # Internal: Returns object class name in APIC package.class notation
     def class_name
       self.class.class_name
     end
 
+    # Internal: Returns class name as ruby package notation
     def ruby_class
       self.class.ruby_class
     end
 
-    def initialize(create_parent, create_attr = {})
+    # Interal: Returns boolean for if this class is read only
+    def read_only
+      self.class.read_only
+    end
+
+    def initialize(create_parent, create_options = {})
+      # always mark dirty unless otherwise specified
+      if create_options[:mark_dirty] == false
+        mark_dirty = false
+      else
+        mark_dirty = true
+      end
+      create_options.delete(:mark_dirty)
+
       @attributes = {}
-      props.each do |prop|
+      @dirty_props = []
+      props.each do |prop, _flags|
         @attributes[prop.to_s] = ''
       end
       @children = []
@@ -61,12 +83,16 @@ module ACIrb
 
       # for performance reasons, do not use set_prop here
       # and build the dn string after all attributes are set
-      create_attr.each do |k, v|
-        @attributes[k.to_s] = v
+      create_options.each do |k, v|
+        flags = props[k.to_s]
+        @attributes[k.to_s] = v.to_s
+        @dirty_props.push(k.to_s) if mark_dirty
       end
       @attributes['dn'] = build_dn
+      @attributes['rn'] = rn
     end
 
+    # Internal: Adds another MO object as a child to this class
     def add_child(child)
       unless child.containers.include?(ruby_class)
         fail child.class.to_s + ' cannot be child of ' + self.class.to_s
@@ -81,11 +107,16 @@ module ACIrb
     def set_prop(key, val)
       key = key.to_s
       val = val.to_s
+
       return if key == 'dn' || key == 'rn'
+
       @attributes[key] = val
+      @dirty_props.push(key)
+
       if naming_props.include? key
         dn_str = build_dn
         @attributes['dn'] = dn_str
+        @attributes['rn'] = rn
       end
     end
 
@@ -95,14 +126,34 @@ module ACIrb
       p
     end
 
+    def get_attributes_to_include
+      incl_attr = {}
+      @attributes.each do |key, value|
+        if props[key.to_s]['isDn'] == true || props[key.to_s]['isRn'] == true || @dirty_props.include?(key) || naming_props.include?(key)
+          incl_attr[key.to_s] = value
+        end
+      end
+      incl_attr
+    end
+
+    def get_children_to_include
+      incl_children = []
+      @children.each do |child|
+        incl_children.push(child) if child.read_only == false
+      end
+      incl_children
+    end
+
     def to_xml
       # TODO: Use nokogiri here
       #   https://github.com/sparklemotion/nokogiri/wiki/Cheat-sheet
       x = REXML::Element.new mo_type.to_s
-      @attributes.each do |key, value|
-        x.attributes[key.to_s] = value if value.to_s != ''
+
+      get_attributes_to_include.each do |key, value|
+        x.attributes[key.to_s] = value
       end
-      @children.each do |child|
+
+      get_children_to_include.each do |child|
         x.add_element(child.to_xml)
       end
       x
@@ -111,10 +162,13 @@ module ACIrb
     def to_hash
       h = {}
       h[mo_type.to_s] = {}
-      h[mo_type.to_s]['attributes'] = @attributes
+      h[mo_type.to_s]['attributes'] = {}
+      get_attributes_to_include.each do |key, value|
+        h[mo_type.to_s]['attributes'][key.to_s] = value
+      end
       h[mo_type.to_s]['attributes']['dn'] = dn
       h[mo_type.to_s]['children'] = [] if children.length > 0
-      @children.each do |child|
+      get_children_to_include.each do |child|
         h[mo_type.to_s]['children'].push(child.to_hash)
       end
       h
@@ -125,15 +179,17 @@ module ACIrb
     end
 
     def create(restclient)
-      @attributes['status'] = 'created,modified'
+      self.status = 'created,modified'
       restclient.post(data: self,
                       url: "/api/mo/#{dn}.#{restclient.format}")
+      @dirty_props = []
     end
 
     def destroy(restclient)
-      @attributes['status'] = 'deleted'
+      self.status = 'deleted'
       restclient.post(data: self,
                       url: "/api/mo/#{dn}.#{restclient.format}")
+      @dirty_props = []
     end
 
     def exists(restclient, recurse = false)
@@ -182,7 +238,7 @@ module ACIrb
         ret
       end
       header_table = hash_to_table(
-        'Class' => class_name,
+        'Class' => class_name
       )
       attribute_table = hash_to_table(attributes)
       header_table.push(attribute_table)
@@ -191,7 +247,8 @@ module ACIrb
 
     def method_missing(name, *args, &block)
       lookup_name = name.to_s
-      return @attributes[lookup_name] if @attributes.include? lookup_name
+      return @attributes[lookup_name] if @attributes.key? lookup_name
+      return set_prop(lookup_name.chomp('='), args[0]) if @attributes.key? lookup_name.chomp('=')
       child_matches = []
       @children.each do |child|
         child_matches.push(child) if child.class.prefix.sub('-', '') == lookup_name

data/lib/naming.rb

@@ -100,7 +100,7 @@ module ACIrb
 
       return prefix_match if matches
 
-      return nil
+      nil
     end
 
     def self.get_class_from_child_prefix(parent_mo, rn_str)

data/lib/query.rb

@@ -7,7 +7,7 @@ module ACIrb
   class Query
     attr_accessor :subtree, :class_filter, :query_target, :subtree_class_filter,
                   :prop_filter, :subtree_prop_filter, :subtree_include,
-                  :page_size, :include_prop, :subscribe, :sort_order
+                  :page_size, :include_prop, :subscribe, :sort_order, :page
 
     def make_options
       query_params = []
@@ -28,6 +28,8 @@ module ACIrb
         if @subtree_include
       query_params.push('page-size=%s' % @page_size) \
         if @page_size
+      query_params.push('page=%s' % @page) \
+        if @page
       query_params.push('order-by=%s' % @sort_order) \
         if @sort_order
       query_params.push('rsp-prop-include=%s' % @include_prop) \