nifty-cloud-sdk 1.7

data/lib/NIFTY/Cloud/instances.rb

@@ -0,0 +1,372 @@
+module NIFTY
+  module Cloud
+    class Base < NIFTY::Base
+      INSTANCE_TYPE                 = ['mini', 'small', 'small2', 'small4', 'medium', 'medium4', 'medium8', 'large', 'large8', 'large16']
+      ACCOUNTING_TYPE               = ['1', '2']
+      BOOLEAN                       = ['true', 'false']
+      IP_TYPE                       = ['static', 'dynamic']
+      INSTANCES_DESCRIBE_ATTRIBUTE  = [
+        'instanceType', 'disableApiTermination', 'blockDeviceMapping', 'accountingType', 
+        'loadbalancing', 'copyInfo', 'autoscaling', 'ipType', 'groupId', 'description']
+      INSTANCES_MODIFY_ATTRIBUTE    = ['instanceType', 'disableApiTermination', 'instanceName', 'description', 'ipType', 'groupId']
+      INSTANCES_IGNORED_PARAMS      = Regexp.union(/MinCount/, 
+                                                   /MaxCount/, 
+                                                   /AddisionalInfo/, 
+                                                   /UserData/, 
+                                                   /AddressingType/, 
+                                                   /Placement.GroupName/, 
+                                                   /KernelId/, 
+                                                   /RamdiskId/,
+                                                   /BlockDeviceMapping.*/, 
+                                                   /Monitoring\.Enabled/, 
+                                                   /SubnetId/, 
+                                                   /InstanceInitiatedShutdownBehavior/)
+
+      # API「DescribeInstanceAttribute」を実行し、指定したサーバーの詳細情報を取得します。1回のリクエストで、指定したサーバーのどれか1つの詳細情報を取得できます。
+      # サーバーを指定するためには、サーバー名が必要です。削除済みのサーバーを指定した、管理外のサーバーを指定したなど、
+      # 無効なサーバーを指定した場合は、エラーが返されます。
+      #
+      #  @option options  [String] :instance_id  サーバー名(必須)
+      #  @option options  [String] :attribute    取得対象の項目名
+      #   許可値: instanceType | disableApiTermination | blockDeviceMapping | accountingType | loadbalancing | copyInfo | autoscaling | ipType | groupId | description
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example 
+      #   describe_instance_attribute(:instance_id => 'server01', :attribute => 'instanceType')
+      #
+      def describe_instance_attribute( options = {} )
+        raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])
+        raise ArgumentError, "Invalid :attribute provided." unless blank?(options[:attribute]) || INSTANCES_DESCRIBE_ATTRIBUTE.include?(options[:attribute].to_s)
+
+        params = {'Action' => 'DescribeInstanceAttribute'}
+        params.merge!(opts_to_prms(options, [:instance_id, :attribute]))
+
+        return response_generator(params)
+      end
+
+
+      # API「DescribeInstances」を実行し、指定したサーバーの情報を取得します。1 回のリクエストで、複数のサーバー情報を取得できます。
+      # サーバーを指定するためには、サーバー名が必要です。サーバーを指定しない場合は、取得可能なすべてのサーバー情報を取
+      # 得します。削除済みのサーバーを指定した、管理外のサーバーを指定したなど、無効なID を指定した場合は、エラーが返されます。
+      #
+      #  @option options [Array<String>] :instance_id サーバー名
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example 
+      #   describe_instances(:instance_id => 'server01')
+      #
+      def describe_instances( options = {} )
+        params = {'Action' => 'DescribeInstances'}
+        params.merge!(pathlist('InstanceId', options[:instance_id]))
+
+        return response_generator(params)
+      end
+
+
+      # API「ModifyInstanceAttribute」を実行し、指定したサーバーの詳細情報を更新します。1 回のリクエストで、1 つのサーバーの情報を更新できます。
+      # サーバーを指定するためには、サーバー名が必要です。削除済みのサーバーを指定した、管理外のサーバーを指定したなど、
+      # 無効なサーバーを指定した場合は、エラーが返されます。
+      # なお、起動済みのサーバーを指定した場合は、エラーが返されます。サーバーのステータスは、API「DescribeInstances」のレスポン
+      # ス値「instanceState」で確認できます。
+      #
+      #  @option options [String] :instance_id  サーバー名(必須)
+      #  @option options [String] :attribute    更新対象の項目名(必須)
+      #   許可値: instanceType(サーバータイプを更新) | disableApiTermination(API からのサーバー削除可否を更新) | instanceName(サーバー名を更新) | 
+      #           description(メモ情報を更新) | ipType(IP アドレスの固定化タイプを更新) | groupId(ファイアウォールグループを更新)
+      #   
+      #  @option options [String] :value        更新値(必須)
+      #   許可値: (:attribute= instanceType) mini | small | small2 | small4 | medium | medium4 | medium8 | large | large8 | large16
+      #           (:attribute= disableApiTermination) true | false 
+      #           (:attribute= ipType) static | dynamic
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   modify_instance_attribute(:instance_id => 'server01', :attribute => 'instanceType', :value => 'mini')
+      #
+      def modify_instance_attribute( options = {} )
+        raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])
+        raise ArgumentError, "No :attribute provided." if blank?(options[:attribute])
+        raise ArgumentError, "Invalid :attribute provided." unless INSTANCES_MODIFY_ATTRIBUTE.include?(options[:attribute].to_s)
+        raise ArgumentError, "No :value provided." if blank?(options[:value])
+        raise ArgumentError, "Invalid :value provided." if options[:attribute] == 'instanceType' && !INSTANCE_TYPE.include?(options[:value].to_s)
+        raise ArgumentError, "Invalid :value provided." if options[:attribute] == 'disableApiTermination' && !BOOLEAN.include?(options[:value].to_s)
+        raise ArgumentError, "Invalid :value provided." if options[:attribute] == 'ipType' && !IP_TYPE.include?(options[:value].to_s)
+
+        params = {'Action' => 'ModifyInstanceAttribute'}
+        params.merge!(opts_to_prms(options, [:instance_id, :attribute, :value]))
+
+        return response_generator(params)
+      end
+
+
+      # API「RebootInstances」を実行し、指定したサーバーを再起動します。
+      # サーバーを指定するためには、サーバー名が必要です。削除済みのサーバーを指定した、管理外のサーバーを指定したなど、
+      # 無効なサーバーを指定した場合は、エラーが返されます。
+      # サーバーの再起動には、時間がかかることがあります。サーバーのステータスは、API「DescribeInstances」のレスポンス値
+      # 「instanceState」で確認できます。
+      #
+      #  @option options [Array<String>] :instance_id  サーバー名(必須) 
+      #  @option options [Boolean] :force              強制オプション
+      #   許可値: true(強制実行) | false(強制実行しない)
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   reboot_instances(:instance_id => ['server01', 'server02'], :force => false)
+      #
+      def reboot_instances( options={} )
+        raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])
+        raise ArgumentError, "Invalid :force provided." unless blank?(options[:force]) || BOOLEAN.include?(options[:force].to_s)
+
+        params = {
+          'Action' => 'RebootInstances',
+          'Force' => options[:force].to_s
+        }
+        params.merge!(pathlist('InstanceId', options[:instance_id]))
+
+        return response_generator(params)
+      end
+
+
+      # API「RunInstances」を実行し、サーバーを新規作成します。1 回のリクエストで、1 つのサーバーを作成できます。
+      # サーバーの作成には、時間がかかることがあります。このAPI のレスポンス「instanceState」を確認し「pending」が返ってきた、
+      # タイムアウトした場合は、API「DescribeInstances」のレスポンス値「instanceState」でサーバーのステータスを確認できます。
+      # 処理が失敗した場合、サーバーは作成されず、エラーが返されます。
+      # またファイアウォール機能を提供していない環境でファイアウォールグループを指定して実行した場合は、エラーが返されます。
+      #
+      #  @option options [String] :image_id                   OSイメージID名(必須)
+      #  @option options [String] :key_name                   SSHキー名
+      #  @option options [Array<String>] :security_group      適用するファイアフォールグループ名
+      #  @option options [String] :instance_type              サーバータイプ
+      #   許可値: mini | small | small2 | small4 | medium | medium4 | medium8 | large | large8 | large16
+      #  @option options [Boolean] :disable_api_termination   APIからのサーバー削除の可否 
+      #   許可値: true(削除不可) | false(削除可)
+      #  @option options [String] :accounting_type            利用料金タイプ
+      #   許可値: 1(月額課金) | 2(従量課金)
+      #  @option options [String] :instance_id                サーバー名
+      #  @option options [String] :admin                      管理者アカウント
+      #  @option options [String] :password                   管理者アカウントパスワード
+      #   許可値: 半角英数字
+      #  @option options [String] :ip_type                    IPアドレスタイプ
+      #   許可値: static | dynamic
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   run_instances(:image_id => 1, :key_name => 'foo', :security_group => ['gr1', 'gr2'], :instance_type => 'mini',
+      #                 :instance_id => 'server01', :password => 'pass', :ip_type => 'static')
+      #
+      def run_instances( options={} )
+        options = {:base64_encoded => false}.merge(options)
+
+        raise ArgumentError, "No :image_id provided." if blank?(options[:image_id])
+        raise ArgumentError, "Invalid :image_id provided." unless options[:image_id].to_s.to_i > 0
+        raise ArgumentError, "Invalid :key_name provided." unless blank?(options[:key_name]) || ALPHANUMERIC =~ options[:key_name].to_s
+        #raise ArgumentError, "No :security_group provided." if blank?(options[:security_group])
+        raise ArgumentError, "Invalid :security_group provided." unless blank?(options[:security_group]) || GROUP_NAME =~ options[:security_group].to_s
+        raise ArgumentError, "No :password provided." if options[:image_id].to_s.to_i < 10000 && blank?(options[:password])
+        raise ArgumentError, "Invalid :password provided." unless blank?(options[:password]) || ALPHANUMERIC =~ options[:password].to_s
+        raise ArgumentError, "Invalid :instance_type provided." unless blank?(options[:instance_type]) || INSTANCE_TYPE.include?(options[:instance_type].to_s)
+        raise ArgumentError, "Invalid :disable_api_termination provided." unless blank?(options[:disable_api_termination]) || 
+          BOOLEAN.include?(options[:disable_api_termination].to_s)
+        raise ArgumentError, "Invalid :accounting_type provided." unless blank?(options[:accounting_type]) || ACCOUNTING_TYPE.include?(options[:accounting_type].to_s)
+        raise ArgumentError, "Invalid :ip_type provided." unless blank?(options[:ip_type]) || IP_TYPE.include?(options[:ip_type].to_s)
+        raise ArgumentError, ":base64_encoded must be 'true' or 'false'." unless [true, false].include?(options[:base64_encoded])
+
+        user_data = extract_user_data(options)
+        options[:user_data] = user_data
+
+        params = {
+          'Action' => 'RunInstances',
+          'Monitoring.Enabled' => options[:monitoring_enabled].to_s
+        }
+        params.merge!(pathlist('SecurityGroup', options[:security_group]))
+        params.merge!(pathhashlist('BlockDeviceMapping', options[:block_device_mapping], 
+                                   {:device_name => 'DeviceName', :virtual_name => 'VirtualName', :ebs_snapshot_id => 'Ebs.SnapshotId', 
+                                     :ebs_volume_size => 'Ebs.VolumeSize', :ebs_delete_on_termination => 'Ebs.DeleteOnTermination', 
+                                     :ebs_no_device => 'Ebs.NoDevice' })) unless blank?(options[:block_device_mapping])
+        params.merge!(opts_to_prms(options, [:image_id, :min_count, :max_count, :key_name, :additional_info, :user_data, :addressing_type,
+                                        :instance_type, :kernel_id, :ramdisk_id, :subnet_id, :disable_api_termination, :instance_initiated_shutdown_behavior,
+                                        :accounting_type, :instance_id, :admin, :password, :ip_type]))
+        params.merge!(opts_to_prms(options, [:availability_zone, :group_name], 'Placement'))
+
+        params.reject! {|k, v| INSTANCES_IGNORED_PARAMS =~ k } if @@ignore_amz_params
+
+        return response_generator(params)
+      end
+
+
+      # API「StartInstances」を実行し、指定したサーバーを起動します。
+      # サーバーを指定するためには、サーバー名が必要です。削除済みのサーバーを指定した、管理外のサーバーを指定したなど、
+      # 無効なサーバーを指定した場合は、エラーが返されます。
+      # サーバーの起動には、時間がかかることがあります。このAPI のレスポンス「currentState.name」を確認して「pending」が返ってきた場
+      # 合は、API「DescribeInstances」のレスポンス値「instanceState」でサーバーのステータスを確認できます。
+      #
+      #  @option options [Array<String>] :instance_id      サーバー名(必須)
+      #  @option options [Array<String>] :instance_type    サーバータイプ
+      #   許可値: mini | small | small2 | small4 | medium | medium4 | medium8 | large | large8 | large16
+      #  @option options [Array<String>] :accounting_type  利用料金タイプ
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   start_instances(:instance_id => ['server01', 'server02'], :instance_type => ['mini', 'small'], :accounting_type => 2)
+      #
+      def start_instances( options={} )
+        raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])
+        [options[:instance_type]].flatten.each do |p| 
+          raise ArgumentError, "Invalid :instance_type provided." unless INSTANCE_TYPE.include?(p.to_s)
+        end unless blank?(options[:instance_type])
+        [options[:accounting_type]].flatten.each do |p| 
+          raise ArgumentError, "Invalid :accounting_type provided." unless ACCOUNTING_TYPE.include?(p.to_s)
+        end unless blank?(options[:accounting_type])
+
+        params = {'Action' => 'StartInstances'}
+        params.merge!(pathlist('InstanceId', options[:instance_id]))
+        params.merge!(pathlist('InstanceType', options[:instance_type]))
+        params.merge!(pathlist('AccountingType', options[:accounting_type]))
+
+        return response_generator(params)
+      end
+
+
+      # API「StopInstances」を実行し、指定したサーバーを停止します。
+      # サーバーを指定するためには、サーバー名が必要です。削除済みのサーバーを指定した、管理外のサーバーを指定したなど、
+      # 無効なサーバーを指定した場合は、エラーが返されます。
+      # サーバーの停止には、時間がかかることがあります。このAPI のレスポンス「currentState.name」を確認して「pending」が返ってきた
+      # 場合は、API「DescribeInstances」のレスポンス値「instanceState」でサーバーのステータスを確認できます。
+      # なお、強制オプションに「true」を指定して実行した際に、サーバーが停止できない状態などのエラーが返されることがあります。
+      # 強制オプションに「true」を指定して実行した場合には、システムチェックや修復を行うことをおすすめします。
+      #
+      #  @option options [Array<String>] :instance_id  サーバー名(必須) 
+      #  @option options [Boolean] :force              強制オプション
+      #   許可値: true | false
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   stop_instances(:instance_id => ['server01', 'server02'], :force => false)
+      #
+      def stop_instances( options={} )
+        raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])
+        raise ArgumentError, "Invalid :force provided." unless blank?(options[:force]) || BOOLEAN.include?(options[:force].to_s)
+
+        params = {
+          'Action' => 'StopInstances',
+          'Force' => options[:force].to_s
+        }
+        params.merge!(pathlist('InstanceId', options[:instance_id]))
+
+        return response_generator(params)
+      end
+
+
+      # API「TerminateInstances」を実行し、指定したサーバーを削除します。
+      # サーバーを指定するためには、サーバー名が必要です。削除済みのサーバーを指定した、管理外のサーバーを指定したなど、
+      # 無効なサーバーを指定した場合は、エラーが返されます。
+      # サーバーの削除には、時間がかかることがあります。このAPI のレスポンス「currentState.name」を確認して「pending」が返ってきた
+      # 場合は、API「DescribeInstances」のレスポンス値「instanceState」でサーバーのステータスを確認できます。
+      # また、API「DescribeInstances」のレスポンスに該当情報がない場合は、削除処理は成功しています。
+      #
+      #  @option options [Array<String>] :instance_id サーバー名(必須) 
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example 
+      #   terminate_instances(:instance_id => ['server01', 'server02'])
+      #
+      def terminate_instances( options={} )
+        raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])
+        
+        params = {'Action' => 'TerminateInstances'}
+        params.merge!(pathlist('InstanceId', options[:instance_id]))
+
+        return response_generator(params)
+      end
+
+
+      # API「CopyInstances」を実行し、指定したサーバーのコピーを作成します。
+      # 停止中のサーバーのみ指定ができます。コピー後のサーバー名は、指定したコピー後のサーバー名の後ろに「-連番」が付加され
+      # た名称になります。
+      # サーバーを指定するためには、サーバー名が必要です。停止中以外のサーバーを指定した、管理外のサーバーを指定したなど、
+      # 無効なサーバーを指定した場合は、エラーが返されます。
+      # またファイアウォール機能を提供していない環境でファイアウォールグループを指定して実行した場合は、エラーが返されます。
+      #
+      #  @option options [String] :instance_id            コピー元のサーバー名(必須) 
+      #  @option options [String] :instance_name          コピー後のサーバー名(必須) 
+      #  @option options [String] :instance_type          サーバータイプ
+      #   許可値: mini | small | small2 | small4 | medium | medium4 | medium8 | large | large8 | large16
+      #  @option options [String] :accounting_type        利用料金タイプ
+      #   許可値: 1(月額課金) | 2(従量課金)
+      #  @option options [Array<Hash>] :load_balancers    ロードバランサー設定
+      #   <Hash> options  [String] :load_balancer_name     - ロードバランサー名
+      #                   [Integer] :load_balancer_port    - 待ち受けポート
+      #                   [Integer] :instance_port         - 宛先ポート
+      #  @option options [Array<String>] :security_group  ファイアウォールグループ名
+      #  @option options [Integer] :copy_count            コピー台数
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   copy_instances(:instance_id => 'server01', :instance_name => 'copyserver', :instance_type => 'mini', :accounting_type => 2,
+      #                   :load_balancers => [{:load_balancer_name => 'lb1'}, {:load_balancer_port => 80, :instance_port => 80}], 
+      #                   :security_group => ['gr1', 'gr2'], :copy_count => 1)
+      #
+      def copy_instances( options={} )
+        raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])
+        raise ArgumentError, "No :instance_name provided." if blank?(options[:instance_name])
+        raise ArgumentError, "Invalid :instance_type provided." unless blank?(options[:instance_type]) || INSTANCE_TYPE.include?(options[:instance_type].to_s)
+        raise ArgumentError, "Invalid :accounting_type provided." unless blank?(options[:accounting_type]) || ACCOUNTING_TYPE.include?(options[:accounting_type].to_s)
+        raise ArgumentError, "Invalid :ip_type provided." unless blank?(options[:ip_type]) || IP_TYPE.include?(options[:ip_type].to_s)
+        unless blank?(options[:load_balancers])
+          [options[:load_balancers]].flatten.each do |opt|
+            raise ArgumentError, "expected each element of arr_of_hashes to be a Hash" unless opt.is_a?(Hash)
+            unless blank?(opt[:load_balancer_name]) && blank?(opt[:load_balancer_port]) && blank?(opt[:instance_port])
+              raise ArgumentError, "No :load_balancer_name provided." if blank?(opt[:load_balancer_name])
+              raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ opt[:load_balancer_name].to_s
+              raise ArgumentError, "No :load_balancer_port provided." if blank?(opt[:load_balancer_port])
+              raise ArgumentError, "Invalid :load_balancer_port provided." unless valid_port?(opt[:load_balancer_port])
+              raise ArgumentError, "No :instance_port provided." if blank?(opt[:instance_port])
+              raise ArgumentError, "Invalid :instance_port provided." unless valid_port?(opt[:instance_port])
+            end
+          end
+        end
+        #raise ArgumentError, "No :security_group provided." if blank?(options[:security_group])
+        raise ArgumentError, "Invalid :security_group provided." unless blank?(options[:security_group]) || GROUP_NAME =~ options[:security_group].to_s
+        raise ArgumentError, "Invalid :copy_count provided." unless blank?(options[:copy_count]) || options[:copy_count].to_s.to_i >= 1
+        
+        params = {
+          'Action' => 'CopyInstances', 
+          'CopyInstance.ipType' => options[:ip_type].to_s
+        }
+        params.merge!(pathhashlist('CopyInstance.LoadBalancers', 
+                                   options[:load_balancers], 
+                                   {:load_balancer_name => 'LoadBalancerName', 
+                                     :load_balancer_port => 'LoadBalancerPort', 
+                                     :instance_port => 'InstancePort'})) unless blank?(options[:load_balancers])
+        params.merge!(pathlist('CopyInstance.SecurityGroup', options[:security_group]))
+        params.merge!(opts_to_prms(options, [:instance_id, :copy_count]))
+        params.merge!(opts_to_prms(options, [:instance_name, :instance_type, :accounting_type], 'CopyInstance'))
+
+        return response_generator(params)
+      end
+
+
+      # API「CancelCopyInstances」を実行し、指定したサーバーの作成（コピーによる作成）をキャンセルします。
+      # 作成待ちのサーバーのみ指定ができます。
+      # サーバーを指定するためには、サーバー名が必要です。作成待ち以外のサーバーを指定した、管理外のサーバーを指定したなど、
+      # 無効なサーバーを指定した場合は、エラーが返されます。
+      #
+      #  @option options [String] :instance_id キャンセル対象のサーバー名(必須) 
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   cancel_copy_instances(:instance_id => 'server01')
+      #
+      def cancel_copy_instances( options={} )
+        raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])
+
+        params = {
+          'Action' => 'CancelCopyInstances',
+          'InstanceId' => options[:instance_id].to_s
+        }
+
+        return response_generator(params)
+      end
+    end   # end of Base class
+  end     # end of Cloud module
+end       # end of NIFTY module

data/lib/NIFTY/Cloud/keypairs.rb

@@ -0,0 +1,76 @@
+module NIFTY
+  module Cloud
+    class Base < NIFTY::Base
+      ALPHANUMERIC = /^[a-zA-Z0-9]+$/
+
+      # API「CreateKeyPair」を実行し、SSH キーを新規作成します。
+      # SSHキーには、SSHキー名およびパスワードを設定します。SSHキー名には、同じユーザーが作るキーのうち、一意となる文字列を
+      # 指定します。設定したパスワードが使用可能文字ルールに適合しない場合は、エラーが返されます。
+      #
+      #  @option options [String] :key_name SSHキー名(必須)
+      #  @option options [String] :password パスワード(必須)
+      #   使用可能文字 : 半角英数字のみ
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   create_keypair(:key_name => 'key', :password => 'pass')
+      #
+      def create_key_pair( options = {} )
+        options = { :key_name => "" }.merge(options)
+        raise ArgumentError, "No :key_name provided." if blank?(options[:key_name])
+        raise ArgumentError, "Invalid :key_name provided." unless ALPHANUMERIC =~ options[:key_name].to_s
+        raise ArgumentError, "No :password provided." if blank?(options[:password])
+        raise ArgumentError, "Invalid :password provided." unless ALPHANUMERIC =~ options[:password].to_s
+
+        params = {'Action' => 'CreateKeyPair'}
+        params.merge!(opts_to_prms(options, [:key_name, :password]))
+
+        return response_generator(params)
+      end
+
+      # API「DeleteKeyPair」を実行し、SSH キーの情報を削除します。
+      # SSHキーを指定するためには、SSHキー名が必要です。削除済みのSSHキーを指定した、管理外のSSHキーを指定したなど、
+      # 無効なSSH キーを指定した場合は、エラーが返されます。
+      #
+      #  @option options [String] :key_name 削除対象のSSHキー名(必須)
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   delete_keypair(:key_name => 'key')
+      #
+      def delete_key_pair( options = {} )
+        options = { :key_name => "" }.merge(options)
+        raise ArgumentError, "No :key_name provided." if blank?(options[:key_name])
+        raise ArgumentError, "Invalid :key_name provided." unless ALPHANUMERIC =~ options[:key_name].to_s
+
+        params = {
+          'Action'  => 'DeleteKeyPair',
+          'KeyName' => options[:key_name].to_s
+        }
+
+        return response_generator(params)
+      end
+
+
+      # API「DescribeKeyPairs」を実行し、指定したSSH キーの情報を取得します。
+      # SSHキーを指定するためには、SSHキー名が必要です。SSHキーを指定しない場合は、取得できるすべてのSSHキー情報を取得します。
+      # 削除済みのSSH キーを指定した、管理外のSSH キーを指定したなど、無効なSSH キーを指定した場合は、エラーが返されます。
+      #
+      #  @option options [Array<String>] :key_name SSHキー名
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   describe_keypairs(:key_name => ['key1', 'key2'])
+      #
+      def describe_key_pairs( options = {} )
+        raise ArgumentError, "Invalid :key_name provided." unless blank?(options[:key_name]) || ALPHANUMERIC =~ options[:key_name].to_s
+
+        params = {'Action' => 'DescribeKeyPairs'}
+        params.merge!(pathlist('KeyName', options[:key_name]))
+
+        return response_generator(params)
+      end
+    end
+  end
+end
+

data/lib/NIFTY/Cloud/load_balancers.rb

@@ -0,0 +1,433 @@
+module NIFTY
+  module Cloud
+    class Base < NIFTY::Base
+      LOAD_BALANCER_PROTOCOL  = ['HTTP', 'HTTPS', 'FTP']
+      BALANCING_TYPE          = ['1', '2']
+      NETWORK_VOLUMES         = ['10', '20', '30', '40', '100', '200']
+      IP_VERSION              = ['v4', 'v6']
+      FILTER_TYPE             = ['1', '2']
+      LOAD_BALANCER_NAME      = /^[a-zA-Z0-9]{1,15}$/
+      LOAD_BALANCERS_IGNORED_PARAMS = Regexp.union(/AvailabilityZones .member.*/, 
+                                                   /HealthCheck .Timeout/)
+
+      # API「ConfigureHealthCheck」を実行し、指定したロードバランサーのヘルスチェックの設定を変更します。
+      # ロードバランサーを指定するためには、ロードバランサー名・ポート番号が必要です。削除済みのロードバランサーを指定した、
+      # 管理外のロードバランサーを指定したなど、無効なロードバランサーを指定した場合は、エラーが返されます。
+      # ヘルスチェックの実行結果は、API「DescribeInstanceHealth」で確認できます。
+      #
+      #  @option options [String] :load_balancer_name     対象のロードバランサー名(必須)
+      #  @option options [Integer] :load_balancer_port    対象の待ち受けポート(必須)
+      #  @option options [Integer] :load_balancer_port    対象の宛先ポート(必須)
+      #  @option options [String] :target                 PING プロトコル+":"+宛先ポート(必須)
+      #   許可値: TCP:宛先ポート | ICMP
+      #  @option options [Integer] :interval              ヘルスチェック間隔(必須)
+      #   許可値: 10 - 300
+      #  @option options [Integer] :unhealthy_threshold   ヘルスチェック回数の閾値(必須)
+      #   許可値: 1 - 10
+      #  @option options [Integer] :healthy_threshold     ヘルスチェックの復旧判断 
+      #   許可値: 1
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   configure_health_check(:load_balancer_name => 'bl1', :load_balancer_port => 80, :instance_port => 80, target => 'TCP:80', 
+      #                           :interval => 300, :unhealthy_threshold => 10, :healthy_threshold => 1)
+      #
+      def configure_health_check( options={} )
+        raise ArgumentError, "No :load_balancer_name provided." if blank?(options[:load_balancer_name])
+        raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ options[:load_balancer_name].to_s
+        raise ArgumentError, "No :load_balancer_port provided." if blank?(options[:load_balancer_port])
+        raise ArgumentError, "Invalid :load_balancer_port provided." unless valid_port?(options[:load_balancer_port])
+        raise ArgumentError, "No :instance_port provided." if blank?(options[:instance_port])
+        raise ArgumentError, "Invalid :instance_port provided." unless valid_port?(options[:instance_port])
+        raise ArgumentError, "No :target provided." if blank?(options[:target])
+        raise ArgumentError, "Invalid :target provided." unless /^(TCP:(\d{1,5})|ICMP)$/ =~ options[:target] 
+        raise ArgumentError, "Invalid :target provided." unless options[:target].to_s == 'ICMP' || valid_port?($2)
+        raise ArgumentError, "No :interval provided." if blank?(options[:interval])
+        raise ArgumentError, "Invalid :interval provided." unless ('10'..'300').to_a.include?(options[:interval].to_s)
+        raise ArgumentError, "No :unhealthy_threshold provided." if blank?(options[:unhealthy_threshold])
+        raise ArgumentError, "Invalid :unhealthy_threshold provided." unless ('1'..'10').to_a.include?(options[:unhealthy_threshold].to_s)
+        raise ArgumentError, "Invalid :healthy_threshold provided." unless blank?(options[:healthy_threshold]) || '1' == options[:healthy_threshold].to_s
+
+        params = {'Action' => 'ConfigureHealthCheck'}
+        params.merge!(opts_to_prms(options, [:load_balancer_name, :load_balancer_port, :instance_port]))
+        params.merge!(opts_to_prms(options, [:target, :interval, :timeout, :unhealthy_threshold, :healthy_threshold], 'HealthCheck'))
+
+        params.reject! {|k, v| LOAD_BALANCERS_IGNORED_PARAMS =~ k } if @@ignore_amz_params
+
+        return response_generator(params)
+      end
+
+
+      # API「CreateLoadBalancer」を実行し、ロードバランサーの定義を作成します。
+      # ロードバランサーの定義を作成します。1 回のリクエストで、1 つのポート定義を作成できます。
+      # すでに存在するロードバランサー名を指定した、存在するポート番号を指定した場合は、エラーが返されます。
+      # ロードバランサーの定義の作成に成功した場合は、以下のAPI を実行する必要があります。
+      #  ・ API「RegisterInstancesWithLoadBalancer」（サーバー設定）
+      #  ・ API「ConfigureHealthCheck」（ヘルスチェック設定）
+      # フィルターの設定は、「すべてのアクセスを許可する」になっています。変更を行う場合は以下のAPI を実行する必要があります。
+      #  ・ API「SetFilterForLoadBalancer」（フィルター設定）
+      #
+      #  @option options [String] :load_balancer_name     ロードバランサー名(必須)
+      #   使用可能文字: 半角英数字(15文字まで)
+      #  @option options [Array<Hash>] :listeners         ロードバランサー設定 
+      #   <Hash> options  [String] :protocol               - プロトコル(:load_balancer_portといずれか必須)
+      #                    許可値: HTTP | HTTPS | FTP
+      #                   [Integer] :load_balancer_port    - 待ち受けポート(:protocolといずれか必須)
+      #                   [Integer] :instance_port         - 宛先ポート
+      #                   [String] :balancing_type         - ロードバランス方式 
+      #                    許可値: 1(Round-Robin) | 2(Least-Connection) 
+      #  @option options [Integer] :network_volume        最大ネットワーク流量
+      #   許可値: 10 | 20 | 30 | 40 | 100 | 200　（単位： Mbps）
+      #  @option options [String] :ip_version             グローバルIP アドレスのバージョン 
+      #   許可値: v4
+      #  @return [Hash] レスポンスXML解析結果
+      #                   
+      #  @example
+      #   create_load_balancer(:load_balancer_name => 'lb1', :listeners => {:protocol => 'http'}, :network_volume => 10)
+      #
+      def create_load_balancer( options={} )
+        raise ArgumentError, "No :load_balancer_name provided." if blank?(options[:load_balancer_name])
+        raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ options[:load_balancer_name].to_s
+        raise ArgumentError, "No :listeners provided." if blank?(options[:listeners])
+        [options[:listeners]].flatten.each do |member|
+          raise ArgumentError, "expected each element of arr_of_hashes to be a Hash" unless member.is_a?(Hash)
+          raise ArgumentError, ":protocol or :load_balancer_port must be provided." if blank?(member[:protocol])&& blank?(member[:load_balancer_port])
+          raise ArgumentError, "Invalid :protocol provided." unless blank?(member[:protocol]) || LOAD_BALANCER_PROTOCOL.include?(member[:protocol].to_s.upcase)
+          raise ArgumentError, "Invalid :load_balancer_port provided." unless blank?(member[:load_balancer_port]) || valid_port?(member[:load_balancer_port])
+          raise ArgumentError, "Invalid :instance_port provided." unless blank?(member[:instance_port]) || valid_port?(member[:instance_port])
+          raise ArgumentError, "Invalid :balancing_type provided." unless blank?(member[:balancing_type]) || BALANCING_TYPE.include?(member[:balancing_type].to_s)
+        end
+        raise ArgumentError, "Invalid :network_volume provided." unless blank?(options[:network_volume]) || NETWORK_VOLUMES.include?(options[:network_volume].to_s)
+        raise ArgumentError, "Invalid :ip_version provided." unless blank?(options[:ip_version]) || IP_VERSION.include?(options[:ip_version].to_s)
+        params = {'Action' => 'CreateLoadBalancer'}
+        params.merge!(opts_to_prms(options, [:load_balancer_name, :network_volume, :ip_version]))
+        params.merge!(pathhashlist('Listeners.member', options[:listeners], 
+                                   {:protocol => 'Protocol', 
+                                     :load_balancer_port => 'LoadBalancerPort',
+                                     :instance_port => 'InstancePort', 
+                                     :balancing_type => 'BalancingType'}))
+        params.merge!(pathlist('AvailabilityZones.member', options[:availability_zones]))
+
+        params.reject! {|k, v| LOAD_BALANCERS_IGNORED_PARAMS =~ k } if @@ignore_amz_params
+
+        return response_generator(params)
+      end
+
+
+      # API「DeleteLoadBalancer」を実行し、指定したロードバランサーのポート定義を削除します。
+      # 関連するフィルター設定・サーバー設定・ヘルスチェック設定もあわせて削除します。
+      # ロードバランサーを指定するためには、ロードバランサー名が必要です。削除済みのロードバランサーを指定した、
+      # 管理外のロードバランサーを指定したなど、無効なロードバランサーを指定した場合は、エラーが返されます。
+      #
+      #  @option options [String] :load_balancer_name   削除対象のロードバランサー名(必須)
+      #  @option options [Integer] :load_balancer_port  削除対象の待ち受けポート(必須)
+      #  @option options [Integer] :instance_port       削除対象の宛先ポート(必須)
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   delete_load_balancer(:load_balancer_name => 'lb1', :load_balancer_port => 80, instance_port => 80)
+      #
+      def delete_load_balancer( options={} )
+        raise ArgumentError, "No :load_balancer_name provided." if blank?(options[:load_balancer_name])
+        raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ options[:load_balancer_name].to_s
+        raise ArgumentError, "No :load_balancer_port provided." if blank?(options[:load_balancer_port])
+        raise ArgumentError, "Invalid :load_balancer_port provided." unless valid_port?(options[:load_balancer_port])
+        raise ArgumentError, "No :instance_port provided." if blank?(options[:instance_port])
+        raise ArgumentError, "Invalid :instance_port provided." unless valid_port?(options[:instance_port])
+
+        params = {'Action' => 'DeleteLoadBalancer'}
+        params.merge!(opts_to_prms(options, [:load_balancer_name, :load_balancer_port, :instance_port]))
+
+        return response_generator(params)
+      end
+
+
+      # API「DeregisterInstancesFromLoadBalancer」を実行し、指定したロードバランサーから、指定したサーバーを解除します。
+      # ロードバランサーを指定するためには、ロードバランサー名・ポート番号が必要です。削除済みのロードバランサーを指定した、
+      # 管理外のロードバランサーを指定したなど、無効なロードバランサーを指定した場合は、エラーが返されます。
+      # またサーバーを指定するためには、サーバー名が必要です。該当するロードバランサーに設定されていないサーバーを指定した、
+      # 削除済みのサーバーを指定した、管理外のサーバーを指定したなど、無効なサーバーを指定した場合は、エラーが返されます。
+      #
+      #  @option options [String] :load_balancer_name   対象のロードバランサー名(必須)
+      #  @option options [Integer] :load_balancer_port  対象の待ち受けポート(必須)
+      #  @option options [Integer] :instance_port       対象の宛先ポート(必須)
+      #  @option options [Array<String>]  :instances    サーバー名(必須)
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   deregister_instances_from_load_balancer(:load_balancer_name => 'lb1', :load_balancer_port => 80, instance_port => 80, :instances => ['server01'])
+      #
+      def deregister_instances_from_load_balancer( options={} )
+        raise ArgumentError, "No :load_balancer_name provided" if blank?(options[:load_balancer_name])
+        raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ options[:load_balancer_name].to_s
+        raise ArgumentError, "No :load_balancer_port provided." if blank?(options[:load_balancer_port])
+        raise ArgumentError, "Invalid :load_balancer_port provided." unless valid_port?(options[:load_balancer_port])
+        raise ArgumentError, "No :instance_port provided." if blank?(options[:instance_port])
+        raise ArgumentError, "Invalid :instance_port provided." unless valid_port?(options[:instance_port])
+        raise ArgumentError, "No :instances provided." if blank?(options[:instances])
+
+        params = {'Action' => 'DeregisterInstancesFromLoadBalancer'}
+        params.merge!(opts_to_prms(options, [:load_balancer_name, :load_balancer_port, :instance_port]))
+        params.merge!(pathhashlist('Instances.member', [options[:instances]].flatten.collect{|e| {:instances => e}}, {:instances => 'InstanceId'}))
+
+        return response_generator(params)
+      end
+
+
+      # API「DescribeInstanceHealth」を実行し、指定したロードバランサーに設定されている、サーバーのヘルスチェック結果を取得します。ヘルスチェックは、API
+      # 「ConfigureHealthCheck」で設定します。
+      # ロードバランサーを指定するためには、ロードバランサー名が必要です。削除済みのロードバランサーを指定した、管理外のロードバランサーを指定したなど、
+      # 無効なロードバランサーを指定した場合は、エラーが返されます。
+      # またサーバーを指定するためには、サーバー名が必要です。サーバーを指定しない場合は、指定したロードバランサーに設定されているすべてのサーバーを対象として、
+      # ヘルスチェック結果を取得します。
+      # 削除済みのサーバーを指定した、管理外のサーバーを指定したなど、無効なサーバーを指定した場合は、エラーが返されます。
+      #
+      #  @option options [String] :load_balancer_name   対象のロードバランサー名(必須)
+      #  @option options [Integer] :load_balancer_port  対象の待ち受けポート(必須)
+      #  @option options [Integer] :instance_port       対象の宛先ポート(必須)
+      #  @option options [Array<String>]  :instances    サーバー名
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   describe_instance_health(:load_balancer_name => 'bl1', :load_balancer_port => 80, :instance_port => 80, :instances => ['server01'])
+      #
+      def describe_instance_health( options={} )
+        raise ArgumentError, "No :load_balancer_name provided" if blank?(options[:load_balancer_name])
+        raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ options[:load_balancer_name].to_s
+        raise ArgumentError, "No :load_balancer_port provided." if blank?(options[:load_balancer_port])
+        raise ArgumentError, "Invalid :load_balancer_port provided." unless valid_port?(options[:load_balancer_port])
+        raise ArgumentError, "No :instance_port provided." if blank?(options[:instance_port])
+        raise ArgumentError, "Invalid :instance_port provided." unless valid_port?(options[:instance_port])
+
+        params = {'Action' => 'DescribeInstanceHealth'}
+        params.merge!(opts_to_prms(options, [:load_balancer_name, :load_balancer_port, :instance_port]))
+          params.merge!(pathhashlist('Instances.member', [options[:instances]].flatten.collect{|e| {:instances => e}}, 
+                                     {:instances => 'InstanceId'})) if options.has_key?(:instances) 
+
+        return response_generator(params)
+      end
+     
+
+      # API「DescribeLoadBalancers」を実行し、指定したロードバランサーの情報を取得します。
+      # ロードバランサーを指定するためには、ロードバランサー名が必要です。ロードバランサーを指定しない場合は、取得可能なすべての
+      # ロードバランサー情報を取得します。
+      # 削除済みのロードバランサーを指定した、管理外のロードバランサーを指定したなど、無効なロードバランサーを指定した場合は、エラーが返されます。
+      #
+      #  @option options [Array<String>] :load_balancer_name    ロードバランサー名
+      #  @option options [Array<Integer>] :load_balancer_port  待ち受けポート
+      #  @option options [Array<Integer>] :instance_port       宛先ポート
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   describe_load_balancers(:load_balancer_name => ['lb1'], :load_balancer_port => [80], :instance_port => [80])
+      #
+      def describe_load_balancers( options={} )
+        [options[:load_balancer_name]].flatten.each do |o|
+          raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ o.to_s
+        end unless blank?(options[:load_balancer_name])
+        [options[:load_balancer_port]].flatten.each do |o| 
+          raise ArgumentError, "Invalid :load_balancer_port provided." unless valid_port?(o) 
+        end unless blank?(options[:load_balancer_port])
+        [options[:instance_port]].flatten.each do |o| 
+          raise ArgumentError, "Invalid :instance_port provided." unless valid_port?(o) 
+        end unless blank?(options[:instance_port])
+
+        params = {'Action' => 'DescribeLoadBalancers'}
+        params.merge!(pathlist('LoadBalancerNames.member', options[:load_balancer_name]))
+        params.merge!(pathlist('LoadBalancerNames.LoadBalancerPort', options[:load_balancer_port]))
+        params.merge!(pathlist('LoadBalancerNames.InstancePort', options[:instance_port]))
+
+        return response_generator(params)
+      end
+
+
+      # API「RegisterInstancesWithLoadBalancer」を実行し、
+      # 指定したロードバランサーにサーバーを追加します。
+      # ロードバランサーを指定するためには、ロードバランサー名・ポート番号が必要です。削除済みのロードバランサーを指定した、
+      # 管理外のロードバランサーを指定したなど、無効なロードバランサーを指定した場合は、エラーが返されます。
+      # またサーバーを指定するためには、サーバー名が必要です。IP アドレスを固定化しているサーバーを指定できます。IP アドレス
+      # を固定化していないサーバーを指定した、ほかのロードバランサーに設定されているサーバーを指定した、削除済みのサーバーを指定した、
+      # 管理外のサーバーを指定したなど、無効なサーバーを指定した場合は、エラーが返されます。
+      #
+      #  @option options [String] :load_balancer_name   対象のロードバランサー名(必須)
+      #  @option options [Integer] :load_balancer_port  対象の待ち受けポート(必須)
+      #  @option options [Integer] :instance_port       対象の宛先ポート(必須)
+      #  @option options [Array<String>] :instances     サーバー名(必須)
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   register_instances_with_load_balancer(:load_balancer_name => 'lb1', :load_balancer_port => 80, instance_port => 80, :instances => ['server01'])
+      #
+      def register_instances_with_load_balancer( options={} )
+        raise ArgumentError, "No :load_balancer_name provided." if blank?(options[:load_balancer_name])
+        raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ options[:load_balancer_name].to_s
+        raise ArgumentError, "No :load_balancer_port provided." if blank?(options[:load_balancer_port])
+        raise ArgumentError, "Invalid :load_balancer_port provided." unless valid_port?(options[:load_balancer_port])
+        raise ArgumentError, "No :instance_port provided." if blank?(options[:instance_port])
+        raise ArgumentError, "Invalid :instance_port provided." unless valid_port?(options[:instance_port])
+        raise ArgumentError, "No :instances provided." if blank?(options[:instances])
+
+        params = {'Action' => 'RegisterInstancesWithLoadBalancer'}
+        params.merge!(opts_to_prms(options, [:load_balancer_name, :load_balancer_port, :instance_port]))
+        params.merge!(pathhashlist('Instances.member', [options[:instances]].flatten.collect{|e| {:instances => e}}, {:instances => 'InstanceId'}))
+
+        return response_generator(params)
+      end
+
+
+      # API「RegisterPortWithLoadBalancer」を実行し、指定したロードバランサーにポートを追加します。
+      # ロードバランサーを指定するためには、ロードバランサー名が必要です。削除済みのロードバランサーを指定した、
+      # 管理外のロードバランサーを指定したなど、無効なロードバランサーを指定した場合は、エラーが返されます。
+      # ポートの追加に成功した場合は、以下のAPI を実行する必要があります。
+      #  ・ API「RegisterInstancesWithLoadBalancer」（サーバー設定）
+      #  ・ API「ConfigureHealthCheck」（ヘルスチェック設定）
+      # フィルターの設定は、「すべてのアクセスを許可する」になっています。変更を行う場合は以下のAPI を実行する必要があります。
+      # API「SetFilterForLoadBalancer」（フィルター設定）
+      #
+      #  @option options [String] :load_balancer_name     対象のロードバランサー名(必須)
+      #  @option options [Array<Hash>] :listeners         ロードバランサー設定 
+      #   <Hash> option   [String] :protocol               - 追加するプロトコル(:load_balancer_portといずれか必須)
+      #                    許可値: HTTP | HTTPS | FTP
+      #                   [Integer] :load_balancer_port    - 追加する待ち受けポート(:protocolといずれか必須)
+      #                   [Integer] :instance_port         - 追加する宛先ポート
+      #                   [String] :balancing_type         - 追加するロードバランス方式 
+      #                    許可値: 1(Round-Robin) | 2(Least-Connection)
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   register_port_with_load_balancer(:load_balancer_name => 'lb1', :listeners => {:protocol => 'http', :balancing_type => 1})
+      #
+      def register_port_with_load_balancer( options={} )
+        raise ArgumentError, "No :load_balancer_name provided." if blank?(options[:load_balancer_name])
+        raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ options[:load_balancer_name].to_s
+        raise ArgumentError, "No :listeners provided." if blank?(options[:listeners])
+        [options[:listeners]].flatten.each do |member|
+          raise ArgumentError, "expected each element of arr_of_hashes to be a Hash" unless member.is_a?(Hash)
+          raise ArgumentError, ":protocol or :load_balancer_port must be provided." if blank?(member[:protocol])&& 
+            blank?(member[:load_balancer_port])
+          raise ArgumentError, "Invalid :protocol provided." unless LOAD_BALANCER_PROTOCOL.include?(member[:protocol].to_s.upcase) || blank?(member[:protocol])
+          raise ArgumentError, "Invalid :load_balancer_port provided." unless valid_port?(member[:load_balancer_port]) || 
+            blank?(member[:load_balancer_port])
+          raise ArgumentError, "Invalid :instance_port provided." unless blank?(member[:instance_port]) || 
+            valid_port?(member[:instance_port])
+          raise ArgumentError, "Invalid :balancing_type provided." unless blank?(member[:balancing_type]) || 
+            BALANCING_TYPE.include?(member[:balancing_type].to_s) 
+        end
+
+        params = {'Action' => 'RegisterPortWithLoadBalancer'}
+        params.merge!(opts_to_prms(options, [:load_balancer_name, :network_volume, :ip_version]))
+        params.merge!(pathhashlist('Listeners.member', options[:listeners], 
+                                   {:protocol => 'Protocol', 
+                                     :load_balancer_port => 'LoadBalancerPort',
+                                     :instance_port => 'InstancePort', 
+                                     :balancing_type => 'BalancingType'}))
+
+        return response_generator(params)
+      end
+      
+
+      # API「SetFilterForLoadBalancer」を実行し、指定したロードバランサーにアクセスフィルターを設定します。
+      # ロードバランサーを指定するためには、ロードバランサー名・ポート番号が必要です。削除済みのロードバランサーを指定した、
+      # 管理外のロードバランサーを指定したなど、無効なロードバランサーを指定した場合は、エラーが返されます。
+      #
+      #  @option options [String] :load_balancer_name   対象のロードバランサー名(必須)
+      #  @option options [Integer] :load_balancer_port  対象の待ち受けポート(必須)
+      #  @option options [Integer] :instance_port       対象の宛先ポート(必須)
+      #  @option options [Array<Hash>] :ip_addresses    IPアドレス設定
+      #   <Hash> options  [String] :ip_address           - アクセス元IPアドレス
+      #                    許可値: 特定のIPアドレス(IPv4/IPv6)
+      #                   [Boolean] :add_on_filter       - 追加フラグ
+      #                    許可値: true(IPアドレスを追加) | false(IPアドレスを削除)
+      #  @option options [String] :filter_type          指定したアクセス元IP アドレスへの対処
+      #   許可値: 1 | 2
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   set_filter_for_load_balancer(:load_balancer_name => 'lb1', :load_balancer_port => 80, :instance_port => 80, 
+      #                                 :ipaddresses => {:ip_address => '111.111.111.111'}, :filter_type => 1)
+      #
+      def set_filter_for_load_balancer( options={} )
+        raise ArgumentError, "No :load_balancer_name provided." if blank?(options[:load_balancer_name])
+        raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ options[:load_balancer_name].to_s
+        raise ArgumentError, "No :load_balancer_port provided." if blank?(options[:load_balancer_port])
+        raise ArgumentError, "Invalid :load_balancer_port provided." unless valid_port?(options[:load_balancer_port])
+        raise ArgumentError, "No :instance_port provided." if blank?(options[:instance_port])
+        raise ArgumentError, "Invalid :instance_port provided." unless valid_port?(options[:instance_port])
+        raise ArgumentError, "Invalid :filter_type provided." unless blank?(options[:filter_type]) || FILTER_TYPE.include?(options[:filter_type].to_s)
+
+        params = {'Action' => 'SetFilterForLoadBalancer'}
+        params.merge!(opts_to_prms(options, [:load_balancer_name, :load_balancer_port, :instance_port, :filter_type]))
+
+        unless blank?(options[:ip_addresses])
+          [options[:ip_addresses]].flatten.each do |member|
+            raise ArgumentError, "expected each element of arr_of_hashes to be a Hash" unless member.is_a?(Hash)
+            begin IPAddr.new(member[:ip_address].to_s) rescue raise ArgumentError, "Invalid :ip_address provided." end unless blank?(member[:ip_address])
+            raise ArgumentError, "Invalid :add_on_filter provided." unless blank?(member[:add_on_filter]) || BOOLEAN.include?(member[:add_on_filter].to_s)
+          end
+          params.merge!(pathhashlist('IPAddresses.member', options[:ip_addresses], 
+                                     { :ip_address => 'IPAddress', :add_on_filter => 'AddOnFilter'}))
+        end
+
+        return response_generator(params)
+      end
+
+      # API「UpdateLoadBalancer」を実行し、指定したロードバランサーの定義を変更します。
+      # ポート定義を更新する場合は、ポート番号もあわせて指定します。
+      # 削除済みのロードバランサー名・待ち受けポートを指定した、管理外のロードバランサー名を指定した場合は、エラーが返されます。
+      #
+      #  @option options [String] :load_balancer_name             変更対象のロードバランサー名(必須)
+      #  @option options [Array<Hash>] :listener_update           ロードバランサー設定
+      #   <Hash> options  [Integer] :load_balancer_port            - 変更対象の待ち受けポート(ポート定義・ロードバランス方式を変更する場合必須) 
+      #                   [Integer] :instance_port                 - 変更対象の宛先ポート(ポート定義・ロードバランス方式を変更する場合必須) 
+      #                   [String] :listener_protocol              - プロトコルの更新値
+      #                    許可値: HTTP | HTTPS | FTP
+      #                   [Integer] :listener_load_balancer_port   - 待ち受けポートの更新値
+      #                   [Integer] :listener_instance_port        - 宛先ポートの更新値
+      #                   [String] :listener_balancing_type        - ロードバランス方式の更新値
+      #                    許可値: 1(Round-Robin) | 2(Least-Connection) 
+      #  @option options [String] :network_volume_update          最大ネットワーク流量の更新値
+      #   許可値: 10 | 20 | 30 | 40 | 100 | 200　（単位： Mbps）
+      #  @return [Hash] レスポンスXML解析結果
+      #
+      #  @example
+      #   update_load_balancer(:load_balancer_name => 'lb1', :listener_update => {:listener_protocol => 'https', :balancing_type => 2}, :network_volume_update => 20)
+      #
+      def update_load_balancer( options={} )
+        raise ArgumentError, "No :load_balancer_name provided." if blank?(options[:load_balancer_name])
+        raise ArgumentError, "Invalid :load_balancer_name provided." unless LOAD_BALANCER_NAME =~ options[:load_balancer_name].to_s
+        raise ArgumentError, "No :load_balancer_port provided." if blank?(options[:load_balancer_port]) && (!blank?(options[:listener_load_balancer_port]) || 
+                                                                                                            !blank?(options[:listener_instance_port]) || 
+                                                                                                            !blank?(options[:listener_protocol]) || 
+                                                                                                            !blank?(options[:listener_balancing_type]) || 
+                                                                                                            !blank?(options[:instance_port]))
+        raise ArgumentError, "Invalid :load_balancer_port provided." unless blank?(options[:load_balancer_port]) || 
+          valid_port?(options[:load_balancer_port])
+        raise ArgumentError, "No :instance_port provided." if blank?(options[:instance_port]) && !blank?(options[:load_balancer_port])
+        raise ArgumentError, "Invalid :instance_port provided." unless blank?(options[:instance_port]) || 
+          valid_port?(options[:instance_port])
+        raise ArgumentError, "Invalid :listener_protocol provided." unless blank?(options[:listener_protocol]) || 
+          LOAD_BALANCER_PROTOCOL.include?(options[:listener_protocol].to_s.upcase)
+        raise ArgumentError, "Invalid :listener_load_balancer_port provided." unless blank?(options[:listener_load_balancer_port]) || 
+          valid_port?(options[:listener_load_balancer_port])
+        raise ArgumentError, "Invalid :listener_instance_port provided." unless blank?(options[:listener_instance_port]) || 
+          valid_port?(options[:listener_instance_port])
+        raise ArgumentError, "Invalid :listener_balancing_type provided." unless blank?(options[:listener_balancing_type]) || 
+          BALANCING_TYPE.include?(options[:listener_balancing_type].to_s)
+        raise ArgumentError, "Invalid :network_volume_update provided." unless blank?(options[:network_volume_update]) || 
+          NETWORK_VOLUMES.include?(options[:network_volume_update].to_s)
+
+        params = {
+          'Action' => 'UpdateLoadBalancer',
+          'ListenerUpdate.Listener.Protocol' => options[:listener_protocol].to_s, 
+          'ListenerUpdate.Listener.LoadBalancerPort' => options[:listener_load_balancer_port].to_s, 
+          'ListenerUpdate.Listener.InstancePort' => options[:listener_instance_port].to_s, 
+          'ListenerUpdate.Listener.BalancingType' => options[:listener_balancing_type].to_s 
+        }
+        params.merge!(opts_to_prms(options, [:load_balancer_name, :network_volume_update]))
+        params.merge!(opts_to_prms(options, [:load_balancer_port, :instance_port], 'ListenerUpdate'))
+        
+        return response_generator(params)
+      end
+    end
+  end
+end