acirb 1.0.4h

data/lib/mo.rb

@@ -0,0 +1,203 @@
+require 'restclient'
+require 'rexml/document'
+require 'json'
+
+# rubocop:disable ClassLength
+module ACIrb
+  # A generic managed object class
+  class MO
+    # Class variable properties
+    class << self
+      # for class variables
+      attr_reader :prefix, :class_name, :child_classes, :props,
+                  :naming_props, :prefixes, :ruby_class, :containers
+    end
+
+    # for instance variables
+    attr_reader :children, :attributes
+    attr_accessor :parent
+
+    def prefixes
+      self.class.prefixes
+    end
+
+    def child_classes
+      self.class.child_classes
+    end
+
+    def containers
+      self.class.containers
+    end
+
+    def naming_props
+      self.class.naming_props
+    end
+
+    def props
+      self.class.props
+    end
+
+    def class_name
+      self.class.class_name
+    end
+
+    def ruby_class
+      self.class.ruby_class
+    end
+
+    def initialize(create_parent, create_attr = {})
+      @attributes = {}
+      props.each do |prop|
+        @attributes[prop.to_s] = ''
+      end
+      @children = []
+
+      if create_parent.nil?
+        @parent = nil
+      else
+        @parent = create_parent
+        @parent.add_child(self)
+      end
+
+      # 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
+      end
+      @attributes['dn'] = build_dn
+    end
+
+    def add_child(child)
+      unless child.containers.include?(ruby_class)
+        fail child.class.to_s + ' cannot be child of ' + self.class.to_s
+      end
+      @children.each do |mo|
+        return nil if mo.dn == child.dn
+      end
+      @children.push(child)
+      child.parent = self
+    end
+
+    def set_prop(key, val)
+      key = key.to_s
+      val = val.to_s
+      return if key == 'dn' || key == 'rn'
+      @attributes[key] = val
+      if naming_props.include? key
+        dn_str = build_dn
+        @attributes['dn'] = dn_str
+      end
+    end
+
+    def root
+      p = self
+      p = p.parent until p.parent.nil?
+      p
+    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 != ''
+      end
+      @children.each do |child|
+        x.add_element(child.to_xml)
+      end
+      x
+    end
+
+    def to_hash
+      h = {}
+      h[mo_type.to_s] = {}
+      h[mo_type.to_s]['attributes'] = @attributes
+      h[mo_type.to_s]['attributes']['dn'] = dn
+      h[mo_type.to_s]['children'] = [] if children.length > 0
+      @children.each do |child|
+        h[mo_type.to_s]['children'].push(child.to_hash)
+      end
+      h
+    end
+
+    def to_json
+      JSON.dump(to_hash)
+    end
+
+    def create(restclient)
+      @attributes['status'] = 'created,modified'
+      restclient.post(data: self,
+                      url: "/api/mo/#{dn}.#{restclient.format}")
+    end
+
+    def destroy(restclient)
+      @attributes['status'] = 'deleted'
+      restclient.post(data: self,
+                      url: "/api/mo/#{dn}.#{restclient.format}")
+    end
+
+    def exists(restclient, recurse = false)
+      options = {}
+      options[:subtree] = 'full' if recurse
+      if restclient.lookupByDn(dn, options)
+        if recurse == true
+          children.each do |child|
+            unless child.exists(restclient, recurse = true)
+              return false
+            end
+          end
+        end
+        return true
+      else
+        return false
+      end
+    end
+
+    def build_dn
+      if @parent.nil?
+        return rn
+      else
+        parent_dn = '' << @parent.dn
+        if parent_dn == ''
+          return rn
+        else
+          parent_dn << '/'
+          parent_dn << rn
+          return parent_dn
+        end
+      end
+    end
+
+    def mo_type
+      self.class.class_name.delete('.')
+    end
+
+    def to_s
+      def hash_to_table(h)
+        len = h.keys.map(&:length).max
+        ret = []
+        h.each do |k, v|
+          ret.push(('%' + len.to_s + 's: %s') % [k.to_s, v.to_s])
+        end
+        ret
+      end
+      header_table = hash_to_table(
+        'Class' => class_name,
+      )
+      attribute_table = hash_to_table(attributes)
+      header_table.push(attribute_table)
+      header_table.join("\n")
+    end
+
+    def method_missing(name, *args, &block)
+      lookup_name = name.to_s
+      return @attributes[lookup_name] if @attributes.include? lookup_name
+      child_matches = []
+      @children.each do |child|
+        child_matches.push(child) if child.class.prefix.sub('-', '') == lookup_name
+      end
+      return child_matches if child_matches.length > 0
+      super
+    end
+  end
+end

data/lib/naming.rb

@@ -0,0 +1,124 @@
+module ACIrb
+  class Naming
+    def self.split_outside_brackets(dn_str, splitChar)
+      depth = 0
+      place = 0
+      last_split = 0
+      pieces = []
+      while place < dn_str.length
+        c = dn_str[place]
+        if c == '['
+          depth += 1
+        elsif c == ']'
+          depth -= 1
+        end
+        if depth == 0 && c == splitChar && place != 0
+          pieces.push(dn_str[last_split..place])
+          last_split = place + 1
+        end
+        place += 1
+      end
+      pieces.push(dn_str[last_split..place - 1]) if place != last_split
+
+      pieces
+    end
+
+    def self.strip_last_delimiter(str, delim)
+      if str[-1] == delim
+        return str[0..-2]
+      else
+        return str
+      end
+    end
+
+    def self.strip_outer_brackets(str)
+      if str[0] == '[' && str[-1] == ']'
+        return str[1..-2]
+      else
+        return str
+      end
+    end
+
+    def self.split_dn_str(dn_str)
+      rns = []
+      split_outside_brackets(dn_str, '/').each do |rn|
+        rns.push(strip_last_delimiter(rn, '/'))
+      end
+      rns
+    end
+
+    def self.split_rn_str(rn_str, delims)
+      rn_pieces = []
+      delims.each_with_index do |(delim, _has_prop), index|
+        begin_delim = rn_str.split(delim)
+
+        if index == delims.length - 1
+          name_prop = begin_delim[1]
+        else
+          rn_str = begin_delim[1]
+          end_delim = rn_str.split(delims[index + 1][0])
+          name_prop = end_delim[0]
+        end
+
+        rn_pieces.push(delim)
+        rn_pieces.push(name_prop)
+      end
+      rn_pieces
+    end
+
+    def self.get_mo_from_dn(dn_str)
+      rns = split_dn_str(dn_str)
+      mo = ACIrb::TopRoot.new(nil)
+      rns.each do |rn|
+        mo = get_mo_from_rn(mo, rn)
+      end
+      mo
+    end
+
+    def self.get_mo_from_rn(parent_mo, rn_str)
+      mo = get_class_from_child_prefix(parent_mo, rn_str).new(parent_mo)
+      return mo if mo.naming_props.length == 0
+      rn_pieces = split_rn_str(rn_str, mo.prefixes)
+      rn_values = rn_pieces.values_at(*(1..rn_pieces.length - 1).step(2))
+      mo.naming_props.each_with_index do |prop_name, index|
+        prop_val = rn_values[index]
+        mo.set_prop(prop_name.to_s, strip_outer_brackets(prop_val))
+      end
+      mo
+    end
+
+    def self.match_prefix_in_list(rn_str, prefix_list)
+      matches = false
+      prefix_match = ''
+      prefix_list.each do |prefix|
+        if rn_str.start_with?(prefix)
+          matches = true
+          prefix_match = prefix
+          break
+        end
+      end
+
+      return prefix_match if matches
+
+      return nil
+    end
+
+    def self.get_class_from_child_prefix(parent_mo, rn_str)
+      prefix_to_class = {}
+      parent_mo.child_classes.each do |c|
+        cls = ACIrb.const_get(c)
+        prefix_to_class[cls.prefix] = cls
+      end
+
+      lpm = prefix_to_class.keys.sort_by { |x| -1 * x.length }
+      prefix_match = match_prefix_in_list(rn_str, lpm)
+
+      if prefix_match
+        return prefix_to_class[prefix_match]
+      else
+        fail 'Unknown child prefix ' + rn_str + ' in container class ' +
+          parent_mo.class.to_s
+      end
+    end
+  end
+end

data/lib/query.rb

@@ -0,0 +1,69 @@
+require 'restclient'
+
+# rubocop:disable ClassLength
+# rubocop:disable FormatString
+module ACIrb
+  # Generic Query Interface
+  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
+
+    def make_options
+      query_params = []
+
+      query_params.push('rsp-subtree=%s' % @subtree) \
+        if @subtree
+      query_params.push('target-subtree-class=%s' % @class_filter) \
+        if @class_filter
+      query_params.push('query-target=%s' % @query_target) \
+        if @query_target
+      query_params.push('rsp-subtree-class=%s' % @subtree_class_filter) \
+        if @subtree_class_filter
+      query_params.push('query-target-filter=%s' % @prop_filter) \
+        if @prop_filter
+      query_params.push('rsp-subtree-filter=%s' % @subtree_prop_filter) \
+        if @subtree_prop_filter
+      query_params.push('rsp-subtree-include=%s' % @subtree_include) \
+        if @subtree_include
+      query_params.push('page-size=%s' % @page_size) \
+        if @page_size
+      query_params.push('order-by=%s' % @sort_order) \
+        if @sort_order
+      query_params.push('rsp-prop-include=%s' % @include_prop) \
+        if @include_prop
+      query_params.push('subscription=yes') \
+        if @subscribe
+
+      if query_params.length > 0
+        '?' + query_params.join('&')
+      else
+        ''
+      end
+    end
+  end
+
+  # Dn Query
+  class DnQuery < Query
+    attr_accessor :dn
+    def initialize(dn)
+      @dn = dn
+    end
+
+    def uri(format)
+      '/api/mo/%s.%s%s' % [@dn, format, make_options]
+    end
+  end
+
+  # Class Query
+  class ClassQuery < Query
+    attr_accessor :cls
+    def initialize(cls)
+      @cls = cls
+    end
+
+    def uri(format)
+      '/api/class/%s.%s%s' % [@cls, format, make_options]
+    end
+  end
+end

data/lib/restclient.rb

@@ -0,0 +1,198 @@
+require 'httpclient'
+require 'openssl'
+require 'nokogiri'
+require 'json'
+# require 'uri'
+
+# rubocop:disable ClassLength
+module ACIrb
+  # REST client end point implementation
+
+  class RestClient
+    attr_accessor :format, :user, :password, :baseurl, :debug, :refresh_time
+    attr_reader :auth_cookie
+    # Desc: initialize a rest client
+    # Returns: does not return anything, but will raise an exception
+    #   if authentication fails
+    # Parameters: accepts a hash of options:
+    #   url : string. URL of APIC
+    #   user : string. User ID for authentication
+    #   password : string. Password for authentication
+    #   debug : true or false. Flag for enabling verbose REST output
+    #   format : 'xml' or 'json'. Defaults to xml
+    #   verify : true or false. verify the SSL certificate. Defaults to disabled
+    def initialize(options = {})
+      uri = URI.parse(options[:url])
+      @baseurl = '%s://%s' % [uri.scheme, uri.host]
+      @format = options[:format] ? options[:format] : 'xml'
+
+      @user = options[:user]
+      @password = options[:password]
+
+      @client = HTTPClient.new
+
+      @client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE \
+        unless options[:verify] && uri.scheme == 'https'
+
+      @debug = options[:debug]
+
+      @auth_cookie = ''
+
+      authenticate if @user && @password
+    end
+
+    # Desc: authenticates the REST session with the APIC and receives an
+    #   auth_cookie/token
+    # Returns: does not return anything, but will raise an exception if
+    #   authentication fails
+    # Parameters: does not accept any parameters
+    def authenticate
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.aaaUser(name: @user, pwd: @password)
+      end
+      post_url = URI.encode(@baseurl.to_s + '/api/mo/aaaLogin.xml')
+      puts 'POST REQUEST', post_url if @debug
+      puts 'POST BODY', builder.to_xml if @debug
+      response = @client.post(post_url, body: builder.to_xml)
+      puts 'POST RESPONSE: ', response.body if @debug
+      doc = Nokogiri::XML(response.body)
+      fail 'Authentication error(%s): %s' % [doc.at_css('error')['code'], doc.at_css('error')['text']] \
+        if doc.at_css('error')
+      @auth_cookie = doc.at_css('aaaLogin')['token']
+      @refresh_time = doc.at_css('aaaLogin')['refreshTimeoutSeconds']
+    end
+
+    def refresh_session
+      get_url = URI.encode(@baseurl.to_s + '/api/mo/aaaRefresh.xml')
+      puts 'GET REQUEST', get_url if @debug
+      response = @client.get(get_url)
+      puts 'GET RESPONSE: ', response.body if @debug
+      doc = Nokogiri::XML(response.body)
+      fail 'Authentication error(%s): %s' % [doc.at_css('error')['code'], doc.at_css('error')['text']] \
+        if doc.at_css('error')
+      @auth_cookie = doc.at_css('aaaLogin')['token']
+      @refresh_time = doc.at_css('aaaLogin')['refreshTimeoutSeconds']
+    end
+
+    # Desc: Perform a Net::HTTP::Post to the REST interface with the
+    #   parameters provided
+    # Returns: an array of managed object containing the parsed result
+    # Parameters: a single hash array is accepted, with the following keys:
+    #   data : This is a string containing the data to be posted. This
+    #      should be well formed XML that the APIC REST interface can interpret.
+    #      No validation is done
+    #   url : this is the path to the REST interface method being
+    #      utilized, typicalliy /api/mo/.xml
+
+    def post(options)
+      post_url = URI.encode(@baseurl.to_s + options[:url].to_s)
+
+      data = options[:data]
+      if @format == 'xml'
+        data = data.to_xml
+      elsif @format == 'json'
+        data = data.to_json
+      end
+
+      puts 'POST REQUEST', post_url if @debug
+      puts 'POST BODY', data if @debug
+      response = @client.post(post_url, body: data)
+      puts 'POST RESPONSE: ', response.body if @debug
+
+      parse_response(response)
+    end
+
+    # Desc: Perform a Net::HTTP::Get to the REST interface with the
+    #   parameters provided
+    # Returns: an array of managed object containing the parsed result
+    # Parameters: a single hash array is accepted, with the following keys:
+    #   url : this is the path to the REST interface method being utilized,
+    #     typicalliy /api/mo/.xml with some parameters
+
+    def get(options)
+      get_url = URI.encode(@baseurl.to_s + options[:url].to_s)
+
+      puts 'GET REQUEST', get_url if @debug
+      response = @client.get(get_url)
+      puts 'GET RESPONSE: ', response.body if @debug
+
+      parse_response(response)
+    end
+
+    def parse_error(doc)
+      if format == 'xml'
+        fail 'Error response from APIC (%s): "%s"' % \
+          [doc.at_css('error')['code'], doc.at_css('error')['text']] \
+          if doc.at_css('error')
+      elsif format == 'json'
+        fail 'Error response from APIC (%s): "%s"' % \
+          [doc['imdata'][0]['error']['attributes']['code'].to_s, \
+           doc['imdata'][0]['error']['attributes']['text'].to_s] \
+           if doc['imdata'].length > 0 && doc['imdata'][0].include?('error')
+      end
+    end
+
+    def parse_response(response)
+      if format == 'xml'
+        xml_data = response.body
+        doc = Nokogiri::XML(xml_data)
+
+        parse_error(doc)
+
+        mos = []
+        doc.root.elements.each do |xml_obj|
+          mo = ACIrb::Loader.load_xml(xml_obj)
+          mos.push(mo)
+        end
+
+        return mos
+
+      elsif format == 'json'
+        json_data = response.body
+        doc = JSON.parse(json_data)
+
+        parse_error(doc)
+
+        mos = []
+        doc['imdata'].each do |json_obj|
+          mo = ACIrb::Loader.load_json(json_obj)
+          mos.push(mo)
+        end
+
+        return mos
+      end
+    end
+
+    def query(query)
+      query_uri = query.uri(@format)
+      get(url: query_uri)
+    end
+
+    # Desc: A helper function that will lookup a given DN via the
+    #   APIC REST interface
+    # Returns: Returns Mo for match if one exists, otherwise nil
+    # Parameters:
+    #   dn : string. the distinguished name to query
+    #   options : hash. set query parameters
+
+    def lookupByDn(dn, options = {})
+      subtree = options[:subtree]
+      dn_query = ACIrb::DnQuery.new(dn)
+      dn_query.subtree = subtree
+
+      mos = query(dn_query)
+      if mos.length == 1
+        return mos[0]
+      else
+        return nil
+      end
+    end
+
+    def lookupByClass(cls, options = {})
+      subtree = options[:subtree]
+      cls_query = ACIrb::ClassQuery.new(cls)
+      cls_query.subtree = subtree
+      query(cls_query)
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module ACIrb
+  VERSION = '1.0.4h'
+end