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

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

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

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

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

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

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

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 を実行する必要があります。

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

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

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

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

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

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

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

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

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

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

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

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] 


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

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

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

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 


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

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    


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

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     


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

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


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 


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

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

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

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

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

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

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

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

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

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 を実行する必要があります。 API「SetFilterForLoadBalancer」（フィルター設定）

@option options [String] :load_balancer_name

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

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

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

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

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

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

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

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

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

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