Class: AvstCloud::GcpConnection

Inherits:
CloudConnection show all
Defined in:
lib/avst-cloud/gcp_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, project) ⇒ GcpConnection

Returns a new instance of GcpConnection.



24
25
26
27
28
 
# File 'lib/avst-cloud/gcp_connection.rb', line 24

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

Instance Attribute Details

#region ⇒ Object

Returns the value of attribute region.



22
23
24
 
# File 'lib/avst-cloud/gcp_connection.rb', line 22

def region
  @region
end

Instance Method Details

#create_server(server_name, flavour, os, key_name, ssh_public_key, ssh_private_key, subnet_id, security_group_ids, root_disk_size, root_disk_type, machine_type_id, availability_zone, additional_hdds = {}, vpc = nil, created_by = nil, custom_tags = [], root_username = nil, delete_root_disk = true) ⇒ Object 



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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/avst-cloud/gcp_connection.rb', line 38

def create_server(server_name, flavour, os, key_name, ssh_public_key, ssh_private_key, subnet_id, security_group_ids, root_disk_size, root_disk_type, machine_type_id, availability_zone, additional_hdds={}, vpc=nil, created_by=nil, custom_tags=[], root_username=nil, delete_root_disk=true)
    flavour = flavour || "g1-small"
    os = os || "centos-7"
    vpc_name = vpc || "default"
    subnet_name = subnet_id || "default"
    machine_type_id = machine_type_id || get_image_name(os) 
    if machine_type_id.nil? or machine_type_id.empty?
        machine_type_id = "centos-7-v20190312"
    end

    unless File.file?(ssh_public_key)
        logger.error "Could not find local public SSH key '#{ssh_public_key}'".red
        raise "Could not find local SSH public key '#{ssh_public_key}'"
    end

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

    existing_servers    = all_named_servers(server_name)
    restartable_servers = existing_servers.select{ |serv| serv.status == 'TERMINATED' }
    #TODO, status is a guess, need to work out if "DELETED" is valid for GCP
    running_servers     = existing_servers.select{ |serv| serv.status != 'TERMINATED' && serv.status != 'DELETED' }

    if running_servers.length > 0
        running_servers.each do |server|
            logger.error "Server #{server_name} with id #{server.id} found in state: #{server.status}".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.status}. Can not restart".yellow
            end
            raise "Too many servers can be restarted."
        end
        server = restartable_servers.first
        server.start
        result_server = AvstCloud::GcpServer.new(server, server_name, server.public_ip_address, root_user, ssh_private_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 GCP server:"
        logger.debug "Server name        - #{server_name}"
        logger.debug "Operating system   - #{os}"
        logger.debug "image_template_id  - #{machine_type_id}"
        logger.debug "flavour            - #{flavour}"
        logger.debug "key_name           - #{key_name}"
        logger.debug "Public ssh_key     - #{ssh_public_key}"
        logger.debug "Private ssh_key    - #{ssh_private_key}"
        logger.debug "root user          - #{root_user}"
        logger.debug "subnet_id          - #{subnet_name}"
        logger.debug "security_group_ids - #{security_group_ids}"
        logger.debug "region             - #{@region}"
        logger.debug "availability_zone  - #{availability_zone}"
        logger.debug "root_disk_size     - #{root_disk_size}"
        logger.debug "additional_hdds    - #{additional_hdds}"
        logger.debug "vpc                - #{vpc_name}"

        # Create root disk
        # TODO check if this exists and exit politely, or catch the exception and exit politely
        root_disk_type = root_disk_type || 'pd-standard'
        logger.debug "Creating root disk with type #{root_disk_type}"
        root_disk_url="https://www.googleapis.com/compute/v1/projects/#{@project}/zones/#{availability_zone}/diskTypes/#{root_disk_type}"
        disk = connect.disks.create :name => "#{server_name}-root",
                                    :size_gb => root_disk_size,
                                    :zone => availability_zone,
                                    :source_image => machine_type_id,
                                    :type => root_disk_url
        
        # wait for the disk to be ready
        logger.debug "Waiting for root disk to be ready"
        disk.wait_for { ready? }

        disk_to_attach=[disk.attached_disk_obj(boot: true, auto_delete: delete_root_disk)]

        # create additional HDD's if required
        if additional_hdds and additional_hdds.is_a?(Hash)
            disk_count=1
            additional_hdds.each_value do |disk|
                #TODO wortk out how to set disk type!
                if disk['disk_size'] || disk['ebs_size']
                    disk_type = disk['disk_type'] || 'pd-standard'
                    logger.debug "Creating additional disk #{disk_count} with type #{disk_type}"
                    disk_url="https://www.googleapis.com/compute/v1/projects/#{@project}/zones/#{availability_zone}/diskTypes/#{disk_type}"
                    delete_disk_with_vm = disk['delete_disk_with_vm'] || false
                    additional_disk = connect.disks.create :name => "#{server_name}-disk#{disk_count}",
                                                           :size_gb => disk['disk_size'] || disk['ebs_size'],
                                                           :zone => availability_zone,
                                                           :type => disk_url
                    # wait for additional disk
                    logger.debug "Waiting for additional disk #{disk_count}"
                    additional_disk.wait_for { ready? }

                    # add disk to array of those to be mounted
                    disk_to_attach.push additional_disk.attached_disk_obj(boot: false, auto_delete: delete_disk_with_vm)

                    #blank the additional disk object for the next time around
                    attached_disk = nil

                    # increment disk counter
                    disk_count = disk_count +1
                else
                    logger.warn "Failed to create additional hdd, required param disk_size missing: #{disk}"
                end 
            end 
        end

        ## GCP tags are not key value pairs
        tags = [server_name, os] + custom_tags

        # work out the URK for the subnetwork
        subnet_url = "https://www.googleapis.com/compute/v1/projects/#{@project}/regions/#{region}/subnetworks/#{subnet_name}"

        # create server
        logger.debug "Creating Server"
        server = connect.servers.create :name => server_name,
                                        :disks => disk_to_attach,
                                        :machine_type => flavour,
                                        :private_key_path => ssh_private_key,
                                        :public_key_path => ssh_public_key,
                                        :zone => availability_zone,
                                        :network_interfaces => [{ :network => "global/networks/#{vpc_name}",
                                                                  :subnetwork => subnet_url,
                                                                  :access_configs => [{
                                                                      :name => "External NAT",
                                                                      :type => "ONE_TO_ONE_NAT" }] 
                                                                }],
                                        :username => root_user,
                                        :tags => tags

        result_server = AvstCloud::GcpServer.new(server, server_name, nil, root_user, ssh_private_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_private_key} #{root_user}@#{server.public_ip_address}\n"
        result_server.ip_address = server.public_ip_address
        result_server
    end
end

#find_fog_server(server_name, should_fail = true) ⇒ Object 



228
229
230
231
232
233
234
235
236
237
238
 
# File 'lib/avst-cloud/gcp_connection.rb', line 228

def find_fog_server(server_name, should_fail=true)
    #TODO, status is a guess, need to work out if this is valid for GCP
    servers = all_named_servers(server_name).select{|serv| serv.status != 'DELETED'}
    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_disk_types(availability_zone) ⇒ Object 



219
220
221
 
# File 'lib/avst-cloud/gcp_connection.rb', line 219

def list_disk_types(availability_zone)
    logger.debug connect.list_disk_types(availability_zone)
end

#list_flavours(zone) ⇒ Object 



204
205
206
 
# File 'lib/avst-cloud/gcp_connection.rb', line 204

def list_flavours(zone)
    logger.debug connect.list_machine_types(zone)
end

#list_images ⇒ Object 



208
209
210
211
212
213
 
# File 'lib/avst-cloud/gcp_connection.rb', line 208

def list_images
    # Only list current images, not deprecated ones
    get_images.each do |im|
        logger.debug im.inspect
    end
end

#list_known_servers ⇒ Object

Returns list of servers from fog



224
225
226
 
# File 'lib/avst-cloud/gcp_connection.rb', line 224

def list_known_servers
    connect.servers.all
end

#list_networks ⇒ Object 



215
216
217
 
# File 'lib/avst-cloud/gcp_connection.rb', line 215

def list_networks
    logger.debug connect.list_networks
end

#list_zones ⇒ Object 



200
201
202
 
# File 'lib/avst-cloud/gcp_connection.rb', line 200

def list_zones
    logger.debug connect.list_zones
end

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



30
31
32
33
34
35
36
 
# File 'lib/avst-cloud/gcp_connection.rb', line 30

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_key(os)
    end
    AvstCloud::GcpServer.new(server, server_name, server.public_ip_address, root_user, root_password)
end

#server_status(server_name) ⇒ Object 



188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/avst-cloud/gcp_connection.rb', line 188

def server_status(server_name)
    #TODO, status is a guess, need to work out if this is valid for GCP
    servers = all_named_servers(server_name).select{|serv| serv.status != 'DELETED'}
    if servers.length > 0
        servers.each do |server|
            logger.debug "Server #{server.id} with name '#{server_name}' exists and has state: #{server.status}"
        end
    else
        logger.debug "Server not found for name: #{server_name}"
    end
end