Class: Fog::AWS::Compute::Servers

Inherits:
Collection
  • Object
show all
Defined in:
lib/fog/aws/models/compute/servers.rb

Instance Method Summary collapse

Constructor Details

#initialize(attributes) ⇒ Servers

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



52
53
54
55
 
# File 'lib/fog/aws/models/compute/servers.rb', line 52

def initialize(attributes)
  self.filters ||= {}
  super
end

Instance Method Details

#all(filters = self.filters) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# 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 = {}) ⇒ Object 



104
105
106
 
# 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 = {}) ⇒ Object

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.



92
93
94
95
96
97
98
99
100
101
102
 
# 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 = {}) ⇒ Object

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.



79
80
81
82
83
 
# 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) ⇒ Object

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



149
150
151
152
153
154
155
 
# 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) ⇒ Object

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



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# 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