class Fog::AWS::Compute::Servers

Public Class Methods

new(attributes) click to toggle source
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
>
Calls superclass method
# File lib/fog/aws/models/compute/servers.rb, line 52
def initialize(attributes)
  self.filters ||= {}
  super
end

Public Instance Methods

all(filters = self.filters) click to toggle source
# File lib/fog/aws/models/compute/servers.rb, line 57
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
bootstrap(new_attributes = {}) click to toggle source
# File lib/fog/aws/models/compute/servers.rb, line 104
def bootstrap(new_attributes = {})
  bootstrap_many(1, 1, new_attributes).first
end
bootstrap_many(min_servers = 1, max_servers = nil, new_attributes = {}) click to toggle source

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.

# File lib/fog/aws/models/compute/servers.rb, line 92
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
create_many(min_servers = 1, max_servers = nil, new_attributes = {}) click to toggle source

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.

# File lib/fog/aws/models/compute/servers.rb, line 79
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
get(server_id) click to toggle source
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
>
# File lib/fog/aws/models/compute/servers.rb, line 149
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
save_many(template, min_servers = 1, max_servers = nil) click to toggle source

From a template, create between m-n servers (see the AWS RunInstances API)

# File lib/fog/aws/models/compute/servers.rb, line 158
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 Instance Methods

_setup_bootstrap(server) click to toggle source
# File lib/fog/aws/models/compute/servers.rb, line 182
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