softlayer_api 3.0.0 → 3.0.1

data/lib/softlayer/BareMetalServer.rb

@@ -50,10 +50,17 @@ module SoftLayer
         softlayer_client[:Ticket].createCancelServerTicket(self.id, cancel_reason, comment, true, 'HARDWARE')
       else
         # Note that reason and comment are ignored in this case, unfortunately
-        softlayer_client[:Billing_Item].object_with_id(self.billingItem['id'].to_i).cancelService()
+        softlayer_client[:Billing_Item].object_with_id(self.service.object_mask("mask[id]").getBillingItem['id'].to_i).cancelService()
       end
     end
 
+    ##
+    # Returns the username/password combinations for remote management accounts
+    #
+    def remote_management_accounts
+      self['remoteManagementAccounts']
+    end
+
     ##
     # Returns the typical Service used to work with this Server
     # For Bare Metal Servers that is +SoftLayer_Hardware+ though in some special cases
@@ -69,17 +76,18 @@ module SoftLayer
     def self.default_object_mask
       sub_mask = {
         "mask(SoftLayer_Hardware_Server)" => [
-          'bareMetalInstanceFlag',
-          'provisionDate',
-          'hardwareStatus',
-          'memoryCapacity',
-          'processorPhysicalCoreAmount',
-          'networkManagementIpAddress',
-          'networkComponents[id, status, speed, maxSpeed, name, ipmiMacAddress, ipmiIpAddress, macAddress, primaryIpAddress, port, primarySubnet]',
-          'activeTransaction[id, transactionStatus[friendlyName,name]]',
-          'hardwareChassis[id, name]'
-          ]
-        }
+                                              'activeTransaction[id, transactionStatus[friendlyName,name]]',
+                                              'bareMetalInstanceFlag',
+                                              'hardwareChassis[id, name]',
+                                              'hardwareStatus',
+                                              'memoryCapacity',
+                                              'networkComponents[id, maxSpeed, name, ipmiIpAddress, ipmiMacAddress, macAddress, port, primaryIpAddress, primarySubnet, speed, status]',
+                                              'networkManagementIpAddress',
+                                              'processorPhysicalCoreAmount',
+                                              'provisionDate',
+                                              'remoteManagementAccounts[password,username]'
+                                             ]
+      }
 
       super.merge(sub_mask)
     end
@@ -249,4 +257,4 @@ module SoftLayer
       bare_metal_data.collect { |server_data| BareMetalServer.new(softlayer_client, server_data) }
     end
   end #BareMetalServer
-end
+end

data/lib/softlayer/BareMetalServerOrder_Package.rb

@@ -56,14 +56,27 @@ module SoftLayer
     # The following properties are optional, but allow further fine tuning of
     # the server
 
+    # Boolean, If true, an hourly server will be ordered, otherwise a monthly server will be ordered
+    # Corresponds to +useHourlyPricing+ in the SoftLayer_Container_Product_Order_Hardware_Server container
+    # documentation
+    attr_accessor :hourly
+
+    # An instance of the SoftLayer::ImageTemplate class.  Represents the image template that should
+    # be installed on the server.
+    attr_accessor :image_template
+
+    # The URI of a script to execute on the server after it has been provisioned. This may be
+    # any object which accepts the to_s message. The resulting string will be passed to SoftLayer API.
+    attr_accessor :provision_script_URI
+
     # An array of the ids of SSH keys to install on the server upon provisioning
     # To obtain a list of existing SSH keys, call getSshKeys on the SoftLayer_Account service:
     #     client[:Account].getSshKeys()
     attr_accessor :ssh_key_ids
 
-    # The URI of a script to execute on the server after it has been provisioned. This may be
-    # any object which accepts the to_s message. The resulting string will be passed to SoftLayer API.
-    attr_accessor :provision_script_URI
+    # String, User metadata associated with the instance
+    # Corresponds to +userData+ in the +SoftLayer_Hardware_Server+ documentation
+    attr_accessor :user_metadata
 
     ##
     # You initialize a BareMetalServerOrder_Package by passing in the package that you
@@ -116,17 +129,21 @@ module SoftLayer
     # based on the configuration options given.
     def hardware_order
       product_order = {
-        'packageId' => @package.id,
-        'useHourlyPricing' => false,
-        'hardware' => [{
-          'hostname' => @hostname,
-          'domain' => @domain
-          }]
+        'packageId'        => @package.id,
+        'hardware'         => [{
+                                 'domain'   => @domain,
+                                 'hostname' => @hostname
+                               }],
+        'useHourlyPricing' => !!@hourly
       }
 
-      product_order['location'] = @datacenter.id if @datacenter
-      product_order['sshKeys'] = [{ 'sshKeyIds' => @ssh_key_ids }] if @ssh_key_ids
-      product_order['provisionScripts'] = [@provision_script_URI.to_s] if @provision_script_URI
+      #Note that the use of image_template and SoftLayer::ProductPackage os/guest_diskX configuration category
+      #item prices is mutually exclusive.
+      product_order['hardware'][0]['userData']       = @user_metadata                    if @user_metadata
+      product_order['imageTemplateGlobalIdentifier'] = @image_template.global_id         if @image_template
+      product_order['location']                      = @datacenter.id                    if @datacenter
+      product_order['provisionScripts']              = [@provision_script_URI.to_s]      if @provision_script_URI
+      product_order['sshKeys']                       = [{ 'sshKeyIds' => @ssh_key_ids }] if @ssh_key_ids
 
       product_order['prices'] = @configuration_options.collect do |key, value|
         if value.respond_to?(:price_id)
@@ -141,4 +158,4 @@ module SoftLayer
       product_order
     end
   end # BareMetalServerOrder_Package
-end # SoftLayer
+end # SoftLayer

data/lib/softlayer/Config.rb

@@ -95,7 +95,12 @@ module SoftLayer
 						result[:username] = softlayer_section['username'] if softlayer_section['username']
 						result[:endpoint_url] = softlayer_section['endpoint_url'] if softlayer_section['endpoint_url']
 						result[:api_key] = softlayer_section['api_key'] if softlayer_section['api_key']
-						result[:timeout] = softlayer_section['timeout'] if softlayer_section['timeout']
+
+            begin
+						  result[:timeout] = Integer(softlayer_section['timeout']) if softlayer_section['timeout']
+            rescue => integer_parse_exception
+              $stderr.puts "Expected the value of the timeout configuration property, '#{result[:timeout]}', to be parseable as an integer"
+            end
 					end
 				end
 			end

data/lib/softlayer/ImageTemplate.rb

@@ -289,8 +289,8 @@ module SoftLayer
       end
 
       option_to_filter_path = {
-        :name => "publicImages.name",
-        :global_id => "publicImages.globalIdentifier",
+        :name => "name",
+        :global_id => "globalIdentifier",
       }
 
       # For each of the options in the option_to_filter_path map, if the options hash includes
@@ -299,10 +299,10 @@ module SoftLayer
       option_to_filter_path.each do |option, filter_path|
         object_filter.modify { |filter| filter.accept(filter_path).when_it is(options_hash[option])} if options_hash[option]
       end
-
+      
       # Tags get a much more complex object filter operation so we handle them separately
       if options_hash.has_key?(:tags)
-        object_filter.set_criteria_for_key_path("publicImages.tagReferences.tag.name", {
+        object_filter.set_criteria_for_key_path("tagReferences.tag.name", {
           'operation' => 'in',
           'options' => [{
             'name' => 'data',
@@ -359,7 +359,12 @@ module SoftLayer
     end
 
     ##
-    # Retrieve the image template with the given global ID
+    # Retrieve the image template with the given global ID.  The routine searches the public image template list first
+    # and the private image template list if no public image with the given id is found.  If no template is found
+    # after searching both lists, then the function returns nil.
+    #
+    # Should either search return more than one result (meaning the system found more than one template with the same
+    # global_id), then the routine will throw an exception.
     #
     # The options parameter should contain:
     #
@@ -370,8 +375,13 @@ module SoftLayer
     #
     # The options may include the following keys
     # * <b>+:object_mask+</b> (string) - A object mask of properties, in addition to the default properties, that you wish to retrieve for the template
+    #
     def self.template_with_global_id(global_id, options_hash = {})
       templates = find_public_templates(options_hash.merge(:global_id => global_id))
+      if templates.empty? then
+        templates = find_private_templates(options_hash.merge(:global_id => global_id))
+      end
+      raise "ImageTemplate::template_with_global_id returned more than one template with the same global id.  This should not happen" if templates != nil && templates.count > 1
       templates.empty? ? nil : templates[0]
     end
 

data/lib/softlayer/NetworkMessageDelivery.rb

@@ -0,0 +1,130 @@
+#--
+# 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 NetworkMessageDelivery instance provides information about
+  # the username/password combination for a specific Network Message Delivery
+  # account.
+  #
+  # This class roughly corresponds to the entity SoftLayer_Network_Message_Delivery
+  # in the API.
+  #
+  class NetworkMessageDelivery < ModelBase
+    include ::SoftLayer::DynamicAttribute
+
+    ##
+    # :attr_reader:
+    # The date this username/password pair was created.
+    sl_attr :created,  'createDate'
+
+    ##
+    # :attr_reader:
+    # The date of the last modification to this username/password pair.
+    sl_attr :modified, 'modifyDate'
+
+    ##
+    # :attr_reader:
+    # The password part of the username/password pair.
+    sl_attr :password
+
+    ##
+    # :attr_reader:
+    # The username part of the username/password pair.
+    sl_attr :username
+
+    ##
+    # The message delivery type description of a network message delivery account.
+    sl_dynamic_attr :description do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @description == nil
+      end
+
+      resource.to_update do
+        type = self.service.getType
+        type['description']
+      end
+    end
+
+    ##
+    # The message delivery type name of a network message delivery account.
+    sl_dynamic_attr :name do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @name == nil
+      end
+
+      resource.to_update do
+        type = self.service.getType
+        type['name']
+      end
+    end
+
+    ##
+    # The vendor name for a network message delivery account.
+    sl_dynamic_attr :vendor do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @vendor == nil
+      end
+
+      resource.to_update do
+        vendor = self.service.getVendor
+        vendor['name']
+      end
+    end
+
+    ##
+    # Updates the password for the current account password.
+    #
+    def password=(password)
+      raise ArgumentError, "The new password cannot be nil"   unless password
+      raise ArgumentError, "The new password cannot be empty" if password.empty?
+
+      self.service.editObject({ "password" => password.to_s })
+      self.refresh_details()
+    end
+
+    ##
+    # Returns the service for interacting with the network message delivery instance
+    # through the network API
+    #
+    def service
+      softlayer_client[:Network_Message_Delivery].object_with_id(self.id)
+    end
+
+    ##
+    # Make an API request to SoftLayer and return the latest properties hash
+    # for this object.
+    #
+    def softlayer_properties(object_mask = nil)
+      my_service = self.service
+
+      if(object_mask)
+        my_service = my_service.object_mask(object_mask)
+      else
+        my_service = my_service.object_mask(self.class.default_object_mask)
+      end
+
+      my_service.getObject()
+    end
+
+    protected
+
+    def self.default_object_mask
+      {
+        "mask(SoftLayer_Network_Message_Delivery)" => [
+                                                       'createDate',
+                                                       'id',
+                                                       'modifyDate',
+                                                       'password',
+                                                       'username'
+                                                      ]
+      }.to_sl_object_mask
+    end
+  end
+end #SoftLayer

data/lib/softlayer/NetworkService.rb

@@ -0,0 +1,95 @@
+#--
+# 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 NetworkService instance provides connectivity
+  # information for a specific Network Service Resource.
+  #
+  # This class roughly corresponds to the entity SoftLayer_Network_Service_Resource
+  # in the API.
+  #
+  class NetworkService < ModelBase
+    include ::SoftLayer::DynamicAttribute
+
+    ##
+    # :attr_reader:
+    # The name associated with this resource
+    sl_attr :name
+
+    ##
+    # :attr_reader:
+    # The backend IP address for this resource
+    sl_attr :private_ip,   'backendIpAddress'
+
+    ##
+    # :attr_reader:
+    # The frontend IP address for this resource
+    sl_attr :public_ip,    'frontendIpAddress'
+
+    ##
+    # :attr_reader:
+    # The ssh username of for this resource
+    sl_attr :ssh_username, 'sshUsername'
+
+    ##
+    # Returns the datacenter that this network service resource is available in
+    sl_dynamic_attr :datacenter do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @datacenter == nil
+      end
+
+      resource.to_update do
+        Datacenter::datacenter_named(self['datacenter']['name'], self.softlayer_client)
+      end
+    end
+
+    ##
+    # Returns the api properties used to connect to the network service resource
+    #
+    def api
+      {
+          'host'     => self['apiHost'],
+          'password' => self['apiPassword'],
+          'path'     => self['apiPath'],
+          'port'     => self['apiPort'],
+          'protocol' => self['apiProtocol'],
+          'username' => self['apiUsername']
+      }
+    end
+
+    ##
+    # Returns the network service resource type name
+    #
+    def type
+      self['type']['type']
+    end
+
+    protected
+
+    def self.default_object_mask
+      {
+        "mask(SoftLayer_Network_Service_Resource)" => [
+                                                       'apiHost',
+                                                       'apiPassword',
+                                                       'apiPath',
+                                                       'apiPort',
+                                                       'apiProtocol',
+                                                       'apiUsername',
+                                                       'backendIpAddress',
+                                                       'datacenter',
+                                                       'frontendIpAddress',
+                                                       'id',
+                                                       'name',
+                                                       'networkDevice.id',
+                                                       'sshUsername',
+                                                       'type.type'
+                                                      ]
+      }.to_sl_object_mask
+    end
+  end
+end #SoftLayer

data/lib/softlayer/NetworkStorage.rb

@@ -0,0 +1,340 @@
+#--
+# 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 NetworkStorage instance provides information about
+  # a storage product and access credentials.
+  #
+  # This class roughly corresponds to the entity SoftLayer_Network_Storage
+  # in the API.
+  #
+  class NetworkStorage < ModelBase
+    include ::SoftLayer::DynamicAttribute
+
+    ##
+    # :attr_reader:
+    # A Storage account's capacity, measured in gigabytes.
+    sl_attr :capacity,   'capacityGb'
+
+    ##
+    # :attr_reader:
+    # The date a network storage volume was created.
+    sl_attr :created,    'createDate'
+
+    ##
+    # :attr_reader:
+    # Public notes related to a Storage volume.
+    sl_attr :notes
+
+    ##
+    # :attr_reader:
+    # The password used to access a non-EVault Storage volume.
+    # This password is used to register the EVault server agent with the
+    # vault backup system.
+    sl_attr :password
+
+    ##
+    # :attr_reader:
+    # A Storage account's type.
+    sl_attr :type,       'nasType'
+
+    ##
+    # :attr_reader:
+    # This flag indicates whether this storage type is upgradable or not.
+    sl_attr :upgradable, 'upgradableFlag'
+
+    ##
+    # :attr_reader:
+    # The username used to access a non-EVault Storage volume.
+    # This username is used to register the EVault server agent with the
+    # vault backup system.
+    sl_attr :username
+
+    ##
+    # Other usernames and passwords associated with a Storage volume.
+    sl_dynamic_attr :account_password do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @account_password == nil
+      end
+
+      resource.to_update do
+        account_password = self.service.object_mask(AccountPassword.default_object_mask).getAccountPassword
+        AccountPassword.new(softlayer_client, account_password) unless account_password.empty?
+      end
+    end
+
+    ##
+    # A Storage volume's access credentials.
+    sl_dynamic_attr :credentials do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @credentials == nil
+      end
+
+      resource.to_update do
+        self.service.object_mask(NetworkStorageCredential.default_object_mask).getCredentials.collect{|cred| NetworkStorageCredential.new(softlayer_client, cred) }
+      end
+    end
+
+    ##
+    # The network resource a Storage service is connected to.
+    sl_dynamic_attr :service_resource do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @service_resource == nil
+      end
+
+      resource.to_update do
+        NetworkService.new(softlayer_client, self.service.object_mask(NetworkService.default_object_mask).getServiceResource)
+      end
+    end
+
+    ##
+    # The account username and password for the EVault webCC interface.
+    sl_dynamic_attr :webcc_account do |resource|
+      resource.should_update? do
+        #only retrieved once per instance
+        @webcc_account == nil
+      end
+
+      resource.to_update do
+        webcc_account = self.service.object_mask(AccountPassword.default_object_mask).getWebccAccount
+        AccountPassword.new(softlayer_client, webcc_account) unless webcc_account.empty?
+      end
+    end
+
+    ##
+    # Add a username/password credential to the network storage instance
+    #
+    def add_credential(credential_type)
+      raise ArgumentError, "The new credential type cannot be nil"   unless credential_type
+      raise ArgumentError, "The new credential type cannot be empty" if credential_type.empty?
+
+      new_credential = self.service.object_mask(NetworkStorageCredential.default_object_mask).assignNewCredential(credential_type.to_s)
+      
+      @credentials = nil
+
+      NetworkStorageCredential.new(softlayer_client, new_credential) unless new_credential.empty?
+    end
+
+    ##
+    # Assign an existing network storage credential specified by the username to the network storage instance
+    #
+    def assign_credential(username)
+      raise ArgumentError, "The username cannot be nil"   unless username
+      raise ArgumentError, "The username cannot be empty" if username.empty?
+
+      self.service.assignCredential(username.to_s)
+      
+      @credentials = nil
+    end
+
+    ##
+    # Determines if one of the credentials pertains to the specified username.
+    #
+    def has_user_credential?(username)
+      self.credentials.map { |credential| credential.username }.include?(username)
+    end
+
+    ##
+    # Updates the notes for the network storage instance.
+    #
+    def notes=(notes)
+      self.service.editObject({ "notes" => notes.to_s })
+      self.refresh_details()
+    end
+
+    ##
+    # Updates the password for the network storage instance.
+    #
+    def password=(password)
+      raise ArgumentError, "The new password cannot be nil"   unless password
+      raise ArgumentError, "The new password cannot be empty" if password.empty?
+
+      self.service.editObject({ "password" => password.to_s })
+      self.refresh_details()
+    end
+
+    ##
+    # Remove an existing network storage credential specified by the username from the network storage instance
+    #
+    def remove_credential(username)
+      raise ArgumentError, "The username cannot be nil"   unless username
+      raise ArgumentError, "The username cannot be empty" if username.empty?
+
+      self.service.removeCredential(username.to_s)
+      
+      @credentials = nil
+    end
+
+    ##
+    # Retrieve a list of network storage services.
+    #
+    # 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 associated with servers matching this datacenter
+    # * <b>+:domain+</b>                      (string) - Include network storage associated with servers matching this domain
+    # * <b>+:hostname+</b>                    (string) - Include network storage associated with servers matching this hostname
+    # * <b>+:network_storage_server_type+</b> (string) - Include network storage associated with this server type
+    # * <b>+:network_storage_type+</b>        (string) - Include network storage from devices of this storage type
+    # * <b>+:service+</b>                     (string) - Include network storage from devices with this service fqdn
+    # * <b>+:tags+</b>                        (Array)  - Include network storage associated with servers matching these tags
+    #
+    def self.find_network_storage(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_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           },
+      }
+
+      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
+
+      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(NetworkStorage.default_object_mask)
+      account_service = account_service.object_mask(options_hash[:network_storage_object_mask]) if options_hash[:network_storage_object_mask]
+
+      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_data.collect { |network_storage| NetworkStorage.new(softlayer_client, network_storage) unless network_storage.empty? }.compact
+    end
+
+    ##
+    # Returns the service for interacting with this network storage through the network API
+    #
+    def service
+      softlayer_client[:Network_Storage].object_with_id(self.id)
+    end
+
+    ##
+    # Make an API request to SoftLayer and return the latest properties hash
+    # for this object.
+    #
+    def softlayer_properties(object_mask = nil)
+      my_service = self.service
+
+      if(object_mask)
+        my_service = my_service.object_mask(object_mask)
+      else
+        my_service = my_service.object_mask(self.class.default_object_mask)
+      end
+
+      my_service.getObject()
+    end
+
+    ##
+    # Updates the password for the network storage credential of the username specified.
+    #
+    def update_credential_password(username, password)
+      raise ArgumentError, "The new password cannot be nil"   unless password
+      raise ArgumentError, "The new username cannot be nil"   unless username
+      raise ArgumentError, "The new password cannot be empty" if password.empty?
+      raise ArgumentError, "The new username cannot be empty" if username.empty?
+
+      self.service.editCredential(username.to_s, password.to_s)
+
+      @credentials = nil
+    end
+
+    protected
+
+    def self.default_object_mask
+      {
+        "mask(SoftLayer_Network_Storage)" => [
+                                              'capacityGb',
+                                              'createDate',
+                                              'id',
+                                              'nasType',
+                                              'notes',
+                                              'password',
+                                              'upgradableFlag',
+                                              'username'
+                                             ]
+      }.to_sl_object_mask
+    end
+  end
+end #SoftLayer