softlayer_api 3.0.0 → 3.0.1

data/lib/softlayer/NetworkStorageAllowedHost.rb

@@ -0,0 +1,77 @@
+module SoftLayer
+  ##
+  # Each SoftLayer NetworkStorageAllowedHost instance provides information about
+  # a hosts allowed access to a storage product group.
+  #
+  # This class roughly corresponds to the entity SoftLayer_Network_Storage_Allowed_Host
+  # in the API.
+  #
+  class NetworkStorageAllowedHost < ModelBase
+    include ::SoftLayer::DynamicAttribute
+
+    ##
+    # :attr_reader:
+    # The name of allowed host, usually an IQN or other identifier
+    sl_attr :name
+
+    ##
+    # The NetworkStorageGroup instances assigned to this host
+    sl_dynamic_attr :assigned_groups do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @assigned_groups == nil
+      end
+
+      resource.to_update do
+        assigned_groups = self.service.object_mask(NetworkStorageGroup.default_object_mask).getAssignedGroups
+        assigned_groups.collect { |assigned_group| NetworkStorageGroup.new(softlayer_client, assigned_group) unless assigned_group.empty? }.compact
+      end
+    end
+
+    ##
+    # The NetworkStorage instances assigned to this host
+    sl_dynamic_attr :assigned_volumes do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @assigned_volumes == nil
+      end
+
+      resource.to_update do
+        assigned_volumes = self.service.object_mask(NetworkStorage.default_object_mask).getAssignedVolumes
+        assigned_volumes.collect { |assigned_volume| NetworkStorage.new(softlayer_client, assigned_volume) unless assigned_volume.empty? }.compact
+      end
+    end
+
+    ##
+    # The NetworkStorageCredential instance used to access NetworkStorage for this host
+    sl_dynamic_attr :credential do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @credential == nil
+      end
+
+      resource.to_update do
+        credential = self.service.object_mask(NetworkStorageCredential.default_object_mask).getCredential
+        NetworkStorageCredential.new(softlayer_client, credential) unless credential.empty?
+      end
+    end
+
+    ##
+    # Returns the service for interacting with this network storage through the network API
+    #
+    def service
+      softlayer_client[:Network_Storage_Allowed_Host].object_with_id(self.id)
+    end
+
+    protected
+
+    def self.default_object_mask
+      {
+        "mask(SoftLayer_Network_Storage_Allowed_Host)" => [
+                                                           'id',
+                                                           'name'
+                                                          ]
+      }.to_sl_object_mask
+    end
+  end
+end #SoftLayer

data/lib/softlayer/NetworkStorageCredential.rb

@@ -0,0 +1,204 @@
+#--
+# Copyright (c) 2014 SoftLayer Technologies, Inc. All rights reserved.
+#
+# For licensing information see the LICENSE.md file in the project root.
+#++
+
+module SoftLayer
+  ##
+  # Each SoftLayer NetworkStorageCredential instance provides information
+  # on a username/password credential combination used to access a specific
+  # Network Storage.
+  #
+  # This class roughly corresponds to the entity SoftLayer_Network_Storage_Credential
+  # in the API.
+  #
+  class NetworkStorageCredential < ModelBase
+    include ::SoftLayer::DynamicAttribute
+
+    ##
+    # :attr_reader:
+    # This is the data that the record was created in the table.
+    sl_attr :created,  'createDate'
+
+    ##
+    # :attr_reader:
+    # This is the date that the record was last updated in the table.
+    sl_attr :modified, 'modifyDate'
+
+    ##
+    # :attr_reader:
+    # This is the password associated with the volume.
+    sl_attr :password
+
+    ##
+    # :attr_reader:
+    # This is the username associated with the volume.
+    sl_attr :username
+ 
+    ##
+    # Returns a description of the Network Storage Credential type
+    #
+    def description
+      self['type']['description']
+    end
+
+    ##
+    # Returns the name of the Network Storage Credential type
+    #
+    def name
+      self['type']['name']
+    end
+
+    ##
+    # Retrieve a list of network storage credentials from all network storage devices.
+    #
+    # The options parameter should contain:
+    #
+    # <b>+:client+</b> - The client used to connect to the API
+    #
+    # If no client is given, then the routine will try to use Client.default_client
+    # If no client can be found the routine will raise an error.
+    #
+    # You may filter the list returned by adding options:
+    # * <b>+:datacenter+</b>                  (string) - Include network storage account passwords associated with servers matching this datacenter
+    # * <b>+:domain+</b>                      (string) - Include network storage account passwords associated with servers matching this domain
+    # * <b>+:hostname+</b>                    (string) - Include network storage account passwords associated with servers matching this hostname
+    # * <b>+:network_storage_server_type+</b> (string) - Include network storage account passwords associated with services of this server type
+    # * <b>+:network_storage_type+</b>        (string) - Include network storage account passwords from devices of this storage type
+    # * <b>+:service+</b>                     (string) - Include network storage account passwords from devices with this service fqdn
+    # * <b>+:tags+</b>                        (Array)  - Include network storage account passwords associated with servers matching these tags
+    # * <b>+:username+</b>                    (string) - Include network storage account passwords with this username only
+    #
+    def self.find_network_storage_credentials(options_hash = {})
+      softlayer_client = options_hash[:client] || Client.default_client
+      raise "#{__method__} requires a client but none was given and Client::default_client is not set" if !softlayer_client
+
+      if(options_hash.has_key? :network_storage_object_filter)
+        network_storage_object_filter = options_hash[:network_storage_object_filter]
+        raise "Expected an instance of SoftLayer::ObjectFilter" unless network_storage_object_filter.kind_of?(SoftLayer::ObjectFilter)
+      else
+        network_storage_object_filter = ObjectFilter.new()
+      end
+
+      if(options_hash.has_key? :network_storage_credential_object_filter)
+        network_storage_credential_object_filter = options_hash[:network_storage_credential_object_filter]
+        raise "Expected an instance of SoftLayer::ObjectFilter" unless network_storage_credential_object_filter.kind_of?(SoftLayer::ObjectFilter)
+      else
+        network_storage_credential_object_filter = ObjectFilter.new()
+      end
+
+      if options_hash.has_key?(:network_storage_server_type) && ! [ :hardware, :virtual_server ].include?(options_hash[:network_storage_server_type])
+        raise "Expected one of :hardware or :virtual_server for :network_storage_server_type option in #{__method__}"
+      end
+
+      filter_label = {
+        :evault          => "evaultNetworkStorage",
+        :hardware        => "hardware",
+        :hub             => "hubNetworkStorage",
+        :iscsi           => "iscsiNetworkStorage",
+        :lockbox         => "lockboxNetworkStorage",
+        :nas             => "nasNetworkStorage",
+        :network_storage => "networkStorage",
+        :virtual_server  => "virtualGuest"
+      }
+
+      option_to_filter_path = {
+        :datacenter                 => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.datacenter.name' ].join                  },
+        :domain                     => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.domain' ].join                           },
+        :hostname                   => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.hostname' ].join                         },
+        :service                    => lambda { |storage_type|              return [ filter_label[storage_type],                                 '.serviceResource.backendIpAddress' ].join },
+        :tags                       => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.tagReferences.tag.name' ].join           },
+        :network_storage_credential => {
+          :username                 => "credentials.username"
+        }
+      }
+
+      if options_hash[:network_storage_type]
+        unless filter_label.select{|label,filter| filter.end_with?("Storage")}.keys.include?(options_hash[:network_storage_type])
+          raise "Expected :evault, :hub, :iscsi, :lockbox, :nas or :network_storage for option :network_storage_type in #{__method__}"
+        end
+      end
+
+      network_storage_type = options_hash[:network_storage_type] || :network_storage
+
+      if options_hash[:service]
+        network_storage_object_filter.modify do |filter|
+          filter.accept(option_to_filter_path[:service].call(network_storage_type)).when_it is(options_hash[:service])
+        end
+      end
+
+      if options_hash[:network_storage_server_type]
+        [ :datacenter, :domain, :hostname ].each do |option|
+          if options_hash[option]
+            network_storage_object_filter.modify do |filter|
+              filter.accept(option_to_filter_path[option].call(network_storage_type, options_hash[:network_storage_server_type])).when_it is(options_hash[option])
+            end
+          end
+        end
+
+        if options_hash[:tags]
+          network_storage_object_filter.set_criteria_for_key_path(option_to_filter_path[:tags].call(network_storage_type, options_hash[:network_storage_server_type]),
+                                                                  {
+                                                                    'operation' => 'in',
+                                                                    'options' => [{
+                                                                                    'name' => 'data',
+                                                                                    'value' => options_hash[:tags].collect{ |tag_value| tag_value.to_s }
+                                                                                  }]
+                                                                  })
+        end
+      end
+
+      option_to_filter_path[:network_storage_credential].each do |option, filter_path|
+        network_storage_credential_object_filter.modify { |filter| filter.accept(filter_path).when_it is(options_hash[option]) } if options_hash[option]
+      end
+
+      account_service = softlayer_client[:Account]
+      account_service = account_service.object_filter(network_storage_object_filter) unless network_storage_object_filter.empty?
+      account_service = account_service.object_mask("mask[id]")
+
+      case options_hash[:network_storage_type]
+      when :evault
+        network_storage_data = account_service.getEvaultNetworkStorage
+      when :hub
+        network_storage_data = account_service.getHubNetworkStorage
+      when :iscsi
+        network_storage_data = account_service.getIscsiNetworkStorage
+      when :lockbox
+        network_storage_data = account_service.getLockboxNetworkStorage
+      when :nas
+        network_storage_data = account_service.getNasNetworkStorage
+      when :network_storage, nil
+        network_storage_data = account_service.getNetworkStorage
+      end
+
+      network_storage_credentials = network_storage_data.collect do |network_storage|
+        network_storage_service = softlayer_client[:Network_Storage].object_with_id(network_storage['id'])
+        network_storage_service = network_storage_service.object_filter(network_storage_credential_object_filter) unless network_storage_credential_object_filter.empty?
+        network_storage_service = network_storage_service.object_mask(NetworkStorageCredential.default_object_mask)
+        network_storage_service = network_storage_service.object_mask(options_hash[:network_storage_credential_object_mask]) if options_hash[:network_storage_credential_object_mask]
+
+        network_storage_credentials_data = network_storage_service.getCredentials
+        network_storage_credentials_data.map { |credential| NetworkStorageCredential.new(softlayer_client, credential) unless credential.empty? }.compact
+      end
+
+      network_storage_credentials.flatten
+    end
+
+    protected
+
+    def self.default_object_mask
+      {
+        "mask(SoftLayer_Network_Storage_Credential)" => [
+                                                         'createDate',
+                                                         'id',
+                                                         'modifyDate',
+                                                         'password',
+                                                         'type.description',
+                                                         'type.name',
+                                                         'username'
+                                                        ]
+      }.to_sl_object_mask
+    end
+  end
+end #SoftLayer

data/lib/softlayer/NetworkStorageGroup.rb

@@ -0,0 +1,159 @@
+module SoftLayer
+  ##
+  # Each SoftLayer NetworkStorageGroup instance provides information about
+  # a storage product group and hosts allowed access.
+  #
+  # This class roughly corresponds to the entity SoftLayer_Network_Storage_Group
+  # in the API.
+  #
+  class NetworkStorageGroup < ModelBase
+    include ::SoftLayer::DynamicAttribute
+
+    ##
+    # :attr_reader:
+    # The friendly name of this group
+    sl_attr :alias
+
+    ##
+    # :attr_reader:
+    # The date this group was created.
+    sl_attr :created, 'createDate'
+
+    ##
+    # :attr_reader:
+    # The date this group was modified.
+    sl_attr :modified, 'modifyDate'
+
+    ##
+    # The SoftLayer_Account which owns this group.
+    sl_dynamic_attr :account do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @account == nil
+      end
+
+      resource.to_update do
+        account = self.service.getAccount
+        Account.new(softlayer_client, account) unless account.empty?
+      end
+    end
+
+    ##
+    # The allowed hosts list for this group.
+    sl_dynamic_attr :allowed_hosts do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @allowed_hosts == nil
+      end
+
+      resource.to_update do
+        allowed_hosts = self.service.object_mask(NetworkStorageAllowedHost.default_object_mask).getAllowedHosts
+        allowed_hosts.collect { |allowed_host| NetworkStorageAllowedHost.new(softlayer_client, allowed_host) unless allowed_host.empty? }.compact
+      end
+    end
+
+    ##
+    # The network storage volumes this group is attached to.
+    sl_dynamic_attr :attached_volumes do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @attached_volumes == nil
+      end
+
+      resource.to_update do
+        attached_volumes = self.service.object_mask(NetworkStorage.default_object_mask).getAttachedVolumes
+        attached_volumes.collect { |attached_volume| NetworkStorage.new(softlayer_client, attached_volume) unless attached_volume.empty? }.compact
+      end
+    end
+
+    ##
+    # The IP address for for SoftLayer_Network_Storage_Allowed_Host objects within this group.
+    sl_dynamic_attr :ip_address do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @ip_address == nil
+      end
+
+      resource.to_update do
+        network_connection_details = self.service.getNetworkConnectionDetails
+        network_connection_details["ipAddress"] unless network_connection_details.empty?
+      end
+    end
+
+    ##
+    # The description of theSoftLayer_Network_Storage_OS_Type Operating System designation that this group was created for.
+    sl_dynamic_attr :os_description do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @os_description == nil
+      end
+
+      resource.to_update do
+        os_type = self.service.getOsType
+        os_type["description"] unless os_type.empty?
+      end
+    end
+
+    ##
+    # The name of theSoftLayer_Network_Storage_OS_Type Operating System designation that this group was created for.
+    sl_dynamic_attr :os_name do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @os_name == nil
+      end
+
+      resource.to_update do
+        os_type = self.service.getOsType
+        os_type["name"] unless os_type.empty?
+      end
+    end
+
+    ##
+    # The network resource this group is created on.
+    sl_dynamic_attr :service_resource do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @service_resource == nil
+      end
+
+      resource.to_update do
+        service_resource = self.service.object_mask(NetworkService.default_object_mask).getServiceResource
+        NetworkService.new(softlayer_client, service_resource) unless service_resource.empty?
+      end
+    end
+
+    ##
+    # The name of the SoftLayer_Network_Storage_Group_Type which describes this group.
+    sl_dynamic_attr :type do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @type == nil
+      end
+
+      resource.to_update do
+        group_type = self.service.getGroupType
+        group_type["name"]
+      end
+    end
+
+    ##
+    # Returns the service for interacting with this network storage through the network API
+    #
+    def service
+      softlayer_client[:Network_Storage_Group].object_with_id(self.id)
+    end
+
+    protected
+
+    def self.default_object_mask
+      {
+        "mask(SoftLayer_Network_Storage_Group)" => [
+                                                    'alias',
+                                                    'createDate',
+                                                    'id',
+                                                    'modifyDate'
+                                                   ]
+      }.to_sl_object_mask
+    end
+  end
+end #SoftLayer

data/lib/softlayer/ProductItemCategory.rb

@@ -10,21 +10,26 @@ 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(:capacity, :capacityRestrictionMaximum, :capacityRestrictionMinimum,
+     :capacityRestrictionType, :description, :hourlyRecurringFee, :laborFee, :oneTimeFee, :price_id, :recurringFee,
+     :requiredCoreCount, :setupFee, :units)
     # Is it evil, or just incongruous to give methods to a struct?
 
     def initialize(package_item_data, price_item_data)
+      self.capacity    = package_item_data['capacity']
       self.description = package_item_data['description']
-      self.capacity = package_item_data['capacity']
-      self.units = package_item_data['units']
+      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
+      self.capacityRestrictionMaximum = price_item_data['capacityRestrictionMaximum'] ? price_item_data['capacityRestrictionMaximum'] : nil
+      self.capacityRestrictionMinimum = price_item_data['capacityRestrictionMinimum'] ? price_item_data['capacityRestrictionMinimum'] : nil
+      self.capacityRestrictionType    = price_item_data['capacityRestrictionType']    ? price_item_data['capacityRestrictionType']    : nil
+      self.hourlyRecurringFee         = price_item_data['hourlyRecurringFee']         ? price_item_data['hourlyRecurringFee'].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.price_id                   = price_item_data['id']
+      self.recurringFee               = price_item_data['recurringFee']               ? price_item_data['recurringFee'].to_f          : 0.0
+      self.requiredCoreCount          = price_item_data['requiredCoreCount']          ? price_item_data['requiredCoreCount']          : nil
+      self.setupFee                   = price_item_data['setupFee']                   ? price_item_data['setupFee'].to_f              : 0.0
     end
 
     # returns true if the configurtion option has no fees associated with it.
@@ -121,4 +126,4 @@ module SoftLayer
       return @is_required
     end
   end
-end
+end