Class: NIFTY::Cloud::Base

Inherits:
Base
  • Object
show all
Defined in:
lib/NIFTY/Cloud.rb,
lib/NIFTY/Cloud/images.rb,
lib/NIFTY/Cloud/volumes.rb,
lib/NIFTY/Cloud/keypairs.rb,
lib/NIFTY/Cloud/instances.rb,
lib/NIFTY/Cloud/certificates.rb,
lib/NIFTY/Cloud/load_balancers.rb,
lib/NIFTY/Cloud/security_groups.rb,
lib/NIFTY/Cloud/availability_zones.rb

Constant Summary collapse

IMAGES_MODIFY_ATTRIBUTE = 
['description', 'imageName']
IMAGES_DESCRIBE_OWNER = 
['niftycloud', 'self']
IMAGES_IGNORED_PARAMS = 
Regexp.union(/Description/, 
/NoReboot/, 
/ExecutableBy\.\d+/, 
/LaunchPermission\.Add\.\d+\.UserId/, 
/LaunchPermission\.Add\.\d+\.Group/, 
/LaunchPermission\.Remove\.\d+\.UserId/, 
/LaunchPermission\.Remove\.\d+\.Group/, 
/ProductCode\.\d+/)
VOLUMES_CREATE_SIZE = 
['1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '15', '20']
VOLUMES_CREATE_DISK_TYPE = 
['1', '2', '3', '4', '5', '6']
VOLUMES_IGNORED_PARAMS = 
Regexp.union(/SnapshotId/, 
/AvailabilityZone/, 
/Device/, 
/Force/)
ALPHANUMERIC = 
/^[a-zA-Z0-9]+$/
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/)
VALIDITY_TERM = 
['6', '12', '24']
KEY_LENGTH = 
['1024', '2048']
CERTIFICATE_DESCRIBE_ATTRIBUTE = 
['count', 'certState', 'period', 'keyLength', 'uploadState', 'description', 'certInfo']
FILE_TYPE = 
['1', '2', '3']
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/)
FILTER_NAME = 
['description', 'group-name']
IP_PROTOCOL = 
['TCP', 'UDP', 'ICMP', 'SSH', 'HTTP', 'HTTPS', 'SMTP', 'POP3', 'IMAP']
IN_OUT = 
['IN', 'OUT']
DATE_FORMAT = 
%r!^(\d{8}|\d{4}-\d{2}-\d{2}|\d{4}/\d{2}/\d{2})$!
GROUP_NAME = 
Regexp.union(/^[a-zA-Z0-9]+$/, 'default(Linux)', 'default(Windows)')
SECURITY_GROUPS_IGNORED_PARAMS = 
Regexp.union(/UserId/, 
/IpPermissions\.\d+\.ToPort/, 
/IpPermissions\.\d+\.Groups\.\d+\.UserId/)
ZONES_IGNORED_PARAMS = 
Regexp.new(/ZoneName\.\d+/)
@@ignore_amz_params =

この値が真のときNIFTY Cloud API側で無視されるパラメータは送信されない

false

Constants inherited from Base

Base::DEFAULT_CONNECTION_TIMEOUT, Base::DEFAULT_CONTENT_TYPE, Base::DEFAULT_PORT, Base::DEFAULT_SOCKET_TIMEOUT, Base::PORT_RANGE, Base::PROTOCOL_HTTPS, Base::SIGNATURE_METHOD_SHA1, Base::SIGNATURE_METHOD_SHA256, Base::SIGNATURE_VERSION

Instance Attribute Summary

Attributes inherited from Base

#access_key, #connection_timeout, #max_retry, #path, #port, #proxy_server, #secret_key, #server, #signature_method, #signature_version, #socket_timeout, #use_ssl, #user_agent

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Base

Returns a new instance of Base.



7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/NIFTY/Cloud.rb', line 7

def initialize( options={} )
  @default_access_key         = ACCESS_KEY
  @default_secret_key         = SECRET_KEY
  @default_endpoint           = ENDPOINT_URL
  @default_proxy_server       = PROXY_SERVER
  @default_user_agent         = USER_AGENT
  @default_max_retry          = MAX_RETRY
  @default_connection_timeout = CONNECTION_TIMEOUT
  @default_socket_timeout     = SOCKET_TIMEOUT
  @default_signature_method   = SIGNATURE_METHOD
  @default_signature_version  = SIGNATURE_VERSION

  super(options)
end

Instance Method Details

#attach_volume(options = {}) ⇒ Object

API「AttachVolume」を実行し、指定したディスクをサーバーへ接続します。 ディスクを指定するためには、ディスク名が必要です。接続済み・削除済みのディスクを指定した、管理外のディスクを指定したなど、 無効なディスクを指定した場合は、エラーが返されます。 またサーバーを指定するためには、サーバー名が必要です。接続済み・削除済みのサーバーを指定した、管理外のサーバーを指定したなど、 無効なサーバーを指定した場合は、エラーが返されます。

@option options [String] :volume_id   サーバーに接続するディスク名(必須)
@option options [String] :instance_id 接続先のサーバー名(必須)
@return [Hash] レスポンスXML解析結果

@example
 attach_volume(:volume_id => 'vol1', :instance_id => 'server01')

Raises:



24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/NIFTY/Cloud/volumes.rb', line 24

def attach_volume( options = {} )
  raise ArgumentError, "No :volume_id provided." if blank?(options[:volume_id])
  raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])

  params = { 'Action' => 'AttachVolume' }
  params.merge!(opts_to_prms(options, [:volume_id, :instance_id, :device]))

  params.reject! {|k, v| VOLUMES_IGNORED_PARAMS =~ k } if @@ignore_amz_params

  return response_generator(params)
end

#authorize_security_group_ingress(options = {}) ⇒ Object

API「AuthorizeSecurityGroupIngress」を実行し、指定したファイアウォールグループへ許可ルールを追加します。 許可ルールの上限数を超える場合は、エラーが返されます。 ファイアウォールグループを指定するためには、ファイアウォールグループ名が必要です。削除済みのファイアウォールグループを指定した、 管理外のファイアウォールグループを指定したなど、無効なファイアウォールグループを指定した場合は、エラーが返されます。

@option options [String] :group_name           対象のファイアウォールグループ名(必須)
@option options [Array<Hash>] :ip_permissions  IP許可設定
 <Hash> options  [String] :protocol             - 許可プロトコル名
                  許可値: TCP | UDP | ICMP | SSH | HTTP | HTTPS
                 [Integer] :from_port           - 許可ポート(:protocolがTCP、UDPの場合は必須)
                 [String] :in_out               - Incoming/Outgoing 指定
                  許可値: IN(Incoming) | OUT(Outgoing)
                 [Array<String>] :group_name    - 許可するファイアウォールグループ名(:cidr_ipとどちらか必須)
                 [Array<String>] :cidr_ip       - 許可するIP アドレス(CIDR指定可) (:group_nameとどちらか必須)
@return [Hash] レスポンスXML解析結果

@example
 authorize_security_group_ingress(:group_name => 'gr1', :ip_permissions => [{:protocol => 'TCP',
                                                                             :from_port => 80,
                                                                             :in_out => 'IN',
                                                                             :group_name => ['gr1', 'gr2'],
                                                                             :cidr_ip => ['111.171.200.1/22', '111.111.111.112']} ])

Raises:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/NIFTY/Cloud/security_groups.rb', line 36

def authorize_security_group_ingress( options = {} )
  raise ArgumentError, "No :group_name provided." if blank?(options[:group_name])
  raise ArgumentError, "Invalid :group_name provided." unless GROUP_NAME =~ options[:group_name].to_s
  raise ArgumentError, "No :ip_permissions provided." if blank?(options[:ip_permissions])
  [options[:ip_permissions]].flatten.each do |opt|
    raise ArgumentError, "expected each element of arr_of_hashes to be a Hash" unless opt.is_a?(Hash)
    raise ArgumentError, "Invalid :ip_protocol provided." unless blank?(opt[:ip_protocol]) || IP_PROTOCOL.include?(opt[:ip_protocol].to_s.upcase)
    raise ArgumentError, "No :from_port provided." if /TCP|UDP/ =~ opt[:ip_protocol] && blank?(opt[:from_port])
    raise ArgumentError, "Invalid :from_port provided." unless blank?(opt[:from_port]) || valid_port?(opt[:from_port])
    raise ArgumentError, "Invalid :to_port provided." unless blank?(opt[:to_port]) || valid_port?(opt[:to_port])
    raise ArgumentError, "Invalid :in_out provided." unless blank?(opt[:in_out]) || IN_OUT.include?(opt[:in_out].to_s.upcase)
    raise ArgumentError, ":group_name or :cidr_ip must be provided." if blank?(opt[:group_name]) && blank?(opt[:cidr_ip])
    raise ArgumentError, "Invalid :group_name provided." unless blank?(opt[:group_name]) || GROUP_NAME =~ opt[:group_name].to_s
    [opt[:cidr_ip]].flatten.each do |ip|
      begin IPAddr.new(ip.to_s) rescue raise ArgumentError, "Invalid :cidr_ip provided." end
    end unless blank?(opt[:cidr_ip])

    opt[:user_id] = [opt[:user_id]].flatten unless blank?(opt[:user_id])
    opt[:group_name] = [opt[:group_name]].flatten unless blank?(opt[:group_name])
    opt[:cidr_ip] = [opt[:cidr_ip]].flatten unless blank?(opt[:cidr_ip])
  end unless blank?(options[:ip_permissions])

  params = {'Action' => 'AuthorizeSecurityGroupIngress'}
  params.merge!(opts_to_prms(options, [:user_id, :group_name]))
  unless blank?(options[:ip_permissions])
    params.merge!(pathhashlist('IpPermissions', options[:ip_permissions], 
                               { :ip_protocol  => 'IpProtocol',
                                 :from_port    => 'FromPort',
                                 :to_port      => 'ToPort',
                                 :in_out       => 'InOut', 
                                 :user_id => 'Groups', 
                                 :group_name => 'Groups', 
                                 :cidr_ip => 'IpRanges'}, 
                                 { :user_id => 'UserId', 
                                   :group_name => 'GroupName', 
                                   :cidr_ip => 'CidrIp'}))
  end

  params.reject! {|k, v| SECURITY_GROUPS_IGNORED_PARAMS =~ k } if @@ignore_amz_params

  return response_generator(params)
end

#cancel_copy_instances(options = {}) ⇒ Object

API「CancelCopyInstances」を実行し、指定したサーバーの作成（コピーによる作成）をキャンセルします。 作成待ちのサーバーのみ指定ができます。 サーバーを指定するためには、サーバー名が必要です。作成待ち以外のサーバーを指定した、管理外のサーバーを指定したなど、 無効なサーバーを指定した場合は、エラーが返されます。

@option options [String] :instance_id キャンセル対象のサーバー名(必須) 
@return [Hash] レスポンスXML解析結果

@example
 cancel_copy_instances(:instance_id => 'server01')

Raises:



360
361
362
363
364
365
366
367
368
369
 
# File 'lib/NIFTY/Cloud/instances.rb', line 360

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

#configure_health_check(options = {}) ⇒ Object

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)

Raises:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/NIFTY/Cloud/load_balancers.rb', line 35

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

#copy_instances(options = {}) ⇒ Object

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)

Raises:



309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/NIFTY/Cloud/instances.rb', line 309

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

#create_image(options = {}) ⇒ Object

API「CreateImage」を実行し、指定したサーバーをイメージ化し、カスタマイズイメージとして保存します。 サーバーをイメージ化するためには、サーバーを停止する必要があります。 カスタマイズイメージの作成には、時間がかかることがあります。このAPI のレスポンス「imageState」を確認し「pending」が返ってきた、 タイムアウトした場合は、API「DescribeImages」のレスポンス「imageState」でカスタマイズイメージのステータスを確認できます。 処理が失敗した場合、カスタマイズイメージは保存されず、エラーが返されます。

@option options [String] :instance_id      イメージ化元サーバー(必須)
@option options [String] :name             イメージ名(必須)
@option options [Boolean] :left_instance   イメージ化元サーバーを残す
 許可値: true(サーバーを残す) | false(サーバーを残さない) 
@return [Hash] レスポンスXML解析結果

@example
 create_image(:instance_id => 'server01', :name => 'image01', :left_instance => true)

Raises:



59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/NIFTY/Cloud/images.rb', line 59

def create_image( options = {} )
  raise ArgumentError, "No :instance_id provided" if blank?(options[:instance_id])
  raise ArgumentError, "No :name provided" if blank?(options[:name])
  raise ArgumentError, "Invalid :left_instance provided. only 'true' or 'false' allowed." unless blank?(options[:left_instance]) || 
    BOOLEAN.include?(options[:left_instance].to_s)

  params = { 'Action' => 'CreateImage' }
  params.merge!(opts_to_prms(options, [:instance_id, :name, :description, :no_reboot, :left_instance]))

  params.reject! {|k, v| IMAGES_IGNORED_PARAMS =~ k } if @@ignore_amz_params

  return response_generator(params)
end

#create_key_pair(options = {}) ⇒ Object

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')

Raises:



18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/NIFTY/Cloud/keypairs.rb', line 18

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

#create_load_balancer(options = {}) ⇒ Object

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)

Raises:



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/NIFTY/Cloud/load_balancers.rb', line 88

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

#create_security_group(options = {}) ⇒ Object

API「CreateSecurityGroup」を実行し、ファイアウォールグループを新規作成します。 ファイアウォールの有償版に申し込んでいない場合は、エラーが返されます。 すでに存在するファイアウォールグループ名を指定した、作成可能なファイアウォールグループの上限数を超える場合は、エラーが返されます。 ファイアウォールの有償版を申し込むには、コントロールパネルで設定する必要があります。

@option options [String] :group_name         ファイアウォールグループ名(必須)
 使用可能文字: 半角英数字
@option options [String] :group_description  ファイアウォールグループのメモ
@return [Hash] レスポンスXML解析結果

@example
 create_security_group(:group_name => 'group01', :group_description => 'Security Group memo.')

Raises:



93
94
95
96
97
98
99
100
101
 
# File 'lib/NIFTY/Cloud/security_groups.rb', line 93

def create_security_group( options={} )
  raise ArgumentError, "No :group_name provided." if blank?(options[:group_name])
  raise ArgumentError, "Invalid :group_name provided." unless ALPHANUMERIC =~ options[:group_name].to_s

  params = {'Action' => 'CreateSecurityGroup'}
  params.merge!(opts_to_prms(options, [:group_name, :group_description]))

  return response_generator(params)
end

#create_ssl_certificate(options = {}) ⇒ Object

API「CreateSslCertificate」を実行し、SSL 証明書の新規作成または更新を行います。 申請法人情報が未登録の場合は、エラーが返されます。 パラメーター「fqdnId」を指定した場合、指定したSSL 証明書を更新します。指定したSSL 証明書の有効期間が更新可能ではない、 アップロードした証明書を指定した、存在しないSSL 証明書を指定した場合など、無効なSSL 証明書を指定した場合は、エラーが返されます。 パラメーター「fqdnId」を指定しない場合、SSL 証明書を新規作成します。作成可能なSSL 証明書の上限数を超える場合は、エラーが返されます。 また申請法人情報を登録するには、API「RegisterCorporateInfoForCertificate」を実行します。

@option options [String] :fqdn_id                  SSL証明書の識別子(必須)
@option options [String] :fqdn                     FQDN(必須)
@option options [Integer] :count                   SSL証明書の数量(必須)
 許可値: 1 - 30
@option options [Integer] :validity_term           SSL証明書の有効月数(必須)
 許可値: 6 (半年) | 12 (1年) | 24 (2年)
@option options [Integer] :key_length              SSL証明書の鍵長(必須)
 許可値: 1024 (1024bit) | 2048 (2048bit)
@option options [String] :organization_name        申請組織名(必須)
@option options [String] :organization_unit_name   申請部署名(必須)
@option options [String] :state_name               事業所住所の都道府県名(必須)
@option options [String] :location_name            事業所住所の市区町村名(必須)
@return [Hash] レスポンスXML解析結果

@example
 create_ssl_certificate(:fqdn => 'aaa.aaa.aaa', :count => 2, :validity_term => 24, :key_length => 1024, :organization_name => 'NIFTY', 
                         :organization_unit_name => 'Center Department', :state_name => 'Tokyo', :location_name => 'Shinagawa-ku')

Raises:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/NIFTY/Cloud/certificates.rb', line 34

def create_ssl_certificate( options={} )
  raise ArgumentError, ":fqdn_id or :fqdn must be provided." if blank?(options[:fqdn_id]) && blank?(options[:fqdn])
  unless blank?(options[:fqdn])
    raise ArgumentError, "No :count provided." if blank?(options[:count])
    raise ArgumentError, "No :validity_term provided." if blank?(options[:validity_term])
    raise ArgumentError, "No :key_length provided." if blank?(options[:key_length])
    raise ArgumentError, "No :organization_name provided." if blank?(options[:organization_name])
    raise ArgumentError, "No :organization_unit_name provided." if blank?(options[:organization_unit_name])
    raise ArgumentError, "No :state_name provided." if blank?(options[:state_name])
    raise ArgumentError, "No :location_name provided." if blank?(options[:location_name])
  end
  raise ArgumentError, "Invalid :count provided." unless blank?(options[:count]) || ('1'..'30').to_a.include?(options[:count].to_s)
  raise ArgumentError, "Invalid :validity_term provided." unless blank?(options[:validity_term]) || 
    VALIDITY_TERM.include?(options[:validity_term].to_s)
  raise ArgumentError, "Invalid :key_length provided." unless blank?(options[:key_length]) || KEY_LENGTH.include?(options[:key_length].to_s)

  params = {'Action' => 'CreateSslCertificate'}
  params.merge!(opts_to_prms(options, [:fqdn_id, :fqdn, :count, :validity_term, :key_length]))
  params.merge!(opts_to_prms(options, [:organization_name, :organization_unit_name, :country_name, 
                             :state_name, :location_name, :email_address], 'CertInfo'))

  return response_generator(params)
end

#create_volume(options = {}) ⇒ Object

API「CreateVolume」を実行し、ディスクを新規作成します。 サーバーを指定するためには、サーバー名が必要です。削除済みのサーバーを指定した、管理外のサーバーを指定した、停止済み 以外のサーバーを指定したなど、無効なサーバーを指定した場合は、エラーが返されます。同様に、ディスクサイズおよびディスク タイプに規定外の値を指定した、すでに存在するディスク名を指定したなどの場合は、エラーが返されます。

@option options [String] :size         ディスクサイズ(必須)
 許可値: (低速) 1(100) | 2(200) | 3(300) | 4(400) | 5(500) | 10(1000) | 15(1500) | 20(2000)
         (高速) 1(100) | 2(200) | 3(300) | 4(400) | 5(500) | 6(600) | 7(700) | 8(800) | 9(900) | 10(1000)　（単位： GB）
@option options [String] :volume_id    ディスク名
@option options [String] :disk_type    ディスクタイプ
 許可値: 1(disk100) | 2(disk40) | 3(disk100A) | 4(disk100B) | 5(disk40A) | 6(disk40B)
@option options [String] :instance_id  サーバー名(必須)
@return [Hash] レスポンスXML解析結果

@example
 create_volume(:size => 1, :volume_id => 'vol1', :disk_type => 1, :instance_id => 'server01')

Raises:



54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/NIFTY/Cloud/volumes.rb', line 54

def create_volume( options = {} )
  raise ArgumentError, "No :size provided." if blank?(options[:size])
  raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])
  raise ArgumentError, "Invalid :size provided." unless blank?(options[:size]) || VOLUMES_CREATE_SIZE.include?(options[:size].to_s)
  raise ArgumentError, "Invalid :disk_type provided." unless blank?(options[:disk_type]) || VOLUMES_CREATE_DISK_TYPE.include?(options[:disk_type].to_s)

  params = {'Action' => 'CreateVolume'}
  params.merge!(opts_to_prms(options, [:size, :snapshot_id, :availability_zone, :volume_id, :disk_type, :instance_id]))

  params.reject! {|k, v| VOLUMES_IGNORED_PARAMS =~ k } if @@ignore_amz_params

  return response_generator(params)
end

#delete_image(options = {}) ⇒ Object

API「DeleteImage」を実行し、指定したカスタマイズイメージを削除します。 削除中のカスタマイズイメージを指定してサーバー作成を行った場合は、サーバー作成からエラーが返されます。 カスタマイズイメージを選択して作成されたサーバーのOSイメージ名は、カスタマイズイメージの削除が完了すると、イメージ化した サーバーのOS 名が返されます。

@option options [String] :image_id 削除対象のイメージID(必須)
 許可値: 10000以降の数値
@return [Hash] レスポンスXML解析結果

@example
 delete_image(:image_id => 10430)

Raises:



86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/NIFTY/Cloud/images.rb', line 86

def delete_image( 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 >= 10000

  params = { 
    'Action'  => 'DeleteImage',
    'ImageId' => options[:image_id].to_s
  }

  return response_generator(params)
end

#delete_key_pair(options = {}) ⇒ Object

API「DeleteKeyPair」を実行し、SSH キーの情報を削除します。 SSHキーを指定するためには、SSHキー名が必要です。削除済みのSSHキーを指定した、管理外のSSHキーを指定したなど、 無効なSSH キーを指定した場合は、エラーが返されます。

@option options [String] :key_name 削除対象のSSHキー名(必須)
@return [Hash] レスポンスXML解析結果

@example
 delete_keypair(:key_name => 'key')

Raises:



41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/NIFTY/Cloud/keypairs.rb', line 41

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

#delete_load_balancer(options = {}) ⇒ Object

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)

Raises:



130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/NIFTY/Cloud/load_balancers.rb', line 130

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

#delete_security_group(options = {}) ⇒ Object

API「DeleteSecurityGroup」を実行し、指定したファイアウォールグループを削除します。 指定したファイアウォールグループを適用しているサーバーが存在する場合、エラーが返されます。同様に、適用しているオートスケール設定が存在する場合、 エラーが返されます。 ファイアウォールグループを指定するためには、ファイアウォールグループ名が必要です。 削除済みのファイアウォールグループを指定した、管理外のファイアウォールグループを指定したなど、無効なファイアウォールグループを指定した場合は、 エラーが返されます。

@option options [String] :group_name   対象のファイアウォールグループ名(必須)
@return [Hash] レスポンスXML解析結果

@example
 delete_security_group(:group_name => 'group01')

Raises:



117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/NIFTY/Cloud/security_groups.rb', line 117

def delete_security_group( options={} )
  raise ArgumentError, "No :group_name provided" if blank?(options[:group_name])
  raise ArgumentError, "Invalid :group_name provided." unless ALPHANUMERIC =~ options[:group_name].to_s

  params = { 
    'Action' => 'DeleteSecurityGroup',
    'GroupName' => options[:group_name].to_s 
  }

  return response_generator(params)
end

#delete_ssl_certificate(options = {}) ⇒ Object

API「DeleteSslCertificate」を実行し、指定したSSL 証明書を削除します。 指定したSSL 証明書のステータスが「期限切れ」「失効」「発行エラー」以外の場合は、エラーが返されます。 またアップロードしたSSL証明書は、ステータスに関わらず削除できます。 SSL 証明書を指定するためには、SSL 証明書の発行識別子（fqdnId）が必要です。削除済みのSSL 証明書を指定した、 管理外のSSL 証明書を指定したなど、無効なSSL 証明書を指定した場合は、エラーが返されます。

@option options [String] :fqdn_id  SSL証明書の識別子(必須)
@return [Hash] レスポンスXML解析結果

@example
 delete_ssl_certificate(:fqdn_id => 111)

Raises:



71
72
73
74
75
76
77
78
79
80
 
# File 'lib/NIFTY/Cloud/certificates.rb', line 71

def delete_ssl_certificate( options={} )
  raise ArgumentError, "No :fqdn_id provided." if blank?(options[:fqdn_id])

  params = {
    'Action'  => 'DeleteSslCertificate',
    'FqdnId'  => options[:fqdn_id].to_s
  }

  return response_generator(params)
end

#delete_volume(options = {}) ⇒ Object

API「DeleteVolume」を実行し、指定したディスクを削除します。 ディスクを指定するためには、ディスク名が必要です。接続済み・削除済みのディスクを指定した、管理外のディスクを指定したなど、 無効なディスクを指定した場合は、エラーが返されます。 削除には、時間がかかることがあります。 なお、サーバーに接続しているディスクを指定した場合には、エラーが返されます。ディスクの接続ステータスは、API 「DescribeVolumes」のレスポンス「attachmentSet.status」で確認できます。

@option options [String] :volume_id 削除対象のディスク名(必須)
@return [Hash] レスポンスXML解析結果

@example
 delete_volume(:volume_id => 'vol1')

Raises:



82
83
84
85
86
87
88
89
90
91
 
# File 'lib/NIFTY/Cloud/volumes.rb', line 82

def delete_volume( options = {} )
  raise ArgumentError, "No :volume_id provided." if blank?(options[:volume_id])

  params = {
    'Action' => 'DeleteVolume',
    'VolumeId' => options[:volume_id].to_s
  }
  
  return response_generator(params)
end

#deregister_instances_from_load_balancer(options = {}) ⇒ Object

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'])

Raises:



160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/NIFTY/Cloud/load_balancers.rb', line 160

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

#deregister_instances_from_security_group(options = {}) ⇒ Object

API「DeregisterInstancesFromSecurityGroup」を実行し、指定したファイアウォールグループから、指定したサーバーをはずします。 ファイアウォールグループを指定するためには、ファイアウォールグループ名が必要です。削除済みのファイアウォールグループを指定した、 管理外のファイアウォールグループを指定したなど、無効なファイアウォールグループを指定した場合は、エラーが返されます。 またサーバーを指定するためには、サーバー名が必要です。指定したファイアウォールグループに適用されていないサーバーを指定した、 削除済みのサーバーを指定した、管理外のサーバーを指定したなど、無効なサーバーを指定した場合は、エラーが返されます。

@option options [String] :group_name           ファイアウォールグループ名(必須)
@option options [Array<String>] :instance_id   サーバー名(必須)
@return [Hash] レスポンスXML解析結果

@example
 deregister_instances_from_security_group(:group_name => 'group01', :instance_id => ['server01', 'server02'])

Raises:



143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/NIFTY/Cloud/security_groups.rb', line 143

def deregister_instances_from_security_group( options={} )
  raise ArgumentError, "No :group_name provided." if blank?(options[:group_name])
  raise ArgumentError, "Invalid :group_name provided." unless GROUP_NAME =~ options[:group_name].to_s
  raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])

  params = { 
    'Action'    => 'DeregisterInstancesFromSecurityGroup',
    'GroupName' => options[:group_name].to_s
  }
  params.merge!(pathlist('InstanceId', options[:instance_id]))

  return response_generator(params)
end

#describe_availability_zones(options = {}) ⇒ Object

API「DescribeAvailabilityZones」を実行し、利用可能なゾーンの情報を取得します。常に、ゾーン「ap-japan-1a」の情報が返されます。

@return [Hash] レスポンスXML解析結果

@example
 describe_availability_zones(:zone_name => 'ap-japan-1a')



13
14
15
16
17
18
19
20
 
# File 'lib/NIFTY/Cloud/availability_zones.rb', line 13

def describe_availability_zones( options={} )
  params = {'Action' => 'DescribeAvailabilityZones'}
  params.merge!(pathlist('ZoneName', options[:zone_name]))

  params.reject! {|k, v| ZONES_IGNORED_PARAMS =~ k } if @@ignore_amz_params

  return response_generator(params)
end

#describe_images(options = {}) ⇒ Object

API「DescribeImages」を実行し、OS イメージの情報を取得します。 特定のOS イメージを指定するためには、OS イメージID またはOS イメージ名が必要です。OS イメージを指定しない場合は、 取得可能なすべてのOS イメージ情報を取得します。無効なOS イメージを指定した場合は、エラーが返されます。

@option options [Array<String>] :image_id   OSイメージID
@option options [Array<String>] :image_name OSイメージ名
@option options [Array<String>] :owner      OSイメージの種別
 許可値: niftycloud | self
@return [Hash] レスポンスXML解析結果

@example
 describe_images(:image_id => [12000, 11001], :image_name => ['image01', 'image02'], :owner => ['niftycloud', 'self'])

Raises:



28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/NIFTY/Cloud/images.rb', line 28

def describe_images( options = {} )
  [options[:owner]].flatten.each{|o| raise ArgumentError, "Invalid :owner provided." unless IMAGES_DESCRIBE_OWNER.include?(o) } unless blank?(options[:owner])
  raise ArgumentError, "Invalid :image_id provided." unless blank?(options[:image_id]) || options[:image_id].to_s.to_i > 0
  
  params = {'Action' => 'DescribeImages'}
  params.merge!(pathlist("ExecutableBy", options[:executable_by]))
  params.merge!(pathlist("ImageId", options[:image_id]))
  params.merge!(pathlist("ImageName", options[:image_name]))
  params.merge!(pathlist("Owner", options[:owner]))

  params.reject! {|k, v| IMAGES_IGNORED_PARAMS =~ k } if @@ignore_amz_params

  return response_generator(params)
end

#describe_instance_attribute(options = {}) ⇒ Object

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')

Raises:



37
38
39
40
41
42
43
44
45
 
# File 'lib/NIFTY/Cloud/instances.rb', line 37

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

#describe_instance_health(options = {}) ⇒ Object

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'])

Raises:



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/NIFTY/Cloud/load_balancers.rb', line 194

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

#describe_instances(options = {}) ⇒ Object

API「DescribeInstances」を実行し、指定したサーバーの情報を取得します。1 回のリクエストで、複数のサーバー情報を取得できます。 サーバーを指定するためには、サーバー名が必要です。サーバーを指定しない場合は、取得可能なすべてのサーバー情報を取 得します。削除済みのサーバーを指定した、管理外のサーバーを指定したなど、無効なID を指定した場合は、エラーが返されます。

@option options [Array<String>] :instance_id サーバー名
@return [Hash] レスポンスXML解析結果

@example 
 describe_instances(:instance_id => 'server01')



58
59
60
61
62
63
 
# File 'lib/NIFTY/Cloud/instances.rb', line 58

def describe_instances( options = {} )
  params = {'Action' => 'DescribeInstances'}
  params.merge!(pathlist('InstanceId', options[:instance_id]))

  return response_generator(params)
end

#describe_key_pairs(options = {}) ⇒ Object

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'])

Raises:



65
66
67
68
69
70
71
72
 
# File 'lib/NIFTY/Cloud/keypairs.rb', line 65

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

#describe_load_balancers(options = {}) ⇒ Object

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])



224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/NIFTY/Cloud/load_balancers.rb', line 224

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

#describe_security_activities(options = {}) ⇒ Object

API「DescribeSecurityActivities」を実行し、指定したファイアウォールグループのログ情報を取得します。 ファイアウォールグループを指定するためには、ファイアウォールグループ名が必要です。削除済みのファイアウォールグループを指定した、 管理外のファイアウォールグループを指定したなど、無効なファイアウォールグループを指定した場合は、エラーが返されます。

@option options [String] :group_name           ファイアウォールグループ名(必須)
@option options [String] :activity_date        取得するログの絞り込み条件(日)
 形式: yyyymmdd | yyyy-mm-dd | yyyy/mm/dd
@option options [Boolean] :range_all           指定日内のログを全件取得
 許可値: true(全件取得) | false(件数指())
@option options [Integer] :range_start_number  取得開始件数
 許可値: 1 - 取得可能な最大件数
@option options [Integer] :range_end_number    取得終了件数
 許可値: 1 - 取得可能な最大件数
@return [Hash] レスポンスXML解析結果

@example
 describe_security_activities(:group_name => 'group01', :activity_date => '2011-06-08', :range_all => false, 
                               :range_start_number => 1, :range_end_number => 10)

Raises:



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/NIFTY/Cloud/security_groups.rb', line 177

def describe_security_activities( options={} )
  raise ArgumentError, "No :group_name provided." if blank?(options[:group_name])
  raise ArgumentError, "Invalid :group_name provided." unless GROUP_NAME =~ options[:group_name].to_s
  raise ArgumentError, "Invalid :activity_date provided." unless blank?(options[:activity_date]) || DATE_FORMAT =~ options[:activity_date].to_s
  raise ArgumentError, "Invalid :range_all provided." unless blank?(options[:range_all]) || BOOLEAN.include?(options[:range_all].to_s)
  raise ArgumentError, "Invalid :range_start_number provided." unless blank?(options[:range_start_number]) || options[:range_start_number].to_s.to_i >= 1
  raise ArgumentError, "Invalid :range_end_number provided." unless blank?(options[:range_end_number]) || (options[:range_end_number]).to_s.to_i >= 1
  raise ArgumentError, "Invalid :range_end_number provided." unless blank?(options[:range_start_number]) || blank?(options[:range_end_number]) || 
    options[:range_start_number] <= options[:range_end_number]

  params = {
    'Action'            => 'DescribeSecurityActivities',
    'GroupName'         => options[:group_name].to_s,
    'ActivityDate'      => options[:activity_date].to_s,
    'Range.All'         => options[:range_all].to_s,
    'Range.StartNumber' => options[:range_start_number].to_s,
    'Range.EndNumber'   => options[:range_end_number].to_s
  }

  return response_generator(params)
end

#describe_security_groups(options = {}) ⇒ Object

API「DescribeSecurityGroups」を実行し、指定したファイアウォールグループの設定情報を取得します。 ファイアウォールグループを指定するためには、ファイアウォールグループ名が必要です。指定しない場合は、取得可能なすべての ファイアウォールグループの設定情報を取得します。

@option options [String] :group_name     ファイアウォールグループ名
@option options [Array<Hash>] :filter    フィルター設定
 <Hash> options  [String] 絞り込み条件の項目名
                  許可値: description | group-name 
                 [String] 絞り込み条件の値 （前方一致）
@return [Hash] レスポンスXML解析結果

@example
 describe_security_groups(:group_name => 'group01', :filter => [ {'description' => 'filter1'}, {'group-name' => ['filter1', 'filter2']} ])



214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/NIFTY/Cloud/security_groups.rb', line 214

def describe_security_groups( options={} )
  [options[:group_name]].flatten.each do |e|
    raise ArgumentError, "Invalid :group_name provided." unless GROUP_NAME =~ options[:group_name].to_s
  end unless blank?(options[:group_name])

  params = {'Action' => 'DescribeSecurityGroups'}
  params.merge!(pathlist("GroupName", options[:group_name]))
  unless blank?(options[:filter])
    [options[:filter]].flatten.each do |opt|
      raise ArgumentError, "expected each element of arr_of_hashes to be a Hash" unless opt.is_a?(Hash)
      raise ArgumentError, "Invalid :name provided." unless blank?(opt[:name]) || FILTER_NAME.include?(opt[:name].to_s) 
      
      opt[:value] = [opt[:value]].flatten unless blank?(opt[:value])
    end

    params.merge!(pathhashlist('Filter', options[:filter], {:name => 'Name', :value => 'Value'}))
  end

  return response_generator(params)
end

#describe_ssl_certificate_attribute(options = {}) ⇒ Object

API「DescribeSslCertificateAttribute」を実行し、指定したSSL証明書の詳細情報を取得します。 1回のリクエストで、指定したSSL証明書のどれか1つの詳細情報を取得できます。 SSL証明書を指定するためには、SSL 証明書の発行識別子（fqdnId）が必要です。削除済みのSSL証明書を指定した、 管理外のSSL証明書を指定したなど、無効なSSL 証明書を指定した場合は、エラーが返されます。

@option options [String] :fqdn_id    SSL証明書の識別子(必須)
@option options [String] :attribute  取得する情報の項目名
 許可値: count(SSL証明書の数量を取得) | certState(SSL証明書の発行ステータスを取得) | period(SSL証明書の有効期間を取得) | 
         keyLength(SSL証明書の鍵長を取得) | uploadState(SSL証明書の種別を取得) | description(SSL証明書のメモ情報を取得) | 
         certInfo(SSL証明書の発行申請情報を取得)

@return [Hash] レスポンスXML解析結果

@example
 describe_ssl_certificate_attribute(:fqdn_id => 111, :attribute => 'certInfo')

Raises:



119
120
121
122
123
124
125
126
127
128
 
# File 'lib/NIFTY/Cloud/certificates.rb', line 119

def describe_ssl_certificate_attribute( options={} )
  raise ArgumentError, "No :fqdn_id provided." if blank?(options[:fqdn_id])
  raise ArgumentError, "Invalid :attribute provided." unless blank?(options[:attribute]) || 
    CERTIFICATE_DESCRIBE_ATTRIBUTE.include?(options[:attribute].to_s)

  params = {'Action' => 'DescribeSslCertificateAttribute'}
  params.merge!(opts_to_prms(options, [:fqdn_id, :attribute]))

  return response_generator(params)
end

#describe_ssl_certificates(options = {}) ⇒ Object

API「DescribeSslCertificates」を実行し、指定したSSL 証明書の情報を取得します。 SSL証明書を指定するためには、SSL 証明書の発行識別子（fqdnId）またはFQDN が必要です。 指定しない場合は、取得可能なすべてのSSL証明書の情報を取得します。

@option options [Array<String>] :fqdn_id   SSL証明書の識別子
@option options [Array<String>] :fqdn      FQDN
@return [Hash] レスポンスXML解析結果

@example
 describe_ssl_certificates(:fqdn_id => 111, :fqdn => 'aaa.aaa.aaa.')



94
95
96
97
98
99
100
 
# File 'lib/NIFTY/Cloud/certificates.rb', line 94

def describe_ssl_certificates( options={} )
  params = {'Action' => 'DescribeSslCertificates'}
  params.merge!(pathlist('Fqdn', options[:fqdn]))
  params.merge!(pathlist('FqdnId', options[:fqdn_id]))

  return response_generator(params)
end

#describe_volumes(options = {}) ⇒ Object

API「DescribeVolumes」を実行し、指定したディスクの情報を取得します。 ディスクを指定するためには、ディスク名が必要です。削除済みのディスクを指定した、管理外のディスクを指定したなど、 無効なディスクを指定した場合は、エラーが返されます。 ディスクを指定しない場合、取得できるすべてのディスク情報を取得します。

@option options [Array<String>] :volume_id ディスク名
@return [Hash] レスポンスXML解析結果

@example
 describe_volumes(:volume_id => ['vol1', 'vol2'])



105
106
107
108
109
110
 
# File 'lib/NIFTY/Cloud/volumes.rb', line 105

def describe_volumes( options = {} )
  params = {'Action' => 'DescribeVolumes'}
  params.merge!(pathlist("VolumeId", options[:volume_id]))

  return response_generator(params)
end

#detach_volume(options = {}) ⇒ Object

API「DetachVolume」を実行し、指定したディスクとサーバーの接続を解除します。 ディスクを指定するためには、ディスク名が必要です。解除済み・削除済みのディスクを指定した、管理外のディスクを指定したなど、 無効なディスクを指定した場合は、エラーが返されます。 またサーバーを指定するためには、サーバー名が必要です。解除済み・削除済みのサーバーを指定した、管理外のサーバーを指定したなど、 無効なサーバーを指定した場合は、エラーが返されます。サーバー名を指定せずに解除すると、指定したディスクのすべての接続情報を解除します。

@option options [String] :volume_id    接続解除対象のディスク名(必須)
@option options [String] :instance_id  接続解除されるサーバー名
@return [Hash] レスポンスXML解析結果

@example
 detach_volume(:volume_id => 'vol1', :instance_id => 'server01')

Raises:



126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/NIFTY/Cloud/volumes.rb', line 126

def detach_volume( options = {} )
  raise ArgumentError, "No :volume_id provided." if blank?(options[:volume_id])
  raise ArgumentError, "Invalid :force provided." unless blank?(options[:force]) || BOOLEAN.include?(options[:force].to_s)

  params = { 'Action' => 'DetachVolume' }
  params.merge!(opts_to_prms(options,[:volume_id, :instance_id, :device, :force]))

  params.reject! {|k, v| VOLUMES_IGNORED_PARAMS =~ k } if @@ignore_amz_params

  return response_generator(params)
end

#download_ssl_certificate(options = {}) ⇒ Object

API「DownloadSslCertificate」を実行し、指定したSSL証明書をダウンロードします。 1回のリクエストで、SSL証明書のキー・CA・証明書のいずれかを取得できます。 SSL証明書を指定するためには、SSL 証明書の発行識別子（fqdnId）が必要です。削除済みのSSL証明書を指定した、 管理外のSSL証明書を指定したなど、無効なSSL証明書を指定した場合は、エラーが返されます。 またSSL証明書の発行状況により、指定したファイルがダウンロードできない場合があります。

@option options [String] :fqdn_id    SSL証明書の識別子(必須)
@option options [String] :file_type  ダウンロードするファイル種別(必須)
 許可値: 1 (キー) | 2 (CA) | 3 (証明書)
@return [Hash] レスポンスXML解析結果

@example
 download_ssl_certificate(:fqdn_id => 111, :file_type => 1)

Raises:



145
146
147
148
149
150
151
152
153
154
 
# File 'lib/NIFTY/Cloud/certificates.rb', line 145

def download_ssl_certificate( options={} )
  raise ArgumentError, "No :fqdn_id provided." if blank?(options[:fqdn_id])
  raise ArgumentError, "No :file_type provided." if blank?(options[:file_type])
  raise ArgumentError, "Invalid :file_type provided." unless FILE_TYPE.include?(options[:file_type].to_s)

  params = {'Action' => 'DownloadSslCertificate'}
  params.merge!(opts_to_prms(options, [:fqdn_id, :file_type]))

  return response_generator(params)
end

#modify_image_attribute(options = {}) ⇒ Object

API「ModifyImageAttribute」を実行し、指定したカスタマイズイメージの詳細情報を更新します。1 回のリクエストで、1 つのカスタマイズイメージの情報を更新できます。 カスタマイズイメージを指定するためには、イメージID が必要です。削除済みのイメージID を指定した、管理外のイメージID を指定したなど、 無効なイメージID を指定した場合は、エラーが返されます。

@option options [String] :image_id   更新対象のイメージID(必須)
 許可値: 10000以降の数値
@option options [String] :attribute  更新対象の項目名(必須)
 許可値:  description | imageName 
@option options [String] :attribute  更新値
@return [Hash] レスポンスXML解析結果

@example
 modify_image_attribute(:image_id => 10000, :attribute => 'description', :value => 'メモ')

Raises:



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/NIFTY/Cloud/images.rb', line 113

def modify_image_attribute( 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 >= 10000
  raise ArgumentError, "No :attribute provided." if blank?(options[:attribute])
  raise ArgumentError, "Invalid :attribute provided." unless blank?(options[:attribute]) || IMAGES_MODIFY_ATTRIBUTE.include?(options[:attribute])

  params = {'Action' => 'ModifyImageAttribute'}
  params.merge!(opts_to_prms(options, [:image_id, :attribute, :value]))
  params.merge!(pathhashlist('LaunchPermission.Add', options[:launch_permission_add], 
                             {:user_id => 'UserId', :group => 'Group'})) unless blank?(options[:launch_permission_add])
  params.merge!(pathhashlist('LaunchPermission.Remove', options[:launch_permission_remove], 
                             {:user_id => 'UserId', :group => 'Group'})) unless blank?(options[:launch_permission_remove])
  params.merge!(pathlist('ProductCode', options[:product_code]))

  params.reject! {|k, v| IMAGES_IGNORED_PARAMS =~ k } if @@ignore_amz_params

  return response_generator(params)
end

#modify_instance_attribute(options = {}) ⇒ Object

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')

Raises:



86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/NIFTY/Cloud/instances.rb', line 86

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

#modify_ssl_certificate_attribute(options = {}) ⇒ Object

API「ModifySslCertificateAttribute」を実行し、指定したSSL 証明書の詳細情報を更新します。1 回のリクエストで、1 つのSSL 証明書の1 つの詳細情報を更新できます。 SSL証明書を指定するためには、SSL 証明書の発行識別子（fqdnId）が必要です。削除済みのSSL証明書を指定した、管理外のSSL 証明書を指定したなど、無効なSSL 証明書を指定した場合は、エラーが返されます。

@option options [String] :fqdn_id      SSL証明書の識別子(必須)
@option options [String] :description  SSL 証明書のメモ情報の更新値
@return [Hash] レスポンスXML解析結果

@example
 modify_ssl_certificate_attribute(:fqdn_id => 111, :description => 'For service A')

Raises:



168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/NIFTY/Cloud/certificates.rb', line 168

def modify_ssl_certificate_attribute( options={} )
  raise ArgumentError, "No :fqdn_id provided." if blank?(options[:fqdn_id])

  params = {
    'Action'  => 'ModifySslCertificateAttribute',
    'FqdnId'  => options[:fqdn_id].to_s,
    'Description.Value' => options[:description].to_s
  }

  return response_generator(params)
end

#reboot_instances(options = {}) ⇒ Object

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)

Raises:



116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/NIFTY/Cloud/instances.rb', line 116

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

#register_corporate_info_for_certificate(options = {}) ⇒ Object

API「RegisterCorporateInfoForCertificate」を実行し、SSL証明書を管理する申請法人情報を登録または更新します。 利用規約（cp.cloud.nifty.com/ssl/trust.txt）をご確認の上、パラメーター「agreement」を指定します。

@option options [Boolean] :agreement       利用規約に同意(必須)
 許可値: true (同意する) | false (同意しない)
@option options [String] :tdb_code         帝国データバンクコード
@option options [String] :corp_name        法人名(必須)
 使用可能文字: 全角
@option options [String] :corp_grade       法人格(必須)
 使用可能文字: 全角
 許可値: 株式会社 | 有限会社 | 社団法人 | 財団法人 | 学校法人 | 医療法人 | 医療法人社団 | 特定非営利活動法人 | 
         有限責任中間法人 | 中央省庁 | 地方公共団体 | 国立大学法人 | 独立行政法人 | 国家資格取得 | 協同組合 | 協同組合連合会 | 
         商工連合会 | 協議会 | 公団 | 公共団体 | その他法人 | その他組合 | その他団体 | その他公共機関
@option options [String] :president_name1  代表者氏名（姓）(必須)
 使用可能文字: 全角
@option options [String] :president_name2  代表者氏名（名）(必須)
 使用可能文字: 全角
@option options [String] :zip1             郵便番号（上3桁）(必須)
 使用可能文字: 半角
@option options [String] :zip2             郵便番号（下4桁）(必須)
 使用可能文字: 半角
@option options [String] :pref             都道府県名(必須)
 使用可能文字: 全角
 許可値: 北海道 | 青森県 | 岩手県 | 宮城県 | 秋田県 | 山形県 | 福島県 | 茨城県 | 栃木県 | 群馬県 | 埼玉県 | 千葉県 | 
         東京都 | 神奈川県 | 新潟県 | 富山県 | 石川県 | 福井県 | 山梨県 | 長野県 | 岐阜県 | 静岡県 | 愛知県 | 三重県 | 
         滋賀県 | 京都府 | 大阪府| 兵庫県 | 奈良県 | 和歌山県 | 鳥取県 | 島根県 |岡山県 | 広島県 | 山口県 | 徳島県 | 
         香川県 | 愛媛県 | 高知県 | 福岡県 | 佐賀県 | 長崎県 | 熊本県 | 大分県 | 宮崎県 | 鹿児島県 | 沖縄県      
@option options [String] :city             市町村名
 使用可能文字: 全角
@option options [String] :name1            責任者氏名（姓）(必須)
 使用可能文字: 全角
@option options [String] :name2            責任者氏名（名）(必須)
 使用可能文字: 全角
@option options [String] :kana_name1       責任者氏名かな（姓）(必須)
 使用可能文字: 全角
@option options [String] :kana_name2       責任者氏名かな（名）(必須)
 使用可能文字: 全角
@option options [String] :post_name        役職名(必須)
 使用可能文字: 全角
@option options [String] :division_name    部署名(必須)
 使用可能文字: 全角
@return [Hash] レスポンスXML解析結果

@example
 register_corporate_info_for_certificate(:agreement => true, :corp_name => 'ニフティ', :corp_grade => '株式会社', :president_name1 => 'ニフティ', 
                                         :president_name2 => '太郎', :zip1 => 140, :zip2 => 8544, :pref => '東京都', :city => '品川区',
                                         :name1 => '山田', :name2 => '花子', :kana_name1 => 'やまだ', :kana_name2 => 'はなこ', :post_name => '部長', 
                                         :division_name => '技術部')

Raises:



230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
 
# File 'lib/NIFTY/Cloud/certificates.rb', line 230

def register_corporate_info_for_certificate( options={} )
  raise ArgumentError, "No :agreement provided." if blank?(options[:agreement])
  raise ArgumentError, "Invalid :agreement provided." unless blank?(options[:agreement]) || BOOLEAN.include?(options[:agreement].to_s)
  raise ArgumentError, "No :corp_name provided." if blank?(options[:corp_name])
  raise ArgumentError, "No :corp_grade provided." if blank?(options[:corp_grade])
  raise ArgumentError, "No :president_name1 provided." if blank?(options[:president_name1])
  raise ArgumentError, "No :president_name2 provided." if blank?(options[:president_name2])
  raise ArgumentError, "No :zip1 provided." if blank?(options[:zip1])
  raise ArgumentError, "Invalid :zip1 provided." unless /^\d{3}$/ =~ options[:zip1].to_s
  raise ArgumentError, "No :zip2 provided." if blank?(options[:zip2])
  raise ArgumentError, "Invalid :zip2 provided." unless /^\d{4}$/ =~ options[:zip2].to_s
  raise ArgumentError, "No :pref provided." if blank?(options[:pref])
  raise ArgumentError, "No :city provided." if blank?(options[:city])
  raise ArgumentError, "No :name1 provided." if blank?(options[:name1])
  raise ArgumentError, "No :name2 provided." if blank?(options[:name2])
  raise ArgumentError, "No :kana_name1 provided." if blank?(options[:kana_name1])
  raise ArgumentError, "No :kana_name2 provided." if blank?(options[:kana_name2])
  raise ArgumentError, "No :post_name provided." if blank?(options[:post_name])
  raise ArgumentError, "No :division_name provided." if blank?(options[:division_name])

  params = {'Action' => 'RegisterCorporateInfoForCertificate'}
  params.merge!(opts_to_prms(options, 
                             [:agreement, :tdb_code, :corp_name, :corp_grade, :president_name1, :president_name2, 
                               :zip1, :zip2, :pref, :city, :name1, :name2, :kana_name1, :kana_name2, :post_name, :division_name]))

  return response_generator(params)
end

#register_instances_with_load_balancer(options = {}) ⇒ Object

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'])

Raises:



261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/NIFTY/Cloud/load_balancers.rb', line 261

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

#register_instances_with_security_group(options = {}) ⇒ Object

API「RegisterInstancesWithSecurityGroup」を実行し、指定したファイアウォールグループを、指定したサーバーへ適用します。 ファイアウォールグループを指定するためには、ファイアウォールグループ名が必要です。削除済みのファイアウォールグループを指定した、 管理外のファイアウォールグループを指定したなど、無効なファイアウォールグループを指定した場合は、エラーが返されます。 またサーバーを指定するためには、サーバー名が必要です。すでにファイアウォールグループに適用されているサーバーを指定した、 削除済みのサーバーを指定した、管理外のサーバーを指定したなど、無効なサーバーを指定した場合は、エラーが返されます。

@option options [String] :group_name           ファイアウォールグループ名(必須)
@option options [Array<String>] :instance_id   サーバー名(必須)
@return [Hash] レスポンスXML解析結果

@example
 register_instances_with_security_group(:group_name => 'group01', :instance_id => ['server02', 'server03'])

Raises:



249
250
251
252
253
254
255
256
257
258
259
260
261
 
# File 'lib/NIFTY/Cloud/security_groups.rb', line 249

def register_instances_with_security_group( options={} )
  raise ArgumentError, "No :group_name provided." if blank?(options[:group_name])
  raise ArgumentError, "Invalid :group_name provided." unless GROUP_NAME =~ options[:group_name].to_s
  raise ArgumentError, "No :instance_id provided." if blank?(options[:instance_id])

  params = { 
    'Action'    => 'RegisterInstancesWithSecurityGroup',
    'GroupName' => options[:group_name]
  }
  params.merge!(pathlist('InstanceId', options[:instance_id]))

  return response_generator(params)
end

#register_port_with_load_balancer(options = {}) ⇒ Object

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})

Raises:



300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
 
# File 'lib/NIFTY/Cloud/load_balancers.rb', line 300

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

#revoke_security_group_ingress(options = {}) ⇒ Object

API「RevokeSecurityGroupIngress」を実行し、指定したファイアウォールグループから許可ルールを削除します。 ファイアウォールグループを指定するためには、ファイアウォールグループ名が必要です。削除済みのファイアウォールグループを指定した、 管理外のファイアウォールグループを指定したなど、無効なファイアウォールグループを指定した場合は、エラーが返されます。 また許可ルールを指定するためには、設定されている 許可プロトコル名・許可ポート・許可するファイアウォールグループまたは許可するIPアドレスが必要です。 該当する許可ルールが存在しない場合は、エラーが返されます。

@option options [String] :group_name           対象のファイアウォールグループ名(必須)
@option options [Array<Hash>] :ip_permissions  IP許可設定
 <Hash> options  [String] :protocol             - 許可プロトコル名
                  許可値: TCP | UDP | ICMP | SSH | HTTP | HTTPS
                 [Integer] :from_port           - 許可ポート(:protocolがTCP、UDPの場合は必須)
                 [String] :in_out               - Incoming/Outgoing 指定
                  許可値: IN(Incoming) | OUT(Outgoing) 
                 [Array<String>] :group_name    - 許可するファイアウォールグループ名(:cidr_ipとどちらか必須)
                 [Array<String>] :cidr_ip       - 許可するIP アドレス(CIDR指定可) (:group_nameとどちらか必須)
@return [Hash] レスポンスXML解析結果

@example
 revoke_security_group_ingress(:group_name => 'gr1', :ip_permissions => [{:protocol => 'TCP',
                                                                          :from_port => 80,
                                                                          :in_out => 'IN',
                                                                          :group_name => ['gr1', 'gr2'],
                                                                          :cidr_ip => ['111.171.200.1/22', '111.111.111.112']} ])

Raises:



288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
 
# File 'lib/NIFTY/Cloud/security_groups.rb', line 288

def revoke_security_group_ingress( options={} )
  raise ArgumentError, "No :group_name provided." if blank?(options[:group_name])
  raise ArgumentError, "Invalid :group_name provided." unless GROUP_NAME =~ options[:group_name].to_s
  raise ArgumentError, "No :ip_permissions provided." if blank?(options[:ip_permissions])
  [options[:ip_permissions]].flatten.each do |opt|
    raise ArgumentError, "expected each element of arr_of_hashes to be a Hash" unless opt.is_a?(Hash)
    raise ArgumentError, "Invalid :ip_protocol provided." unless blank?(opt[:ip_protocol]) || IP_PROTOCOL.include?(opt[:ip_protocol].to_s.upcase)
    raise ArgumentError, "No :from_port provided." if /TCP|UDP/ =~ opt[:ip_protocol] && blank?(opt[:from_port])
    raise ArgumentError, "Invalid :from_port provided." unless blank?(opt[:from_port]) || valid_port?(opt[:from_port])
    raise ArgumentError, "Invalid :to_port provided." unless blank?(opt[:to_port]) || valid_port?(opt[:to_port])
    raise ArgumentError, "Invalid :in_out provided." unless blank?(opt[:in_out]) || IN_OUT.include?(opt[:in_out].to_s.upcase)
    raise ArgumentError, ":group_name or :cidr_ip must be provided." if blank?(opt[:group_name]) && blank?(opt[:cidr_ip])
    raise ArgumentError, "Invalid :group_name provided." unless blank?(opt[:group_name]) || GROUP_NAME =~ opt[:group_name].to_s
    [opt[:cidr_ip]].flatten.each do |ip|
      begin IPAddr.new(ip.to_s) rescue raise ArgumentError, "Invalid :cidr_ip provided." end
    end unless blank?(opt[:cidr_ip])

    opt[:user_id] = [opt[:user_id]].flatten unless blank?(opt[:user_id])
    opt[:group_name] = [opt[:group_name]].flatten unless blank?(opt[:group_name])
    opt[:cidr_ip] = [opt[:cidr_ip]].flatten unless blank?(opt[:cidr_ip])
  end unless blank?(options[:ip_permissions])

  params = {'Action' => 'RevokeSecurityGroupIngress'}
  params.merge!(opts_to_prms(options, [:user_id, :group_name]))
  unless blank?(options[:ip_permissions])
    params.merge!(pathhashlist('IpPermissions', [options[:ip_permissions]].flatten, 
                               { :ip_protocol  => 'IpProtocol',
                                 :from_port    => 'FromPort',
                                 :to_port      => 'ToPort',
                                 :in_out       => 'InOut', 
                                 :user_id => 'Groups', 
                                 :group_name => 'Groups', 
                                 :cidr_ip => 'IpRanges'}, 
                                 { :user_id => 'UserId', 
                                   :group_name => 'GroupName', 
                                   :cidr_ip => 'CidrIp'}))
  end

  params.reject! {|k, v| SECURITY_GROUPS_IGNORED_PARAMS =~ k } if @@ignore_amz_params

  return response_generator(params)
end

#run_instances(options = {}) ⇒ Object

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')

Raises:



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/NIFTY/Cloud/instances.rb', line 157

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

#set_filter_for_load_balancer(options = {}) ⇒ Object

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)

Raises:



349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
 
# File 'lib/NIFTY/Cloud/load_balancers.rb', line 349

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

#start_instances(options = {}) ⇒ Object

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)

Raises:



212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/NIFTY/Cloud/instances.rb', line 212

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

#stop_instances(options = {}) ⇒ Object

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)

Raises:



246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/NIFTY/Cloud/instances.rb', line 246

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

#terminate_instances(options = {}) ⇒ Object

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'])

Raises:



273
274
275
276
277
278
279
280
 
# File 'lib/NIFTY/Cloud/instances.rb', line 273

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

#update_load_balancer(options = {}) ⇒ Object

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)

Raises:



395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
 
# File 'lib/NIFTY/Cloud/load_balancers.rb', line 395

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

#update_security_group(options = {}) ⇒ Object

API「UpdateSecurityGroup」を実行し、ファイアウォールグループの設定情報を更新します。 ファイアウォールグループを指定するためには、ファイアウォールグループ名が必要です。削除済みのファイアウォールグループを指定した、 管理外のファイアウォールグループを指定したなど、無効なファイアウォールグループを指定した場合は、エラーが返されます。

@option options [String] :group_name                 ファイアウォールグループ名(必須)
@option options [String] :group_name_update          ファイアウォールグループ名の変更
@option options [String] :group_description_update   ファイアウォールグループのメモの変更
@return [Hash] レスポンスXML解析結果

@example
 update_security_group(:group_name => 'group01', :group_name_update => 'group02', :group_description_update => 'Security Group memo.Updated.')

Raises:



344
345
346
347
348
349
350
351
352
353
 
# File 'lib/NIFTY/Cloud/security_groups.rb', line 344

def update_security_group( options={} )
  raise ArgumentError, "No :group_name provided." if blank?(options[:group_name])
  raise ArgumentError, "Invalid :group_name provided." unless GROUP_NAME =~ options[:group_name].to_s
  raise ArgumentError, "Invalid :group_name_update provided." unless blank?(options[:group_name_update]) || ALPHANUMERIC =~ options[:group_name_update].to_s

  params = {'Action' => 'UpdateSecurityGroup'}
  params.merge!(opts_to_prms(options, [:group_name, :group_name_update, :group_description_update]))

  return response_generator(params)
end

#upload_ssl_certificate(options = {}) ⇒ Object

API「UploadSslCertificate」を実行し、指定したSSL証明書をアップロードします。 1回のリクエストで、SSL証明書のキー・CA・証明書の1 セットをアップロードできます。 作成可能なSSL証明書の上限数を超える場合は、エラーが返されます。 またアップロードしたファイルの解析に失敗した場合は、エラーが返されます。

@option options [String] :certificate  証明書ファイル(必須)
@option options [String] :key          秘密鍵ファイル(必須)
@option options [String] :ca           CA（認証局）ファイル
@return [Hash] レスポンスXML解析結果

@example
 upload_ssl_certificate(:certificate => 'xxxxxxxxxxxxxxxxxxxxxx', :key => 'xxxxxxxxxxx')

Raises:



272
273
274
275
276
277
278
279
280
 
# File 'lib/NIFTY/Cloud/certificates.rb', line 272

def upload_ssl_certificate( options={} )
  raise ArgumentError, "No :certificate provided." if blank?(options[:certificate])
  raise ArgumentError, "No :key provided." if blank?(options[:key])

  params = {'Action' => 'UploadSslCertificate'}
  params.merge!(opts_to_prms(options, [:certificate, :key, :ca]))

  return response_generator(params)
end