kontena-cli 0.14.7 → 0.15.0.rc1

data/lib/kontena/machine/upcloud/master_provisioner.rb

@@ -1,138 +0,0 @@
-require 'fileutils'
-require 'erb'
-require 'open3'
-require 'shell-spinner'
-
-module Kontena
-  module Machine
-    module Upcloud
-      class MasterProvisioner
-        include RandomName
-        include Machine::CertHelper
-        include UpcloudCommon
-
-        attr_reader :http_client, :username, :password
-
-        # @param [String] token Upcloud token
-        def initialize(upcloud_username, upcloud_password)
-          @username = upcloud_username
-          @password = upcloud_password
-        end
-
-        def run!(opts)
-          if File.readable?(File.expand_path(opts[:ssh_key]))
-            ssh_key = File.read(File.expand_path(opts[:ssh_key])).strip
-          end
-
-          abort('Invalid ssh key') unless ssh_key && ssh_key.start_with?('ssh-')
-
-          if opts[:ssl_cert]
-            abort('Invalid ssl cert') unless File.exists?(File.expand_path(opts[:ssl_cert]))
-            ssl_cert = File.read(File.expand_path(opts[:ssl_cert]))
-          else
-            ShellSpinner "Generating self-signed SSL certificate" do
-              ssl_cert = generate_self_signed_cert
-            end
-          end
-
-          abort_unless_api_access
-
-          abort('CoreOS template not found on Upcloud') unless coreos_template = find_template('CoreOS Stable')
-          abort('Server plan not found on Upcloud') unless plan = find_plan(opts[:plan])
-          abort('Zone not found on Upcloud') unless zone_exist?(opts[:zone])
-
-          hostname = generate_name
-
-          userdata_vars = {
-              ssl_cert: ssl_cert,
-              auth_server: opts[:auth_server],
-              version: opts[:version],
-              vault_secret: opts[:vault_secret],
-              vault_iv: opts[:vault_iv],
-              mongodb_uri: opts[:mongodb_uri]
-          }
-
-          device_data = {
-            server: {
-              zone: opts[:zone],
-              title: "Kontena Master #{hostname}",
-              hostname: hostname,
-              plan: plan[:name],
-              vnc: 'off',
-              timezone: 'UTC',
-              user_data: user_data(userdata_vars),
-              firewall: 'off',
-              storage_devices: {
-                storage_device: [
-                  {
-                    action: 'clone',
-                    storage: coreos_template[:uuid],
-                    title: "From template #{coreos_template[:title]}",
-                    size: plan[:storage_size],
-                    tier: 'maxiops'
-                  }
-                ]
-              },
-              login_user: {
-                create_password: 'no',
-                username: 'root',
-                ssh_keys: {
-                  ssh_key: [ssh_key]
-                }
-              }
-            }
-          }.to_json
-
-          ShellSpinner "Creating Upcloud master #{hostname.colorize(:cyan)} " do
-            response = post('server', body: device_data)
-            if response.has_key?(:error)
-              abort("\nUpcloud server creation failed (#{response[:error].fetch(:error_message, '')})")
-            end
-            device_data = response[:server]
-
-            until device_data && device_data.fetch(:state, nil).to_s == 'maintenance'
-              device_data = get("server/#{device[:uuid]}").fetch(:server, {}) rescue nil
-              sleep 5
-            end
-          end
-
-          device_public_ip = device_data[:ip_addresses][:ip_address].find do |ip|
-            ip[:access].eql?('public') && ip[:family].eql?('IPv4')
-          end
-
-          abort('Server public ip not found, destroy manually.') unless device_public_ip
-
-          master_url = "https://#{device_public_ip[:address]}"
-          Excon.defaults[:ssl_verify_peer] = false
-          @http_client = Excon.new("#{master_url}", :connect_timeout => 10)
-
-          ShellSpinner "Waiting for #{hostname.colorize(:cyan)} to start" do
-            sleep 5 until master_running?
-          end
-
-          puts "Kontena Master is now running at #{master_url}"
-          puts "Use #{"kontena login --name=#{hostname.sub('kontena-master-', '')} #{master_url}".colorize(:light_black)} to complete Kontena Master setup"
-        end
-
-        def user_data(vars)
-          cloudinit_template = File.join(__dir__ , '/cloudinit_master.yml')
-          erb(File.read(cloudinit_template), vars)
-        end
-
-        def generate_name
-          "kontena-master-#{super}-#{rand(1..9)}"
-        end
-
-        def master_running?
-          http_client.get(path: '/').status == 200
-        rescue
-          false
-        end
-
-        def erb(template, vars)
-          ERB.new(template, nil, '%<>-').result(OpenStruct.new(vars).instance_eval { binding })
-        end
-      end
-    end
-  end
-end

data/lib/kontena/machine/upcloud/node_destroyer.rb

@@ -1,85 +0,0 @@
-require 'shell-spinner'
-
-module Kontena
-  module Machine
-    module Upcloud
-      class NodeDestroyer
-        include RandomName
-        include UpcloudCommon
-
-        attr_reader :api_client, :username, :password
-
-        # @param [Kontena::Client] api_client Kontena api client
-        # @param [String] token Upcloud token
-        def initialize(api_client, upcloud_username, upcloud_password)
-          @api_client = api_client
-          @username = upcloud_username
-          @password = upcloud_password
-        end
-
-        def run!(grid, name)
-
-          abort_unless_api_access
-
-          servers = get('server')
-          unless servers && servers.has_key?(:servers)
-            abort('Upcloud API error')
-          end
-
-          server = servers[:servers][:server].find{|s| s[:hostname] == name}
-            
-          abort "Cannot find node #{name.colorize(:cyan)} in Upcloud" unless server
-
-          server_data = get("server/#{server[:uuid]}")
-
-          storage_devices = server_data.fetch(:server, {}).fetch(:storage_devices, {}).fetch(:storage_device, [])
-          storage_uuids = storage_devices.map{|s| s[:storage]}
-
-          abort('No storage devices found for Upcloud node') if storage_uuids.empty?
-
-          if server
-            unless server[:state].eql?('stopped')
-              ShellSpinner "Shutting down Upcloud node #{name.colorize(:cyan)} " do
-                device_data = post(
-                  "server/#{server[:uuid]}/stop", body: {
-                    stop_server: {
-                      stop_type: 'soft',
-                      timeout: 120
-                    }
-                  }.to_json
-                )
-
-                until device_data && device_data.fetch(:state, nil).to_s.eql?('stopped')
-                  device_data = get("server/#{server[:uuid]}").fetch(:server, {}) rescue nil
-                  sleep 5
-                end
-              end
-            end
-
-            ShellSpinner "Terminating Upcloud node #{name.colorize(:cyan)} " do
-              response = delete("server/#{server[:uuid]}")
-              abort "Cannot delete node #{name.colorize(:cyan)} in Upcloud" unless response[:success]
-            end
-
-            storage_uuids.each do |uuid|
-              ShellSpinner "Deleting Upcloud storage device '#{uuid.colorize(:cyan)}' " do
-                response = delete("storage/#{uuid}")
-                unless response[:success]
-                  puts "#{"WARNING".colorize(:red)}: Couldn't delete Upcloud storage '#{uuid.colorize(:cyan)}', check manually."
-                end
-              end
-            end
-          else
-            abort "Cannot find node #{name.colorize(:cyan)} in Upcloud"
-          end
-          node = api_client.get("grids/#{grid['id']}/nodes")['nodes'].find{|n| n['name'] == name}
-          if node
-            ShellSpinner "Removing node #{name.colorize(:cyan)} from grid #{grid['name'].colorize(:cyan)} " do
-              api_client.delete("grids/#{grid['id']}/nodes/#{name}")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/kontena/machine/upcloud/node_provisioner.rb

@@ -1,121 +0,0 @@
-require 'fileutils'
-require 'erb'
-require 'open3'
-require 'shell-spinner'
-
-module Kontena
-  module Machine
-    module Upcloud
-      class NodeProvisioner
-        include RandomName
-        include UpcloudCommon
-
-        attr_reader :api_client, :username, :password
-
-        # @param [Kontena::Client] api_client Kontena api client
-        # @param [String] upcloud_username Upcloud username
-        # @param [String] upcloud_password Upcloud password
-        def initialize(api_client, upcloud_username, upcloud_password)
-          @api_client = api_client
-          @username = upcloud_username
-          @password = upcloud_password
-        end
-
-        def run!(opts)
-          if File.readable?(File.expand_path(opts[:ssh_key]))
-            ssh_key = File.read(File.expand_path(opts[:ssh_key])).strip
-          end
-
-          abort('Invalid ssh key') unless ssh_key && ssh_key.start_with?('ssh-')
-
-          userdata_vars = {
-            version: opts[:version],
-            master_uri: opts[:master_uri],
-            grid_token: opts[:grid_token],
-          }
-
-          abort_unless_api_access
-          
-          abort('CoreOS template not found on Upcloud') unless coreos_template = find_template('CoreOS Stable')
-          abort('Server plan not found on Upcloud') unless plan = find_plan(opts[:plan])
-          abort('Zone not found on Upcloud') unless zone_exist?(opts[:zone])
-
-          hostname = generate_name
-
-          device_data = {
-            server: {
-              zone: opts[:zone],
-              title: "Kontena Grid #{opts[:grid]} Node #{hostname}",
-              hostname: hostname,
-              plan: plan[:name],
-              vnc: 'off',
-              timezone: 'UTC',
-              user_data: user_data(userdata_vars),
-              firewall: 'off',
-              storage_devices: {
-                storage_device: [
-                  {
-                    action: 'clone',
-                    storage: coreos_template[:uuid],
-                    title: "From template #{coreos_template[:title]}",
-                    size: plan[:storage_size],
-                    tier: 'maxiops'
-                  }
-                ]
-              },
-              login_user: {
-                create_password: 'no',
-                username: 'root',
-                ssh_keys: {
-                  ssh_key: [ssh_key]
-                }
-              }
-            }
-          }.to_json
-
-          ShellSpinner "Creating Upcloud node #{hostname.colorize(:cyan)} " do
-            response = post('server', body: device_data)
-
-            if response.has_key?(:error)
-              abort("\nUpcloud server creation failed (#{response[:error].fetch(:error_message, '')})")
-            end
-            device_data = response[:server]
-
-            until device_data && device_data.fetch(:state, nil).to_s == 'maintenance'
-              device_data = get("server/#{device[:uuid]}").fetch(:server, {}) rescue nil
-              sleep 5
-            end
-          end
-
-          node = nil
-          ShellSpinner "Waiting for node #{hostname.colorize(:cyan)} join to grid #{opts[:grid].colorize(:cyan)} " do
-            sleep 2 until node = node_exists_in_grid?(opts[:grid], hostname)
-          end
-          set_labels(node, ["region=#{opts[:zone]}", "provider=upcloud"])
-        end
-
-        def user_data(vars)
-          cloudinit_template = File.join(__dir__ , '/cloudinit.yml')
-          erb(File.read(cloudinit_template), vars)
-        end
-
-        def generate_name
-          "#{super}-#{rand(1..99)}"
-        end
-
-        def node_exists_in_grid?(grid, hostname)
-          api_client.get("grids/#{grid}/nodes")['nodes'].find{|n| n['name'] == hostname}
-        end
-
-        def erb(template, vars)
-          ERB.new(template).result(OpenStruct.new(vars).instance_eval { binding })
-        end
-
-        def set_labels(node, labels)
-          data = {labels: labels}
-          api_client.put("nodes/#{node['id']}", data, {}, {'Kontena-Grid-Token' => node['grid']['token']})
-        end
-      end
-    end
-  end
-end

data/lib/kontena/machine/upcloud/node_restarter.rb

@@ -1,49 +0,0 @@
-require 'shell-spinner'
-
-module Kontena
-  module Machine
-    module Upcloud
-      class NodeRestarter
-        include RandomName
-        include UpcloudCommon
-
-        attr_reader :username, :password
-
-        # @param [String] upcloud_username Upcloud username
-        # @param [String] upcloud_password Upcloud password
-        def initialize(upcloud_username, upcloud_password)
-          @username = upcloud_username
-          @password = upcloud_password
-        end
-
-        def run!(name)
-          abort_unless_api_access
-
-          servers = get('server')
-          unless servers && servers.has_key?(:servers)
-            abort('Upcloud API error')
-          end
-
-          server = servers[:servers][:server].find{|s| s[:hostname] == name}
-
-          if server
-            ShellSpinner "Restarting Upcloud node #{name.colorize(:cyan)} " do
-              result = post(
-                "server/#{server[:uuid]}/restart", body: {
-                  restart_server: {
-                    stop_type: 'soft',
-                    timeout: 600,
-                    timeout_action: 'ignore'
-                  }
-                }.to_json
-              )
-            end
-          else
-            abort "Cannot find node #{name.colorize(:cyan)} in Upcloud"
-          end
-        end
-      end
-    end
-  end
-end
-

data/lib/kontena/machine/upcloud/upcloud_common.rb

@@ -1,74 +0,0 @@
-require 'excon'
-require 'json'
-
-module Kontena
-  module Machine
-    module Upcloud
-      module UpcloudCommon
-
-        attr_reader :username
-        attr_reader :password
-        
-        def client
-          @client ||= Excon.new(
-            'https://api.upcloud.com',
-            omit_default_port: true,
-            user: username,
-            password: password,
-            headers: { "Accept-Encoding" => 'application/json' }
-          )
-        end
-
-        def find_template(name)
-          get('storage/template')[:storages][:storage].find{|s| s[:title].downcase.start_with?(name.downcase)}
-        end
-        
-        def find_plan(name)
-          get('plan')[:plans][:plan].find{|s| s[:name].downcase.eql?(name.downcase)}
-        end
-
-        def zone_exist?(name)
-          get('zone')[:zones][:zone].map{|p| p[:id]}.include?(name)
-        end
-
-        def get_server(id)
-          get("server/#{id}").fetch(:server, nil)
-        end
-
-        def api_access?
-          response = get('account')
-          response.kind_of?(Hash) && response.has_key?(:account)
-        rescue
-          false
-        end
-
-        def abort_unless_api_access
-          unless api_access?
-            abort('Upcloud API authentication failed. Check that API access is enabled for the user.')
-          end
-        end
-
-        [:get, :post, :delete].each do |http_method|
-          define_method http_method do |path, opts={}|
-            response = client.send(
-              http_method, 
-              opts.merge(
-                path: File.join('/1.2', path),
-                headers: {
-                  'Content-Type': 'application/json'
-                }
-              )
-            )
-            if response.body && response.body.start_with?('{')
-              JSON.parse(response.body, symbolize_names: true)
-            elsif response.status.to_s.start_with?('2')
-              {success: true}
-            else
-              {error: response.status}
-            end
-          end
-        end
-      end
-    end
-  end
-end