Added VLANFirewalls and some related models

Author: SLsthompson

examples/order_bare_metal_package.rb

@@ -129,11 +129,11 @@ def tl_dr_version
   # We have a configuration for the server, we also need a location for the new server.
   # The package can give us a list of locations. Let's print out that list
   puts "\nData Centers for '#{quad_intel_package.name}':"
-  quad_intel_package.datacenter_options.each { |location| puts "\t#{location}"}
+  quad_intel_package.datacenter_options.each { |datacenter| puts "\t#{datacenter.name}"}
 
   # With all the config options in place we can now construct the product order.
   server_order = SoftLayer::BareMetalServerOrder_Package.new(quad_intel_package, client)
-  server_order.datacenter = 'sng01'
+  server_order.datacenter = SoftLayer::Datacenter.datacenter_named 'sng01', client
   server_order.hostname = 'sample'
   server_order.domain = 'softlayerapi.org'
   server_order.configuration_options = config_options

lib/softlayer/APIParameterFilter.rb

@@ -173,7 +173,7 @@ def server_result_offset
   ##
   # A utility method that returns the object filter (if any) stored with this filter.
   def server_object_filter
-    self.parameters[:object_filter].to_h
+    self.parameters[:object_filter].to_h if self.parameters.has_key?(:object_filter)
   end
 
   ##

lib/softlayer/Client.rb

@@ -32,7 +32,7 @@ class Client
 
     # A string passsed as the value for the User-Agent header when requests are sent to SoftLayer API.
     attr_accessor :user_agent
-    
+
     # An integer value (in seconds). The number of seconds to wait for HTTP requests to the network API
     # until they timeout. This value can be nil in which case the timeout will be the default value for
     # the library handling network communication (often 30 seconds)
@@ -84,8 +84,10 @@ def initialize(options = {})
       # and the endpoint url
       @endpoint_url = settings[:endpoint_url] || API_PUBLIC_ENDPOINT
 
+      # set the user agent to the one provided, or set it to a default one
       @user_agent = settings[:user_agent] || "softlayer_api gem/#{SoftLayer::VERSION} (Ruby #{RUBY_PLATFORM}/#{RUBY_VERSION})"
-      
+
+      # and assign a time out if the settings offer one
       @network_timeout = settings[:timeout] if settings.has_key?(:timeout)
 
       raise "A SoftLayer Client requires a username" if !@username || @username.empty?

lib/softlayer/NetworkComponent.rb

@@ -0,0 +1,14 @@
+#--
+# Copyright (c) 2014 SoftLayer Technologies, Inc. All rights reserved.
+#
+# For licensing information see the LICENSE.md file in the project root.
+#++
+
+module SoftLayer
+	class NetworkComponent < SoftLayer::ModelBase
+    sl_attr :name
+    sl_attr :port
+    sl_attr :speed
+    sl_attr :maxSpeed
+  end
+end

lib/softlayer/ProductItemCategory.rb

@@ -10,9 +10,23 @@ module SoftLayer
   # the product order is the price_id, the rest of the information is provided
   # to make the object friendly to humans who may be searching for the
   # meaning of a given price_id.
-  class ProductConfigurationOption < Struct.new(:price_id, :description, :capacity, :units, :setupFee, :laborFee, :oneTimeFee, :recurringFee, :hourlyRecurringFee)
+  class ProductConfigurationOption < Struct.new(:price_id, :description, :capacity, :units, :setupFee, :laborFee,
+     :oneTimeFee, :recurringFee, :hourlyRecurringFee)
     # Is it evil, or just incongruous to give methods to a struct?
 
+    def initialize(package_item_data, price_item_data)
+      self.description = package_item_data['description']
+      self.capacity = package_item_data['capacity']
+      self.units = package_item_data['units']
+
+      self.price_id = price_item_data['id']
+      self.setupFee = price_item_data['setupFee'] ? price_item_data['setupFee'].to_f : 0.0
+      self.laborFee = price_item_data['laborFee'] ? price_item_data['laborFee'].to_f : 0.0
+      self.oneTimeFee = price_item_data['oneTimeFee'] ? price_item_data['oneTimeFee'].to_f : 0.0
+      self.recurringFee = price_item_data['recurringFee'] ? price_item_data['recurringFee'].to_f : 0.0
+      self.hourlyRecurringFee = price_item_data['hourlyRecurringFee'] ? price_item_data['hourlyRecurringFee'].to_f : 0.0
+    end
+    
     # returns true if the configurtion option has no fees associated with it.
     def free?
       self.setupFee == 0 && self.laborFee == 0 && self.oneTimeFee == 0 && self.recurringFee == 0 && self.hourlyRecurringFee == 0
@@ -63,17 +77,7 @@ class ProductItemCategory < ModelBase
         # web UI), but this code collapses the groups.
         self['groups'].collect do |group|
           group['prices'].sort{|lhs,rhs| lhs['sort'] <=> rhs['sort']}.collect do |price_item|
-            ProductConfigurationOption.new(
-              price_item['id'],
-              price_item['item']['description'],
-              price_item['item']['capacity'],
-              price_item['item']['units'],
-              price_item['setupFee'] ? price_item['setupFee'].to_f : 0.0,
-              price_item['laborFee'] ? price_item['laborFee'].to_f : 0.0,
-              price_item['oneTimeFee'] ? price_item['oneTimeFee'].to_f : 0.0,
-              price_item['recurringFee'] ? price_item['recurringFee'].to_f : 0.0,
-              price_item['hourlyRecurringFee'] ? price_item['hourlyRecurringFee'].to_f : 0.0
-              )
+            ProductConfigurationOption.new(price_item['item'], price_item)
           end
         end.flatten # flatten out the individual group arrays.
       end

lib/softlayer/ProductPackage.rb

@@ -80,32 +80,75 @@ class ProductPackage < ModelBase
         # Run though the categories and for each one that's in our config, create a SoftLayer::ProductItemCategory object.
         # Conveniently the +keys+ of the required_by_category_code gives us a list of the category codes in the configuration
         config_categories = required_by_category_code.keys
-        categories_data.collect do |category_data|
+
+        # collect all the categories into an array
+        @categories = categories_data.collect do |category_data|
           if config_categories.include? category_data['categoryCode']
             SoftLayer::ProductItemCategory.new(softlayer_client, category_data, required_by_category_code[category_data['categoryCode']])
           else
-            nil
+            SoftLayer::ProductItemCategory.new(softlayer_client, category_data, false)
           end
         end.compact
+
+        # The configuration consists of only those categories that are required.
+        @categories.select { |category| category.required? }
+      end # to_update
+    end # configuration
+
+    ##
+    # The full set of product categories contained in the package
+    #
+    sl_dynamic_attr :categories do |resource|
+      resource.should_update? do
+        @categories == nil
+      end
+
+      resource.to_update do
+        # This is a bit ugly, but what we do is ask for the configuration
+        # which updates all the categories for the package (and marks those
+        # that are required)
+        self.configuration
+
+        # return the value constructed by the configuraiton
+        @categories
       end
     end
 
     ##
     # Returns an array of the required categories in this package
     def required_categories
-      configuration.select { |category| category.required? }
+      configuration
     end
 
     ##
     # Returns the product category with the given category code (or nil if one cannot be found)
     def category(category_code)
-      configuration.find { |category| category.categoryCode == category_code }
+      categories.find { |category| category.categoryCode == category_code }
     end
 
+    ##
+    # Returns a list of the datacenters that this package is available in
     def datacenter_options
       available_locations.collect { |location_data| Datacenter::datacenter_named(location_data["location"]["name"], self.softlayer_client) }.compact
     end
 
+    ##
+    # Returns the package items with the given description
+    # Currently this is returning the low-level hash representation directly from the Network API
+    #
+    def items_with_description(expected_description)
+      filter = ObjectFilter.new { |filter| filter.accept("items.description").when_it is(expected_description) }
+      items_data = self.service.object_filter(filter).getItems()
+      
+      items_data.collect do |item_data|
+        first_price = item_data['prices'][0]
+        ProductConfigurationOption.new(item_data, first_price)
+      end
+    end
+
+    ##
+    # Returns the service for interacting with this package through the network API
+    #
     def service
       softlayer_client['Product_Package'].object_with_id(self.id)
     end
@@ -168,6 +211,13 @@ def self.bare_metal_server_packages(client = nil)
       packages_with_key_name('BARE_METAL_CPU', client)
     end
 
+    ##
+    # The "Additional Products" package is a grab-bag of products
+    # and services.  It has a "well known" id of 0
+    def self.additional_products_package(client = nil)
+      return package_with_id(0, client)
+    end
+
     protected
 
     def self.default_object_mask(root)

lib/softlayer/Server.rb

@@ -16,6 +16,7 @@ module SoftLayer
   # ancestry.  As a result there is no SoftLayer API analog
   # to this class.
   class Server  < SoftLayer::ModelBase
+    include ::SoftLayer::DynamicAttribute
 
     ##
     # :attr_reader:
@@ -52,6 +53,17 @@ class Server  < SoftLayer::ModelBase
     # Notes about these server (for use by the customer)
     sl_attr :notes
 
+    sl_dynamic_attr :primary_network_component do |primary_component|
+      primary_component.should_update? do
+        return @primary_network_component == nil
+      end
+
+      primary_component.to_update do
+        component_data = self.service.getPrimaryNetworkComponent();
+        SoftLayer::NetworkComponent.new(self.softlayer_client, component_data)
+      end
+    end
+
     ##
     # Construct a server from the given client using the network data found in +network_hash+
     #

lib/softlayer/Service.rb

@@ -20,6 +20,19 @@
 
 require 'xmlrpc/client'
 
+# utility routine for swapping constants without warnings.
+def with_warnings(flag)
+  old_verbose, $VERBOSE = $VERBOSE, flag
+  yield
+ensure
+  $VERBOSE = old_verbose
+end
+
+# enable parsing of "nil" values in structures returned from the API
+with_warnings(nil) {
+  XMLRPC::Config.const_set('ENABLE_NIL_PARSER', true)
+}
+
 # The XML-RPC spec calls for the "faultCode" in faults to be an integer
 # but the SoftLayer XML-RPC API can return strings as the "faultCode"
 #
@@ -39,16 +52,6 @@ def self.fault(hash)
   end
 end
 
-# The XMLRPC client uses a fixed user agent string, but we want to
-# supply our own, so we add a method to XMLRPC::Client that lets
-# us change it.
-class XMLRPC::Client
-  def self.set_user_agent(new_agent)
-    remove_const(:USER_AGENT) if const_defined?(:USER_AGENT)
-    const_set(:USER_AGENT, new_agent)
-  end
-end
-
 module SoftLayer
   # = SoftLayer API Service
   #
@@ -233,7 +236,7 @@ def call_softlayer_api_with_params(method_name, parameters, args)
       # The client knows about authentication, so ask him for the auth headers
       authentication_headers = self.client.authentication_headers
       additional_headers.merge!(authentication_headers)
-
+      
       if parameters && parameters.server_object_filter
         additional_headers.merge!("#{@service_name}ObjectFilter" => parameters.server_object_filter)
       end
@@ -315,10 +318,11 @@ def http
           end
 
           @xmlrpc_client.http.set_debug_output($stderr)
+          @xmlrpc_client.http.instance_variable_set(:@verify_mode, OpenSSL::SSL::VERIFY_NONE)
         end # $DEBUG
       end
 
       @xmlrpc_client
     end
-  end # Service class
+  end # Service class  
 end # module SoftLayer

lib/softlayer/VLANFirewall.rb

@@ -0,0 +1,75 @@
+#--
+# Copyright (c) 2014 SoftLayer Technologies, Inc. All rights reserved.
+#
+# For licensing information see the LICENSE.md file in the project root.
+#++
+
+module SoftLayer
+	class VLANFirewall < SoftLayer::ModelBase
+    sl_attr :VLAN_number, 'vlanNumber'
+
+    ##
+    # return the name of the router the firewall is attached to
+    def primaryRouter
+      return self['primaryRouter']['hostname']
+    end
+
+    ##
+    # The fully qualified domain name of the firewall
+    def fullyQualifiedDomainName
+      if self.has_sl_property?('networkVlanFirewall')
+        return self['networkVlanFirewall']['fullyQualifiedDomainName']
+      else
+        return @softlayer_hash
+      end
+    end
+
+    ##
+    # returns true if the firewall has the high availability flag set
+    #
+    def high_availability?
+      # note that highAvailabilityFirewallFlag is a boolean in the softlayer hash
+      return self.has_sl_property?('highAvailabilityFirewallFlag') && self['highAvailabilityFirewallFlag']
+    end
+
+    def rule_set
+      rule_set = nil
+
+      # Search down through the firewall's data to find the AccessControlList (ACL) for the
+      # "outside" interface which handles "in"-wardly directed traffic.  This is the list that
+      # has the rules we're interested in.
+      outside_interface_data = self["firewallInterfaces"].find { |firewall_interface_data| firewall_interface_data['name'] == 'outside' }
+      if outside_interface_data
+        incoming_ACL = outside_interface_data['firewallContextAccessControlLists'].find { |firewallACL_data| firewallACL_data['direction'] == 'in' }
+        
+        firewall_ACL = self.softlayer_client[:Network_Firewall_AccessControlList].object_with_id(incoming_ACL['id']).getObject
+        rule_set = VLANFirewallRuleset.new(self.softlayer_client, firewall_ACL)
+      end
+
+      return rule_set
+    end
+
+    ##
+    # collect a list of the firewalls on the account
+    #
+    def self.find_firewalls(client)
+      softlayer_client = client || Client.default_client
+      raise "#{__method__} requires a client but none was given and Client::default_client is not set" if !softlayer_client
+
+      vlan_firewall_filter = SoftLayer::ObjectFilter.new() { |filter|
+        filter.accept("networkVlans.networkVlanFirewall").when_it is_not_null
+      }
+
+      vlan_firewalls = client[:Account].object_mask(vlan_firewall_mask).object_filter(vlan_firewall_filter).getNetworkVlans
+      vlan_firewalls.collect { |firewall_data| SoftLayer::VLANFirewall.new(client, firewall_data)}
+    end
+
+    private
+
+    def self.vlan_firewall_mask
+      return "mask[primaryRouter,dedicatedFirewallFlag,highAvailabilityFirewallFlag,"+
+        "firewallInterfaces.firewallContextAccessControlLists," +
+        "networkVlanFirewall[id, datacenter, primaryIpAddress, firewallType, fullyQualifiedDomainName]]"
+    end
+  end # class Firewall
+end # module SoftLayer