lib/fog/aws/models/compute/servers.rb
require 'fog/aws/models/compute/server'
module Fog
module AWS
class Compute
class Servers < Fog::Collection
attribute :filters
model Fog::AWS::Compute::Server
# Creates a new server
#
# AWS.servers.new
#
# ==== Returns
#
# Returns the details of the new server
#
#>> AWS.servers.new
# <Fog::AWS::Compute::Server
# id=nil,
# ami_launch_index=nil,
# availability_zone=nil,
# block_device_mapping=nil,
# hibernation_options=nil,
# network_interfaces=nil,
# client_token=nil,
# dns_name=nil,
# groups=["default"],
# flavor_id="m1.small",
# image_id=nil,
# ip_address=nil,
# kernel_id=nil,
# key_name=nil,
# created_at=nil,
# monitoring=nil,
# product_codes=nil,
# private_dns_name=nil,
# private_ip_address=nil,
# ramdisk_id=nil,
# reason=nil,
# root_device_name=nil,
# root_device_type=nil,
# state=nil,
# state_reason=nil,
# subnet_id=nil,
# tags=nil,
# user_data=nil
# >
#
def initialize(attributes)
self.filters ||= {}
super
end
def all(filters = self.filters)
unless filters.is_a?(Hash)
Fog::Logger.deprecation("all with #{filters.class} param is deprecated, use all('instance-id' => []) instead [light_black](#{caller.first})[/]")
filters = {'instance-id' => [*filters]}
end
self.filters = filters
data = service.describe_instances(filters).body
load(
data['reservationSet'].map do |reservation|
reservation['instancesSet'].map do |instance|
instance.merge(:groups => reservation['groupSet'], :security_group_ids => reservation['groupIds'])
end
end.flatten
)
end
# Create between m and n servers with the server options specified in
# new_attributes. Equivalent to this loop, but happens in 1 request:
#
# 1.upto(n).map { create(new_attributes) }
#
# See the AWS RunInstances API.
def create_many(min_servers = 1, max_servers = nil, new_attributes = {})
max_servers ||= min_servers
template = new(new_attributes)
save_many(template, min_servers, max_servers)
end
# Bootstrap between m and n servers with the server options specified in
# new_attributes. Equivalent to this loop, but happens in 1 AWS request
# and the machines' spinup will happen in parallel:
#
# 1.upto(n).map { bootstrap(new_attributes) }
#
# See the AWS RunInstances API.
def bootstrap_many(min_servers = 1, max_servers = nil, new_attributes = {})
template = service.servers.new(new_attributes)
_setup_bootstrap(template)
servers = save_many(template, min_servers, max_servers)
servers.each do |server|
server.wait_for { ready? }
server.setup(:key_data => [server.private_key])
end
servers
end
def bootstrap(new_attributes = {})
bootstrap_many(1, 1, new_attributes).first
end
# Used to retrieve a server
#
# server_id is required to get the associated server information.
#
# You can run the following command to get the details:
# AWS.servers.get("i-5c973972")
#
# ==== Returns
#
#>> AWS.servers.get("i-5c973972")
# <Fog::AWS::Compute::Server
# id="i-5c973972",
# ami_launch_index=0,
# availability_zone="us-east-1b",
# block_device_mapping=[],
# hibernation_options=[],
# client_token=nil,
# dns_name="ec2-25-2-474-44.compute-1.amazonaws.com",
# groups=["default"],
# flavor_id="m1.small",
# image_id="test",
# ip_address="25.2.474.44",
# kernel_id="aki-4e1e1da7",
# key_name=nil,
# created_at=Mon Nov 29 18:09:34 -0500 2010,
# monitoring=false,
# product_codes=[],
# private_dns_name="ip-19-76-384-60.ec2.internal",
# private_ip_address="19.76.384.60",
# ramdisk_id="ari-0b3fff5c",
# reason=nil,
# root_device_name=nil,
# root_device_type="instance-store",
# state="running",
# state_reason={},
# subnet_id=nil,
# tags={},
# user_data=nil
# >
#
def get(server_id)
if server_id
self.class.new(:service => service).all('instance-id' => server_id).first
end
rescue Fog::Errors::NotFound
nil
end
# From a template, create between m-n servers (see the AWS RunInstances API)
def save_many(template, min_servers = 1, max_servers = nil)
max_servers ||= min_servers
data = service.run_instances(template.image_id, min_servers, max_servers, template.run_instance_options)
# For some reason, AWS sometimes returns empty results alongside the real ones. Thus the select
data.body['instancesSet'].select { |instance_set| instance_set['instanceId'] }.map do |instance_set|
server = template.dup
server.merge_attributes(instance_set)
# expect eventual consistency
if (tags = server.tags) && tags.size > 0
Fog.wait_for { server.reload rescue nil }
Fog.wait_for {
begin
service.create_tags(server.identity, tags)
rescue Fog::AWS::Compute::NotFound
false
end
}
end
server
end
end
private
def _setup_bootstrap(server)
unless server.key_name
# first or create fog_#{credential} keypair
name = Fog.respond_to?(:credential) && Fog.credential || :default
unless server.key_pair = service.key_pairs.get("fog_#{name}")
server.key_pair = service.key_pairs.create(
:name => "fog_#{name}",
:public_key => server.public_key
)
end
end
security_group = service.security_groups.get(server.groups.first)
if security_group.nil?
raise Fog::AWS::Compute::Error, "The security group" \
" #{server.groups.first} doesn't exist."
end
# make sure port 22 is open in the first security group
authorized = security_group.ip_permissions.find do |ip_permission|
ip_permission['ipRanges'].find { |ip_range| ip_range['cidrIp'] == '0.0.0.0/0' } &&
ip_permission['fromPort'] == 22 &&
ip_permission['ipProtocol'] == 'tcp' &&
ip_permission['toPort'] == 22
end
unless authorized
security_group.authorize_port_range(22..22)
end
end
end
end
end
end