softlayer_api 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9978e710e2d6a05a3880081e3cdee3f6bb2d3753
-  data.tar.gz: dd01519dab1d396a02f4f870385cd60c6b191c57
+  metadata.gz: 498eb5e1ea2559ee02a3d3f471515c5233c665ee
+  data.tar.gz: 9957ced500d1790af7e1dcc312b2deec1cad2390
 SHA512:
-  metadata.gz: 72845603df5f67b24caa19d5fe6fa41a576362f8eed388180b86695c1945941f335ac0837cf549715272340b2481d35d3d9eb93848a2e8c57ec10c72c0df1647
-  data.tar.gz: 9b03b78a3f56f54d558a495abc14240abd5ef3d1f3e424b432ef6aee8360106a21dcfa3c4a15f394ce26d03f459ac6351c5786fba6053e622e46eccc962046fc
+  metadata.gz: 160b9c1883f81422a9d94fbd4a413a89d5d2c8173683d739223897323e2d72f68becd9f1121e8f9f2ae2cfda9447f4b7d22d9c7750f81643b5ff79c831e69ad9
+  data.tar.gz: 5dc081303ba4b1e7abbf3177059b20547471bbf986a1afd1ebd2210fbf2f5b93b7dd78664c110c794060b1751b05b183e0827df6d7c4b832e83948c894df49ee

data/examples/order_virtual_server.rb

@@ -47,7 +47,7 @@ begin
 
   # The list will look something like ["ams01", "dal01", "dal05",...
   # Let's put our server in the 'dal05' (Dallas 5) datacenter
-  server_order.datacenter = 'dal05'
+  server_order.datacenter = SoftLayer::Datacenter.datacenter_named 'dal05', client
 
   # The order must know how many computing cores we want in our virtual
   # server.  Again we can ask the class for options.  The result will

data/lib/softlayer/Account.rb

@@ -80,23 +80,21 @@ module SoftLayer
     end
 
     ##
-    # The virtual servers (aka. CCIs or Virtual_Guests) associated with the
-    # account. Unless you force these to update, they will be refreshed every
-    # five minutes.
-    # :call-seq:
-    #   virtual_servers(force_update=false)
-    sl_dynamic_attr :virtual_servers do |virtual_servers|
-      virtual_servers.should_update? do
-        @last_virtual_server_update ||= Time.at(0)
-        (Time.now - @last_virtual_server_update) > 5 * 60  # update every 5 minutes
+    # Retrieve an account's master EVault user. This is only used when an account
+    # has an EVault service.
+    sl_dynamic_attr :evault_master_users do |evault_users|
+      evault_users.should_update? do
+        @evault_master_users == nil
       end
 
-      virtual_servers.to_update do
-        @last_virtual_server_update = Time.now
-        VirtualServer.find_servers(:client => self.softlayer_client)
+      evault_users.to_update do
+        evault_user_passwords = self.service.object_mask(AccountPassword.default_object_mask).getEvaultMasterUsers
+        evault_user_passwords.collect { |evault_user_password| AccountPassword.new(softlayer_client, evault_user_password) unless evault_user_password.empty? }.compact
       end
     end
 
+    ##
+    # Retrieve an account's image templates
     sl_dynamic_attr :image_templates do |image_templates|
       image_templates.should_update? do
         @last_image_template_update ||= Time.at(0)
@@ -109,6 +107,34 @@ module SoftLayer
       end
     end
 
+    ##
+    # Retrieve an account's network message delivery acounts.
+    sl_dynamic_attr :network_message_delivery_accounts do |net_msg_deliv_accts|
+      net_msg_deliv_accts.should_update? do
+        @network_message_delivery_accounts == nil
+      end
+
+      net_msg_deliv_accts.to_update do
+        network_message_delivery_accounts = self.service.object_mask(NetworkMessageDelivery.default_object_mask).getNetworkMessageDeliveryAccounts
+        network_message_delivery_accounts.collect { |net_msg_deliv_acct| NetworkMessageDelivery.new(softlayer_client, net_msg_deliv_acct) unless net_msg_deliv_acct.empty? }.compact
+      end
+    end
+
+    ##
+    # Retrieve an account's network storage groups.
+    sl_dynamic_attr :network_storage_groups do |net_stor_groups|
+      net_stor_groups.should_update? do
+        @network_storage_groups == nil
+      end
+
+      net_stor_groups.to_update do
+        network_storage_groups = self.service.object_mask(NetworkStorageGroup.default_object_mask).getNetworkStorageGroups
+        network_storage_groups.collect { |net_stor_group| NetworkStorageGroup.new(softlayer_client, net_stor_group) unless net_stor_group.empty? }.compact
+      end
+    end
+
+    ##
+    # Retrieve an account's open tickets
     sl_dynamic_attr :open_tickets do |open_tickets|
       open_tickets.should_update? do
         @last_open_tickets_update ||= Time.at(0)
@@ -122,6 +148,52 @@ module SoftLayer
       end
     end
 
+    ##
+    # Retrieve an account's portal users.
+    sl_dynamic_attr :users do |users|
+      users.should_update? do
+        @users == nil
+      end
+
+      users.to_update do
+        account_users = self.service.object_mask(UserCustomer.default_object_mask).getUsers
+        account_users.collect { |account_user| UserCustomer.new(softlayer_client, account_user) unless account_user.empty? }.compact
+      end
+    end
+
+    ##
+    # Retrieve an account's virtual disk images
+    sl_dynamic_attr :virtual_disk_images do |virtual_disk_images|
+      virtual_disk_images.should_update? do
+        @last_virtual_disk_images_update ||= Time.at(0)
+        (Time.now - @last_virtual_disk_images_update) > 5 * 60  # update every 5 minutes
+      end
+
+      virtual_disk_images.to_update do
+        @last_virtual_disk_images_update ||= Time.now
+        virtual_disk_images_data = self.service.object_mask(SoftLayer::VirtualDiskImage.default_object_mask).getVirtualDiskImages
+        virtual_disk_images_data.collect { |virtual_disk_image| SoftLayer::VirtualDiskImage.new(softlayer_client, virtual_disk_image) }
+      end
+    end
+
+    ##
+    # The virtual servers (aka. CCIs or Virtual_Guests) associated with the
+    # account. Unless you force these to update, they will be refreshed every
+    # five minutes.
+    # :call-seq:
+    #   virtual_servers(force_update=false)
+    sl_dynamic_attr :virtual_servers do |virtual_servers|
+      virtual_servers.should_update? do
+        @last_virtual_server_update ||= Time.at(0)
+        (Time.now - @last_virtual_server_update) > 5 * 60  # update every 5 minutes
+      end
+
+      virtual_servers.to_update do
+        @last_virtual_server_update = Time.now
+        VirtualServer.find_servers(:client => self.softlayer_client)
+      end
+    end
+
     def service
       softlayer_client[:Account].object_with_id(self.id)
     end
@@ -164,4 +236,4 @@ module SoftLayer
       return self.bare_metal_servers + self.virtual_servers
     end
   end
-end
+end

data/lib/softlayer/AccountPassword.rb

@@ -0,0 +1,356 @@
+#--
+# 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 AccountPassword instance provides information about
+  # a user's password associated with a SoftLayer Account instance.
+  #
+  # This class roughly corresponds to the entity SoftLayer_Account_Password
+  # in the API.
+  #
+  class AccountPassword < ModelBase
+    include ::SoftLayer::DynamicAttribute
+    
+    ##
+    # :attr_reader:
+    # A simple description of a username/password combination.
+    sl_attr :notes
+
+    ##
+    # :attr_reader:
+    # The password portion of a username/password combination.
+    sl_attr :password
+
+    ##
+    # :attr_reader:
+    # The username portion of a username/password combination.
+    sl_attr :username
+
+    ##
+    # A description of the use for the account username/password combination.
+    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
+
+    ##
+    # Updates the notes for the current account password.
+    #
+    def notes=(notes)
+      self.service.editObject({ "notes" => notes.to_s })
+      self.refresh_details()
+    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
+
+    ##
+    # Retrieve a list of network storage account passwords 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 from servers matching this datacenter
+    # * <b>+:domain+</b>                      (string) - Include network storage account passwords from servers matching this domain
+    # * <b>+:hostname+</b>                    (string) - Include network storage account passwords from servers matching this hostname
+    # * <b>+:network_storage_server_type+</b> (string) - Include network storage account passwords attached to this server type
+    # * <b>+:network_storage_type+</b>        (string) - Include network storage account passwords from devices of this storage type
+    # * <b>+:tags+</b>                        (Array)  - Include network storage account passwords from servers matching these tags
+    # * <b>+:username+</b>                    (string) - Include network storage account passwords with this username only
+    #
+    def self.find_network_storage_account_passwords(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? :account_password_object_filter)
+        account_password_object_filter = options_hash[:account_password_object_filter]
+        raise "Expected an instance of SoftLayer::ObjectFilter" unless account_password_object_filter.kind_of?(SoftLayer::ObjectFilter)
+      else
+        account_password_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 = {
+        :account_password => {
+          :username       => "accountPassword.username"
+        },
+        :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               },
+        :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
+
+      if options_hash[:network_storage_server_type]
+        network_storage_type = options_hash[:network_storage_type] || :network_storage
+
+        [ :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[:account_password].each do |option, filter_path|
+        account_password_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
+
+      account_passwords = 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(account_password_object_filter) unless account_password_object_filter.empty?
+        network_storage_service = network_storage_service.object_mask(AccountPassword.default_object_mask)
+        network_storage_service = network_storage_service.object_mask(options_hash[:account_password_object_mask]) if options_hash[:account_password_object_mask]
+
+        account_password_data = network_storage_service.getAccountPassword
+        AccountPassword.new(softlayer_client, account_password_data) unless account_password_data.empty?
+      end
+
+      account_passwords.compact
+    end
+
+    ##
+    # Retrieve a list of network storage webcc passwords 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 webcc passwords from servers matching this datacenter
+    # * <b>+:domain+</b>                      (string) - Include network storage webcc passwords from servers matching this domain
+    # * <b>+:hostname+</b>                    (string) - Include network storage webcc passwords from servers matching this hostname
+    # * <b>+:network_storage_server_type+</b> (string) - Include network storage webcc passwords attached to this server type
+    # * <b>+:network_storage_type+</b>        (string) - Include network storage webcc passwords from devices of this storage type
+    # * <b>+:tags+</b>                        (Array)  - Include network storage webcc passwords from servers matching these tags
+    # * <b>+:username+</b>                    (string) - Include network storage webcc passwords with this username only
+    #
+    def self.find_network_storage_webcc_passwords(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? :webcc_password_object_filter)
+        webcc_password_object_filter = options_hash[:webcc_password_object_filter]
+        raise "Expected an instance of SoftLayer::ObjectFilter" unless webcc_password_object_filter.kind_of?(SoftLayer::ObjectFilter)
+      else
+        webcc_password_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               },
+        :tags             => lambda { |storage_type, server_type| return [ filter_label[storage_type], '.', filter_label[server_type], '.tagReferences.tag.name' ].join },
+        :webcc_password => {
+          :username       => "webccAccount.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
+
+      if options_hash[:network_storage_server_type]
+        network_storage_type = options_hash[:network_storage_type] || :network_storage
+
+        [ :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[:webcc_password].each do |option, filter_path|
+        webcc_password_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
+
+      webcc_passwords = 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(webcc_password_object_filter) unless webcc_password_object_filter.empty?
+        network_storage_service = network_storage_service.object_mask(AccountPassword.default_object_mask)
+        network_storage_service = network_storage_service.object_mask(options_hash[:webcc_password_object_mask]) if options_hash[:webcc_password_object_mask]
+
+        webcc_password_data = network_storage_service.getWebccAccount
+        AccountPassword.new(softlayer_client, webcc_password_data) unless webcc_password_data.empty?
+      end
+
+      webcc_passwords.compact
+    end
+
+    ##
+    # Returns the service for interacting with this account password through the network API
+    #
+    def service
+      softlayer_client[:Account_Password].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_Account_Password)" => [
+                                               'id',
+                                               'notes',
+                                               'password',
+                                               'username'
+                                              ]
+      }.to_sl_object_mask
+    end
+  end
+end #SoftLayer