icontrol 0.3.2 → 0.3.3

data/.yardopts

@@ -0,0 +1,9 @@
+--no-private
+--plugin examples-from-rspec
+-m rdoc
+lib/**/*rb
+spec/**/*.rb
+-
+README.rdoc
+LICENSE
+

data/README.rdoc

@@ -17,19 +17,35 @@ In order to configure you just have to set up the username, password and the ser
 
 = Using the library
 
+Bassically the library is the same as the one documented in the f5 devcentral but using ruby docs (http://devcentral.f5.com/wiki/default.aspx/iControl/APIReference.html). The main difference is that while the icontrol api does allow the bulk operation over a number of elements at the same time, in this case we limit it to just one at a time. So, for example, if you one to set the default pool for a virtual server, in the f5 doc, it says you have to pass 2 parameters
+    set_default_pool_name(
+      in String [] virtual_servers,
+      in String [] default_pools
+   );
+So you can change several default pools at a time. On the contrary this library adopts a more object oriented design and only allows to work with one object at a time, i. e. and talking ruby, you don't have a set_default_pool_name class method but an instance one, so you have to first retreive the virtual server and later set its default pool. Something like this
+  IControl::LocalLB::VirtualServer.find("my_virtual_server).set_default_pool_name(:default_pool => "the default pool name")
+if you want to do it in every virtual server then you do something like this.
+  IControl::LocalLB::VirtualServer.find(:all).each { |vs| vs.set_default_pool_name(:default_pool => "the default pool name") }
+I think you get the point. Note that now the parameter name is :default_pool and not :default_pools, because of the semantics change.
+
 == Virtual Servers
 
 You can retreive, create, delete and modify virtual servers, for more information see IControl::LocalLB::VirtualServer. As an example of you what you can do:
 
 === Creating a virtual Server
- new_virtual_server = IControl::LocalLB::VirtualServer.create(:name => "foo_virtual_server",
-                                  :address => "192.168.1.1",
-                                  :port => "80",
-                                  :protocol => IControl::Common::ProtocolType::PROTOCOL_TCP,
-                                  :wildmask => "255.255.255.255",
-                         	  :type => IControl::LocalLB::VirtualServer::Type::RESOURCE_TYPE_POOL,
-                                  :default_pool =>  foo_pool,
-                                  :profiles => [])
+  IControl::LocalLB::VirtualServer.create(:definition => {
+                                            :address => "192.168.99.99",
+                                            :name => "test_virtual_server",
+                                            :port => "4",
+                                            :protocol => IControl::Common::ProtocolType::PROTOCOL_TCP
+                                          },
+                                          :wildmask => "255.255.255.255",
+                                          :resource => {
+                                            :type => IControl::LocalLB::VirtualServer::VirtualServerType::RESOURCE_TYPE_POOL,
+                                            :default_pool_name => ""
+                                          },
+                                          :profiles => [])
+
 
 === Obtaining an instance of a virtual server
 
@@ -39,7 +55,7 @@ You can retreive, create, delete and modify virtual servers, for more informatio
 
 === Changing its default pool
 
- my_virtual_server.default_pool = IControl::LocalLB::Pool.find("my_new_default_pool")
+ my_virtual_server.set_default_pool_name(:default_pool => "my_pool_name")
 
 === Destroying it
 
@@ -56,5 +72,5 @@ You can retreive, create, delete and modify virtual servers, for more informatio
 * Send me a pull request. Bonus points for topic branches.
 
 == Copyright
-
+This documentation is based on the original documentation procided by F5 Networks, Inc., Seattle, Washington
 Copyright (c) 2010 Jose Fernandez (magec). See LICENSE for details.

data/lib/icontrol/base.rb

@@ -13,6 +13,7 @@ require 'base/sequence'
 require 'base/predeclarations'
 require 'base/exception'
 require 'base/icontrol_overlay'
+require 'base/xml'
 
 Savon.log = false
 HTTPI::Adapter.use = :net_http
@@ -51,6 +52,11 @@ module IControl
     include IControl::Base::Attributable
         
     class << self
+
+      attr_accessor :id_name
+      def set_id_name(name)
+        @id_name = name
+      end
       
       def class_name
         name.split("::").last
@@ -79,8 +85,49 @@ module IControl
         return @client
       end
 
+      def symbolize(data)
+        if data.is_a? Hash
+          out = data.inject({}) do |hash,(key,value)|
+            value = case value
+                    when ::Hash then value["xsi:nil"] ? nil : symbolize(value)
+                    when ::Array then value.map { |val| symbolize(val) rescue val }
+                    when ::String then value
+                    end
+
+            new_key = if Savon.strip_namespaces?
+                        key.strip_namespace.snakecase.to_sym
+                      else
+                        key.snakecase
+                      end
+            if hash[new_key] # key already exists, value should be added as an Array
+              hash[new_key] = [hash[new_key], value].flatten
+              result = hash
+            else
+              result = hash.merge new_key => value
+            end
+            result
+          end
+          if data.respond_to?(:empty_node?)
+            out.instance_eval{ @_empty_node = data.empty_node? }
+          end
+          return out
+        else
+          return data
+        end
+      end
+
+
       # Generic type mapping
       def map_response(response)
+
+        response = Crack::XML.parse(response).to_hash
+
+        envelope = response[response.keys.first] || {}
+        body_key = envelope.keys.find { |key| /.+:Body/ =~ key } rescue nil
+        response = body_key ? envelope[body_key] : {}
+        
+        response = symbolize(response)
+
         response_key = response.keys.first
         if response_key
           if response[response_key].has_key? :return
@@ -155,6 +202,8 @@ module IControl
 
 
       def pluralize(string)
+        string = string.to_s.gsub(/ss$/,"sse")
+        return string if string[-1..-1] == "s"
         return "#{string}s"
       end
 
@@ -175,7 +224,7 @@ module IControl
               block.call(soap) if block
               request = soap.to_xml
             end
-            return self.map_response(response.to_hash)
+            return self.map_response(response.to_xml)
           rescue Savon::HTTP::Error, Savon::SOAP::Fault => error
             IControl::Base::ExceptionFactory.raise_from_xml(error.http.body)
           end
@@ -186,6 +235,13 @@ module IControl
       
     end
 
+    def initialize(attributes)     
+      @attributes = {}
+      id = attributes.delete(self.class.id_name) if attributes && attributes[self.class.id_name]
+      @attributes[:id] ||= id       
+      super(attributes)
+    end
+
     def default_body
       { self.class.id_name.to_s  =>  @attributes[:id] }
     end

data/lib/icontrol/base/attributable.rb

@@ -7,38 +7,17 @@ module IControl
       def self.included(klass)
         klass.class_eval do
           include InstanceMethods
-          class << self;
-            attr_accessor :id_name
-            def set_id_name(name)
-              @id_name = name
-            end
-          end
         end
       end
 
       module InstanceMethods # :nodoc:
-        
-        def id
-          @attributes[:id]
-        end
 
         def type
           return @attributes[:type] || super
         end
 
         def initialize(attributes)
-          id = attributes.delete(self.class.id_name) if attributes && attributes[self.class.id_name]
           @attributes = attributes || {}
-          @attributes[:id] ||= id       
-          
-          # Now we define an alias for the id_name
-          id_name = self.class.id_name
-
-          (class << self; self; end).instance_eval do        
-            define_method(id_name) do 
-              @attributes[:id]
-            end
-          end if id_name
         end
 
         def method_missing(method_name,*args,&block)

data/lib/icontrol/base/mappings.rb

@@ -17,6 +17,7 @@ module IControl # :nodoc:
         return String if type == "y:string"
         return LongSequence if type == "y:longSequence"
         return StringSequence if type == "y:stringSequence"
+        return BooleanSequence if type == "y:booleanSequence"
 
         splitted = type.split(":")
         temp_name = [splitted.shift,*splitted.shift.split(".")]

data/lib/icontrol/base/sequence.rb

@@ -6,6 +6,7 @@ class BasicSequence
     end
     def from_soap(xml)
       object = [*xml[:item]].map { |i| i.send(@conversion_method) }
+      return nil if object.empty?
       return object.length == 1 ? object.first : object
     end
   end
@@ -31,6 +32,14 @@ class LongSequence < BasicSequence
   set_conversion_method :to_i
 end
 
+class BooleanSequence
+  def self.from_soap(xml)
+    object = [*xml[:item]].map { |i| i == "true" }
+    return object.length == 1 ? object.first : object
+  end
+end
+
+
 # @private DoubleSequence
 class DoubleSequence < BasicSequence
   set_conversion_method :to_f

data/lib/icontrol/base/struct.rb

@@ -30,7 +30,11 @@ module IControl # :nodoc:
               if v == Numeric
                 aux[k] = xml[k].to_i
               else
-                aux[k] = xml[k]
+                if xml[k].empty_node?
+                  aux[k] = nil
+                else
+                  aux[k] = xml[k]
+                end
               end
             end
           end if xml

data/lib/icontrol/base/xml.rb

@@ -0,0 +1,231 @@
+require 'rexml/parsers/streamparser'
+require 'rexml/parsers/baseparser'
+require 'rexml/light/node'
+require 'rexml/text'
+require 'date'
+require 'time'
+require 'yaml'
+require 'bigdecimal'
+
+# This is a slighly modified version of the XMLUtilityNode from
+# http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
+# It's mainly just adding vowels, as I ht cd wth n vwls :)
+# This represents the hard part of the work, all I did was change the
+# underlying parser.
+class REXMLUtilityNode #:nodoc:
+  attr_accessor :name, :attributes, :children, :type, :empty_node
+
+  def self.typecasts
+    @@typecasts
+  end
+
+  def self.typecasts=(obj)
+    @@typecasts = obj
+  end
+
+  def self.available_typecasts
+    @@available_typecasts
+  end
+
+  def self.available_typecasts=(obj)
+    @@available_typecasts = obj
+  end
+
+  self.typecasts = {}
+  self.typecasts["integer"]       = lambda{|v| v.nil? ? nil : v.to_i}
+  self.typecasts["boolean"]       = lambda{|v| v.nil? ? nil : (v.strip != "false")}
+  self.typecasts["datetime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
+  self.typecasts["date"]          = lambda{|v| v.nil? ? nil : Date.parse(v)}
+  self.typecasts["dateTime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
+  self.typecasts["decimal"]       = lambda{|v| v.nil? ? nil : BigDecimal(v.to_s)}
+  self.typecasts["double"]        = lambda{|v| v.nil? ? nil : v.to_f}
+  self.typecasts["float"]         = lambda{|v| v.nil? ? nil : v.to_f}
+  self.typecasts["symbol"]        = lambda{|v| v.nil? ? nil : v.to_sym}
+  self.typecasts["string"]        = lambda{|v| v.to_s}
+  self.typecasts["yaml"]          = lambda{|v| v.nil? ? nil : YAML.load(v)}
+  self.typecasts["base64Binary"]  = lambda{|v| v.unpack('m').first }
+
+  self.available_typecasts = self.typecasts.keys
+
+  def initialize(name, normalized_attributes = {})
+    
+    # unnormalize attribute values
+    attributes = Hash[* normalized_attributes.map { |key, value|
+      [ key, unnormalize_xml_entities(value) ]
+    }.flatten]
+    
+    @name         = name.tr("-", "_")
+    # leave the type alone if we don't know what it is
+    @type         = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
+
+    @nil_element  = attributes.delete("nil") == "true"
+    @attributes   = undasherize_keys(attributes)
+    @children     = []
+    @text         = false
+    @empty_node   = false
+  end
+
+  def add_node(node)
+    @text = true if node.is_a? String
+    @children << node
+  end
+
+  def emptyze!(obj,value)
+    # Monkeypatch to allow empty_node? in the hash values
+    obj.class.instance_eval do 
+      define_method(:empty_node?) { @_empty_node }
+    end
+    obj.instance_eval { @_empty_node = value }
+  end
+
+  def to_hash
+    if @type == "file"
+      f = StringIO.new((@children.first || '').unpack('m').first)
+      class << f
+        attr_accessor :original_filename, :content_type
+      end
+      f.original_filename = attributes['name'] || 'untitled'
+      f.content_type = attributes['content_type'] || 'application/octet-stream'
+      return {name => f}
+    end
+
+    if @text
+      t = typecast_value( unnormalize_xml_entities( inner_html ) )
+      t.class.send(:attr_accessor, :attributes)
+      t.attributes = attributes
+      emptyze!(t,false)
+      return { name => t }
+    else
+      #change repeating groups into an array
+      groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }
+
+      out = nil
+      if @type == "array"
+        out = []
+        groups.each do |k, v|
+          if v.size == 1
+            out << v.first.to_hash.entries.first.last
+          else
+            out << v.map{|e| e.to_hash[k]}
+          end
+        end
+        out = out.flatten
+
+      else # If Hash
+        out = {}
+        groups.each do |k,v|
+          if v.size == 1
+            out.merge!(v.first)
+          else
+            out.merge!( k => v.map{|e| e.to_hash[k]})
+          end
+        end
+        out.merge! attributes unless attributes.empty?
+        out = out.empty? ? nil : out
+      end
+
+      if @type && out.nil?
+        out = typecast_value(out) 
+      end
+      emptyze!(out,@empty_node)
+
+      { name => out }
+    end
+  end
+
+  # Typecasts a value based upon its type. For instance, if
+  # +node+ has #type == "integer",
+  # {{[node.typecast_value("12") #=> 12]}}
+  #
+  # @param value<String> The value that is being typecast.
+  #
+  # @details [:type options]
+  #   "integer"::
+  #     converts +value+ to an integer with #to_i
+  #   "boolean"::
+  #     checks whether +value+, after removing spaces, is the literal
+  #     "true"
+  #   "datetime"::
+  #     Parses +value+ using Time.parse, and returns a UTC Time
+  #   "date"::
+  #     Parses +value+ using Date.parse
+  #
+  # @return <Integer, TrueClass, FalseClass, Time, Date, Object>
+  #   The result of typecasting +value+.
+  #
+  # @note
+  #   If +self+ does not have a "type" key, or if it's not one of the
+  #   options specified above, the raw +value+ will be returned.
+  def typecast_value(value)
+    return value unless @type
+    proc = self.class.typecasts[@type]
+    proc.nil? ? value : proc.call(value)
+  end
+
+  # Take keys of the form foo-bar and convert them to foo_bar
+  def undasherize_keys(params)
+    params.keys.each do |key, value|
+      params[key.tr("-", "_")] = params.delete(key)
+    end
+    params
+  end
+
+  # Get the inner_html of the REXML node.
+  def inner_html
+    @children.join
+  end
+
+  # Converts the node into a readable HTML node.
+  #
+  # @return <String> The HTML node in text form.
+  def to_html
+    attributes.merge!(:type => @type ) if @type
+    "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>"
+  end
+
+  # @alias #to_html #to_s
+  def to_s
+    to_html
+  end
+  
+  private
+
+  def unnormalize_xml_entities value
+    REXML::Text.unnormalize(value)
+  end
+end
+
+module Crack
+  class XML
+    def self.parse(xml)
+      stack = []
+      parser = REXML::Parsers::BaseParser.new(xml)
+      inner_elements = [0]
+
+      while true
+        event = parser.pull
+        case event[0]
+        when :end_document
+          break
+        when :end_doctype, :start_doctype
+          # do nothing
+        when :start_element
+          stack.push REXMLUtilityNode.new(event[1], event[2])
+          inner_elements[-1] += 1
+          inner_elements << 0
+        when :end_element
+          if stack.size > 1
+            temp = stack.pop
+            temp.empty_node = true if inner_elements.pop == 0
+            stack.last.add_node(temp)
+          else
+            stack.last.empty_node = true if inner_elements.pop == 0
+          end
+        when :text, :cdata
+          stack.last.add_node(event[1]) unless event[1].strip.length == 0 || stack.empty?
+        end
+      end
+      stack.length > 0 ? stack.pop.to_hash : {}
+    end
+  end
+end