softlayer_api 3.0.b1 → 3.0.b2

data/lib/softlayer/ModelBase.rb

@@ -47,7 +47,7 @@ module SoftLayer
     # a particular entity in the SoftLayer_Ticket service.  The particular
     # entity is identified by its id so the Ticket class would return
     #
-    #     softlayer_client["Ticket"].object_with_id
+    #     softlayer_client[:Ticket].object_with_id
     #
     # which is a service which would allow calls to the ticket service
     # through that particular object.

data/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

data/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,24 +77,14 @@ module SoftLayer
         # 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
     end
 
     def service
-      softlayer_client["SoftLayer_Product_Item_Category"].object_with_id(self.id)
+      softlayer_client[:SoftLayer_Product_Item_Category].object_with_id(self.id)
     end
 
     ##

data/lib/softlayer/ProductPackage.rb

@@ -65,7 +65,7 @@ module SoftLayer
         # filtering mechanism on the server side to give us a list of the categories, groups, and prices that are valid for the current
         # account at the current time. We construct the ProductItemCategory objects from the results we get back.
         #
-        configuration_data = softlayer_client['Product_Package'].object_with_id(self.id).object_mask("mask[isRequired,itemCategory.categoryCode]").getConfiguration()
+        configuration_data = softlayer_client[:Product_Package].object_with_id(self.id).object_mask("mask[isRequired,itemCategory.categoryCode]").getConfiguration()
 
         # We sort of invert the information and create a map from category codes to a boolean representing
         # whether or not they are required.
@@ -75,39 +75,82 @@ module SoftLayer
         end
 
         # This call to getCategories is the one that does lots of fancy back-end filtering for us
-        categories_data = softlayer_client['Product_Package'].object_with_id(self.id).getCategories()
+        categories_data = softlayer_client[:Product_Package].object_with_id(self.id).getCategories()
 
         # 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
+      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)
+      softlayer_client[:Product_Package].object_with_id(self.id)
     end
 
     ##
@@ -122,7 +165,7 @@ module SoftLayer
         filter.accept('type.keyName').when_it is(key_name)
       end
 
-      filtered_service = softlayer_client['Product_Package'].object_filter(filter).object_mask(self.default_object_mask('mask'))
+      filtered_service = softlayer_client[:Product_Package].object_filter(filter).object_mask(self.default_object_mask('mask'))
       packages_data = filtered_service.getAllObjects
       packages_data.collect { |package_data| ProductPackage.new(softlayer_client, package_data) }
     end
@@ -135,7 +178,7 @@ module SoftLayer
       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
 
-      package_data = softlayer_client['Product_Package'].object_with_id(package_id).object_mask(self.default_object_mask('mask')).getObject
+      package_data = softlayer_client[:Product_Package].object_with_id(package_id).object_mask(self.default_object_mask('mask')).getObject
       ProductPackage.new(softlayer_client, package_data)
     end
 
@@ -168,6 +211,13 @@ module SoftLayer
       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)

data/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 @@ module SoftLayer
     # 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+
     #
@@ -82,7 +94,7 @@ module SoftLayer
       when :power_cycle
         self.service.rebootHard
       else
-        raise RuntimeError, "Unrecognized reboot technique in SoftLayer::Server#reboot!}"
+        raise ArgumentError, "Unrecognized reboot technique in SoftLayer::Server#reboot!}"
       end
     end
 
@@ -105,7 +117,7 @@ module SoftLayer
     # Change the notes of the server
     # raises ArgumentError if you pass nil as the notes
     def notes=(new_notes)
-      raise ArgumentError.new("The new notes cannot be nil") unless new_notes
+      raise ArgumentError, "The new notes cannot be nil" unless new_notes
 
       edit_template = {
         "notes" => new_notes
@@ -119,7 +131,7 @@ module SoftLayer
     # Change the user metadata for the server.
     #
     def user_metadata=(new_metadata)
-      raise ArgumentError.new("Cannot set user metadata to nil") unless new_metadata
+      raise ArgumentError, "Cannot set user metadata to nil" unless new_metadata
       self.service.setUserMetadata([new_metadata])
       self.refresh_details()
     end
@@ -129,8 +141,8 @@ module SoftLayer
     # Raises an ArgumentError if the new hostname is nil or empty
     #
     def set_hostname!(new_hostname)
-      raise ArgumentError.new("The new hostname cannot be nil") unless new_hostname
-      raise ArgumentError.new("The new hostname cannot be empty") if new_hostname.empty?
+      raise ArgumentError, "The new hostname cannot be nil" unless new_hostname
+      raise ArgumentError, "The new hostname cannot be empty" if new_hostname.empty?
 
       edit_template = {
         "hostname" => new_hostname
@@ -147,8 +159,8 @@ module SoftLayer
     # no further validation is done on the domain name
     #
     def set_domain!(new_domain)
-      raise ArgumentError.new("The new hostname cannot be nil") unless new_domain
-      raise ArgumentError.new("The new hostname cannot be empty") if new_domain.empty?
+      raise ArgumentError, "The new hostname cannot be nil" unless new_domain
+      raise ArgumentError, "The new hostname cannot be empty" if new_domain.empty?
 
       edit_template = {
         "domain" => new_domain
@@ -158,6 +170,16 @@ module SoftLayer
       self.refresh_details()
     end
 
+    ##
+    # Returns the max port speed of the public network interfaces of the server taking into account
+    # bound interface pairs (redundant network cards).
+    def firewall_port_speed
+      network_components = self.service.object_mask("mask[id,maxSpeed]").getFrontendNetworkComponents()
+      max_speeds = network_components.collect { |component| component['maxSpeed'] }
+
+      max_speeds.empty? ? 0 : max_speeds.max
+    end
+
     ##
     # Change the current port speed of the server
     #
@@ -166,8 +188,7 @@ module SoftLayer
     # on the port.
     #
     # Set +public+ to +false+ in order to change the speed of the
-    # primary private network interface.
-    #
+    # private network interface.
     def change_port_speed(new_speed, public = true)
       if public
         self.service.setPublicNetworkInterfaceSpeed(new_speed)

data/lib/softlayer/ServerFirewall.rb

@@ -0,0 +1,263 @@
+#--
+# Copyright (c) 2014 SoftLayer Technologies, Inc. All rights reserved.
+#
+# For licensing information see the LICENSE.md file in the project root.
+#++
+
+module SoftLayer
+  ##
+  # The ServerFirewall class represents a firewall in the
+  # SoftLayer environment that exists in a 1 to 1 relationship
+  # with a particular server (either Bare Metal or Virtual).
+  #
+  # This is also called a "Shared Firewall" in some documentation.
+  #
+  # Instances of this class rougly correspond to instances of the
+  # SoftLayer_Network_Component_Firewall service entity.
+  #
+	class ServerFirewall < SoftLayer::ModelBase
+    include ::SoftLayer::DynamicAttribute
+
+    ##
+    # :attr_reader:
+    # The state of the firewall, includes whether or not the rules are
+    # editable and whether or not the firewall rules are applied or bypassed
+    # Can at least be 'allow_edit', 'bypass' or 'no_edit'.
+    # This list may not be exhaustive
+    sl_attr :status
+
+    ##
+    # :attr_reader:
+    # The firewall rules assigned to this firewall. These rules will
+    # be read from the network API every time you ask for the value
+    # of this property. To change the rules on the server use the
+    # asymmetric method change_rules!
+    sl_dynamic_attr :rules do |firewall_rules|
+      firewall_rules.should_update? do
+        # firewall rules update every time you ask for them.
+        return true
+      end
+
+      firewall_rules.to_update do
+        rules_data = self.service.object_mask(self.class.default_rules_mask).getRules()
+
+        # At the time of this writing, the object mask sent to getRules is not
+        # applied properly. This has been reported as a bug to the proper
+        # development team. In the mean time, this extra step does filtering
+        # that should have been done by the object mask.
+        rules_keys = self.class.default_rules_mask_keys
+        new_rules = rules_data.inject([]) do |new_rules, current_rule|
+          new_rule = current_rule.delete_if { |key, value| !(rules_keys.include? key) }
+          new_rules << new_rule
+        end
+
+        new_rules.sort { |lhs, rhs| lhs['orderValue'] <=> rhs['orderValue'] }
+      end
+    end
+
+    ##
+    # :attr_reader:
+    # The server that this firewall is attached to. The result may be
+    # either a bare metal or virtual server.
+    #
+    sl_dynamic_attr :protected_server do |protected_server|
+      protected_server.should_update? do
+        @protected_server == nil
+      end
+
+      protected_server.to_update do
+        if has_sl_property?('networkComponent')
+          @protected_server = SoftLayer::BareMetalServer.server_with_id(self['networkComponent']['downlinkComponent']['hardwareId'], :client => softlayer_client)
+        end
+
+        if has_sl_property?('guestNetworkComponent')
+          @protected_server = SoftLayer::VirtualServer.server_with_id(self['guestNetworkComponent']['guest']['id'], :client => softlayer_client)
+        end
+
+        @protected_server
+      end
+    end
+
+    ##
+    # Calls super to initialize the object then initializes some
+    # properties
+    def initialize(client, network_hash)
+      super(client, network_hash)
+      @protected_server = nil
+    end
+
+    ##
+    # Cancel the firewall
+    #
+    # This method cancels the firewall and releases its
+    # resources. The cancellation is processed immediately!
+    # Call this method with careful deliberation!
+    #
+    # Notes is a string that describes the reason for the
+    # cancellation. If empty or nil, a default string will
+    # be added
+    #
+    def cancel!(notes = nil)
+      user = self.softlayer_client[:Account].object_mask("mask[id,account]").getCurrentUser
+      notes = "Cancelled by a call to #{__method__} in the softlayer_api gem" if notes == nil || notes == ""
+
+      cancellation_request = {
+        'accountId' => user['account']['id'],
+        'userId'    => user['id'],
+        'items' => [ {
+          'billingItemId' => self['billingItem']['id'],
+          'immediateCancellationFlag' => true
+          } ],
+        'notes' => notes
+      }
+
+      self.softlayer_client[:Billing_Item_Cancellation_Request].createObject(cancellation_request)
+    end
+
+    ##
+    # Change the set of rules for the firewall.
+    # The rules_data parameter should be an array of hashes where
+    # each hash gives the conditions of the rule. The keys of the
+    # hashes should be entries from the array returned by
+    # SoftLayer::ServerFirewall.default_rules_mask_keys
+    #
+    # *NOTE!* When changing the rules on the firewall, you must
+    # pass in a complete set of rules each time. The rules you
+    # submit will replace the entire ruleset on the destination
+    # firewall.
+    #
+    # *NOTE!* The rules themselves have an "orderValue" property.
+    # It is this property, and *not* the order that the rules are
+    # found in the rules_data array, which will determine in which
+    # order the firewall applies it's rules to incomming traffic.
+    #
+    # *NOTE!* Changes to the rules are not applied immediately
+    # on the server side. Instead, they are enqueued by the
+    # firewall update service and updated periodically. A typical
+    # update will take about one minute to apply, but times may vary
+    # depending on the system load and other circumstances.
+    def change_rules!(rules_data)
+      change_object = {
+        "networkComponentFirewallId" => self.id,
+        "rules" => rules_data
+      }
+
+      self.softlayer_client[:Network_Firewall_Update_Request].createObject(change_object)
+    end
+
+    ##
+    # This method asks the firewall to ignore its rule set and pass all traffic
+    # through the firewall. Compare the behavior of this routine with
+    # change_routing_bypass!
+    #
+    # It is important to note that changing the bypass to :bypass_firewall_rules
+    # removes ALL the protection offered by the firewall. This routine should be
+    # used with careful deliberation.
+    #
+    # Note that this routine queues a rule change and rule changes may take
+    # time to process. The change will probably not take effect immediately.
+    #
+    # The two symbols accepted as arguments by this routine are:
+    # :apply_firewall_rules - The rules of the firewall are applied to traffic. This is the default operating mode of the firewall
+    # :bypass_firewall_rules - The rules of the firewall are ignored. In this configuration the firewall provides no protection.
+    #
+    def change_rules_bypass!(bypass_symbol)
+      change_object = {
+        "networkComponentFirewallId" => self.id,
+        "rules" => self.rules
+      }
+
+      case bypass_symbol
+      when :apply_firewall_rules
+        change_object['bypassFlag'] = false
+        self.softlayer_client[:Network_Firewall_Update_Request].createObject(change_object)
+      when :bypass_firewall_rules
+        change_object['bypassFlag'] = true
+        self.softlayer_client[:Network_Firewall_Update_Request].createObject(change_object)
+      else
+        raise ArgumentError, "An invalid parameter was sent to #{__method__}. It accepts :apply_firewall_rules and :bypass_firewall_rules"
+      end
+    end
+
+    ##
+    # Locate and return all the server firewalls in the environment.
+    #
+    # These are a bit tricky to track down. The strategy we take here is
+    # to look at the account and find all the VLANs that do NOT have their
+    # "dedicatedFirewallFlag" set.
+    #
+    # With the list of VLANs in hand we check each to see if it has an
+    # firewallNetworkComponents (corresponding to bare metal servers) or
+    # firewallGuestNetworkComponents (corresponding to virtual servers) that
+    # have a status of "allow_edit". Each such component is a firewall
+    # interface on the VLAN with rules that the customer can edit.
+    #
+    # The collection of all those VLANs becomes the set of firewalls
+    # for the account.
+    #
+    def self.find_firewalls(client = nil)
+      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
+
+      # Note that the dedicatedFirewallFlag is actually an integer and not a boolean
+      # so we compare it against 0
+      shared_vlans_filter = SoftLayer::ObjectFilter.new() { |filter|
+        filter.accept("networkVlans.dedicatedFirewallFlag").when_it is(0)
+      }
+
+      bare_metal_firewalls_data = []
+      virtual_firewalls_data = []
+
+      shared_vlans = softlayer_client[:Account].object_mask(network_vlan_mask).object_filter(shared_vlans_filter).getNetworkVlans
+      shared_vlans.each do |vlan_data|
+        bare_metal_firewalls_data.concat vlan_data['firewallNetworkComponents'].select { |network_component| network_component['status'] != 'no_edit'}
+        virtual_firewalls_data.concat vlan_data['firewallGuestNetworkComponents'].select { |network_component| network_component['status'] != 'no_edit'}
+      end
+
+      bare_metal_firewalls = bare_metal_firewalls_data.collect { |bare_metal_firewall_data|
+        self.new(softlayer_client, bare_metal_firewall_data)
+      }
+
+      virtual_server_firewalls = virtual_firewalls_data.collect { |virtual_firewall_data|
+        self.new(softlayer_client, virtual_firewall_data)
+      }
+
+      return bare_metal_firewalls + virtual_server_firewalls
+    end
+
+    #--
+    # Methods for the SoftLayer model
+    #++
+
+    def service
+      self.softlayer_client[:Network_Component_Firewall].object_with_id(self.id)
+    end
+
+    def softlayer_properties(object_mask = nil)
+      service = self.service
+      service = service.object_mask(object_mask) if object_mask
+
+      if self.has_sl_property?('networkComponent')
+        service.object_mask("mask[id,status,billingItem.id,networkComponent.downlinkComponent.hardwareId]").getObject
+      else
+        service.object_mask("mask[id,status,billingItem.id,guestNetworkComponent.guest.id]").getObject
+      end
+    end
+
+    #--
+    #++
+    private
+
+    def self.network_vlan_mask
+      "mask[firewallNetworkComponents[id,status,billingItem.id,networkComponent.downlinkComponent.hardwareId],firewallGuestNetworkComponents[id,status,billingItem.id,guestNetworkComponent.guest.id]]"
+    end
+
+    def self.default_rules_mask
+      return { "mask" => default_rules_mask_keys }.to_sl_object_mask
+    end
+
+    def self.default_rules_mask_keys
+      ['orderValue','action','destinationIpAddress','destinationIpSubnetMask',"protocol","destinationPortRangeStart","destinationPortRangeEnd",'sourceIpAddress',"sourceIpSubnetMask","version"]
+    end
+  end # ServerFirewall class
+end # SoftLayer module