Class: AvstCloud::AwsConnection

Inherits:
CloudConnection show all
Defined in:
lib/avst-cloud/aws_connection.rb

Constant Summary

Constants inherited from CloudConnection

CloudConnection::UNIMPLEMENTED

Instance Attribute Summary collapse

Attributes inherited from CloudConnection

#connection, #provider, #provider_pass, #provider_user

Instance Method Summary collapse

Methods included from Logging

included, logger, #logger, logger=, mask_message, show_passwords=

Constructor Details

#initialize(provider_user, provider_pass, region) ⇒ AwsConnection

Returns a new instance of AwsConnection.



23
24
25
26
 
# File 'lib/avst-cloud/aws_connection.rb', line 23

def initialize(provider_user, provider_pass, region)
    super('aws', provider_user, provider_pass)
    @region = region
end

Instance Attribute Details

#region ⇒ Object

Returns the value of attribute region.



21
22
23
 
# File 'lib/avst-cloud/aws_connection.rb', line 21

def region
  @region
end

Instance Method Details

#create_server(server_name, flavour, os, key_name, ssh_key, subnet_id, security_group_ids, ebs_size, hdd_device_path, ami_image_id, availability_zone, additional_hdds = {}, vpc = nil, created_by = nil, custom_tags = {}, root_username = nil) ⇒ Object 



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
78
79
80
81
82
83
84
85
86
87
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/avst-cloud/aws_connection.rb', line 36

def create_server(server_name, flavour, os, key_name, ssh_key, subnet_id, security_group_ids, ebs_size, hdd_device_path, ami_image_id, availability_zone, additional_hdds={}, vpc=nil, created_by=nil, custom_tags={}, root_username=nil)
    # Permit named instances from DEFAULT_FLAVOURS
    flavour = flavour || "t2.micro"
    os = os || "ubuntu-14"
    ami_image_id = ami_image_id || "ami-f0b11187"
    device_name = hdd_device_path || '/dev/sda1'

    root_user = root_username || user_from_os(os)
    unless File.file?(ssh_key)
        logger.error "Could not find local SSH key '#{ssh_key}'".red
        raise "Could not find local SSH key '#{ssh_key}'"
    end

    existing_servers    = all_named_servers(server_name)
    restartable_servers = existing_servers.select{ |serv| serv.state == 'stopped' }
    running_servers     = existing_servers.select{ |serv| serv.state != 'stopped' && serv.state != 'terminated' }

    if running_servers.length > 0
        running_servers.each do |server|
            logger.error "Server #{server_name} with id #{server.id} found in state: #{server.state}".yellow
        end
        raise "Server with the same name found!"

    elsif restartable_servers.length > 0
        if restartable_servers.length > 1
            running_servers.each do |server|
                logger.error "Server #{server_name} with id #{server.id} found in state: #{server.state}. Can not restart".yellow
            end
            raise "Too many servers can be restarted."
        end
        server = restartable_servers.first
        server.start
        result_server = AvstCloud::AwsServer.new(server, server_name, server.public_ip_address, root_user, ssh_key)
        result_server.wait_for_state() {|serv| serv.ready?}
        logger.debug "[DONE]\n\n"
        logger.debug "The server was successfully re-started.\n\n"
        result_server
    else
        logger.debug "Creating EC2 server:"
        logger.debug "Server name        - #{server_name}"
        logger.debug "Operating system   - #{os}"
        logger.debug "image_template_id  - #{ami_image_id}"
        logger.debug "flavour            - #{flavour}"
        logger.debug "key_name           - #{key_name}"
        logger.debug "ssh_key            - #{ssh_key}"
        logger.debug "root user          - #{root_user}"
        logger.debug "subnet_id          - #{subnet_id}"
        logger.debug "security_group_ids - #{security_group_ids}"
        logger.debug "region             - #{@region}"
        logger.debug "availability_zone  - #{availability_zone}"
        logger.debug "ebs_size           - #{ebs_size}"
        logger.debug "hdd_device_path    - #{device_name}"
        logger.debug "additional_hdds    - #{additional_hdds}"
        logger.debug "vpc                - #{vpc}"

        create_ebs_volume = nil
        if ebs_size
            # in case of centos ami we need to use /dev/xvda this is ami dependent
            create_ebs_volume = [ 
                                    { 
                                        :DeviceName => device_name,
                                        'Ebs.VolumeType' => 'gp2',
                                        'Ebs.VolumeSize' => ebs_size,
                                    } 
                                ]
            if additional_hdds and additional_hdds.is_a?(Hash)
                additional_hdds.each_value do |disk|
                    volume_type = disk['volume_type'] || 'gp2'
                    if disk['device_name'] && disk['ebs_size']
                        create_ebs_volume << { 
                            :DeviceName => disk['device_name'],
                            'Ebs.VolumeType' => volume_type,
                            'Ebs.VolumeSize' => disk['ebs_size']
                        }
                    else
                        logger.warn "Failed to create additional hdd, required params device_name (e.g. /dev/sda1) or ebs_size missing: #{disk}"
                    end 
                end 
            end
        end

        tags = {
            'Name' => server_name,
            'os' => os
        }
        if created_by 
            tags['created_by'] = created_by
        end
        tags.merge!(custom_tags)
        # create server
        server = connect.servers.create :tags => tags,
                                        :flavor_id => flavour,
                                        :image_id => ami_image_id,
                                        :key_name => key_name,
                                        :subnet_id => subnet_id,
                                        :associate_public_ip => true,
                                        :security_group_ids => security_group_ids,
                                        :availability_zone => availability_zone,
                                        :block_device_mapping => create_ebs_volume,
                                        :vpc => vpc

        
        result_server = AvstCloud::AwsServer.new(server, server_name, nil, root_user, ssh_key)
        # result_server.logger = logger
        # Check every 5 seconds to see if server is in the active state (ready?).
        # If the server has not been built in 5 minutes (600 seconds) an exception will be raised.
        result_server.wait_for_state() {|serv| serv.ready?}

        logger.debug "[DONE]\n\n"

        logger.debug "The server has been successfully created, to login onto the server:\n"
        logger.debug "\t ssh -i #{ssh_key} #{root_user}@#{server.public_ip_address}\n"
        if create_ebs_volume
            logger.debug("Creating tags on ebs volumes")
            ebs_volumes = server.block_device_mapping
            logger.debug("Creating tags on ebs volumes #{ebs_volumes}")
            ebs_volumes.each do |ebs_volume|
                if ebs_volume['volumeId']
                    tags.each do |key, value|
                        connect.tags.create(:resource_id => ebs_volume['volumeId'], :key => key, :value => value)
                    end
                end
            end
        end
        result_server.ip_address = server.public_ip_address
        result_server
    end
end

#find_fog_server(server_name, should_fail = true) ⇒ Object 



193
194
195
196
197
198
199
200
201
202
 
# File 'lib/avst-cloud/aws_connection.rb', line 193

def find_fog_server(server_name, should_fail=true)
    servers = all_named_servers(server_name).select{|serv| serv.state != 'terminated'}
    unless servers.length == 1    
        logger.debug "Found #{servers.length} servers for name: #{server_name}".yellow
        if should_fail
            raise "Found #{servers.length} servers for name: #{server_name}"
        end
    end
    servers.first
end

#list_flavours ⇒ Object 



176
177
178
179
180
 
# File 'lib/avst-cloud/aws_connection.rb', line 176

def list_flavours
    connect.flavors.each do |fl|
        logger.debug fl.inspect
    end
end

#list_images ⇒ Object 



182
183
184
185
186
 
# File 'lib/avst-cloud/aws_connection.rb', line 182

def list_images
    connect.images.each do |im|
        logger.debug im.inspect
    end
end

#list_known_servers ⇒ Object

Returns list of servers from fog



189
190
191
 
# File 'lib/avst-cloud/aws_connection.rb', line 189

def list_known_servers
    connect.servers.all
end

#server(server_name, root_user, root_password, os = nil) ⇒ Object 



28
29
30
31
32
33
34
 
# File 'lib/avst-cloud/aws_connection.rb', line 28

def server(server_name, root_user, root_password, os=nil)
    server = find_fog_server(server_name)
    if !root_user and os
        root_user = user_from_os(os)
    end
    AvstCloud::AwsServer.new(server, server_name, server.public_ip_address, root_user, root_password)
end

#server_status(server_name) ⇒ Object 



165
166
167
168
169
170
171
172
173
174
 
# File 'lib/avst-cloud/aws_connection.rb', line 165

def server_status(server_name)
    servers = all_named_servers(server_name).select{|serv| serv.state != 'terminated'}
    if servers.length > 0
        servers.each do |server|
            logger.debug "Server #{server.id} with name '#{server_name}' exists and has state: #{server.state}"
        end
    else
        logger.debug "Server not found for name: #{server_name}"
    end
end