hetzner-bootstrap 1.0.2 → 2.0.0

data/lib/hetzner-bootstrap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'benchmark'
 require 'logger'
 
@@ -8,14 +10,11 @@ require 'hetzner/bootstrap/template'
 
 module Hetzner
   class Bootstrap
-    attr_accessor :targets
-    attr_accessor :api
-    attr_accessor :actions
-    attr_accessor :logger
+    attr_accessor :targets, :api, :actions, :logger
 
     def initialize(options = {})
       @targets     = []
-      @actions     = %w(enable_rescue_mode
+      @actions     = %w[enable_rescue_mode
                         reset
                         wait_for_ssh_down
                         wait_for_ssh_up
@@ -26,48 +25,47 @@ module Hetzner
                         verify_installation
                         copy_ssh_keys
                         update_local_known_hosts
-                        post_install)
+                        post_install
+                        post_install_remote]
       @api         = options[:api]
-      @logger      = options[:logger] || Logger.new(STDOUT)
+      @logger      = options[:logger] || Logger.new($stdout)
     end
 
     def add_target(param)
-      if param.is_a? Hetzner::Bootstrap::Target
-        @targets << param
-      else
-        @targets << (Hetzner::Bootstrap::Target.new param)
-      end
+      @targets << if param.is_a? Hetzner::Bootstrap::Target
+                    param
+                  else
+                    Hetzner::Bootstrap::Target.new(param)
+                  end
     end
 
     def <<(param)
       add_target param
     end
 
-    def bootstrap!(options = {})
+    def bootstrap!(_options = {})
       @targets.each do |target|
-        #fork do
-          target.use_api    @api
-          target.use_logger @logger
-          bootstrap_one_target! target
-        #end
+        # fork do
+        target.use_api @api
+        target.use_logger @logger
+        bootstrap_one_target! target
+        # end
       end
-      #Process.waitall
+      # Process.waitall
     end
 
     def bootstrap_one_target!(target)
       actions = (target.actions || @actions)
-      actions.each_with_index do |action, index|
-
+      actions.each_with_index do |action, _index|
         loghack = "\b" * 24 # remove: "[bootstrap_one_target!] ".length
-        target.logger.info "#{loghack}[#{action}] #{sprintf "%-20s", "START"}"
+        target.logger.info "#{loghack}[#{action}] #{format '%-20s', 'START'}"
         d = Benchmark.realtime do
           target.send action
         end
-        target.logger.info "#{loghack}[#{action}] FINISHED in #{sprintf "%.5f",d} seconds"
+        target.logger.info "#{loghack}[#{action}] FINISHED in #{format '%.5f', d} seconds"
       end
-    rescue => e
+    rescue StandardError => e
       puts "something bad happened unexpectedly: #{e.class} => #{e.message}"
     end
   end
 end
-

data/lib/hetzner/bootstrap/target.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'erubis'
 require 'net/ssh'
 require 'socket'
@@ -6,34 +8,23 @@ require 'timeout'
 module Hetzner
   class Bootstrap
     class Target
-      attr_accessor :ip
-      attr_accessor :login
-      attr_accessor :password
-      attr_accessor :template
-      attr_accessor :rescue_os
-      attr_accessor :rescue_os_bit
-      attr_accessor :actions
-      attr_accessor :hostname
-      attr_accessor :post_install
-      attr_accessor :public_keys
-      attr_accessor :bootstrap_cmd
-      attr_accessor :logger
-      
+      attr_accessor :ip, :login, :password, :template, :rescue_os, :rescue_os_bit, :actions, :hostname, :public_keys, :bootstrap_cmd, :logger
+      attr_writer :post_install, :post_install_remote
+
       def initialize(options = {})
-        @rescue_os     = 'linux'
-        @rescue_os_bit = '64'
-        @retries       = 0
-        @bootstrap_cmd = 'export TERM=xterm; /root/.oldroot/nfs/install/installimage -a -c /tmp/template'
-        @login         = 'root'
-
-        if tmpl = options.delete(:template)
-          @template = Template.new tmpl
-        else
-          raise NoTemplateProvidedError.new 'No imageinstall template provided.'
-        end
+        @rescue_os           = 'linux'
+        @rescue_os_bit       = '64'
+        @retries             = 0
+        @bootstrap_cmd       = 'export TERM=xterm; /root/.oldroot/nfs/install/installimage -a -c /tmp/template'
+        @login               = 'root'
+        @post_install_remote = ''
 
-        options.each_pair do |k,v|
-          self.send("#{k}=", v)
+        @template = Template.new options.delete(:template)
+
+        raise NoTemplateProvidedError 'No imageinstall template provided.' unless @template
+
+        options.each_pair do |k, v|
+          send("#{k}=", v)
         end
       end
 
@@ -45,14 +36,14 @@ module Hetzner
           reset_retries
           logger.info "IP: #{ip} => password: #{@password}"
         elsif @retries > 3
-          logger.error "rescue system could not be activated"
+          logger.error 'rescue system could not be activated'
           raise CantActivateRescueSystemError, result
         else
           @retries += 1
 
           logger.warn "problem while trying to activate rescue system (retries: #{@retries})"
           @api.disable_rescue! @ip
-          
+
           rolling_sleep
           enable_rescue_mode options
         end
@@ -64,7 +55,7 @@ module Hetzner
         if result.success?
           reset_retries
         elsif @retries > 3
-          logger.error "resetting through webservice failed."
+          logger.error 'resetting through webservice failed.'
           raise CantResetSystemError, result
         else
           @retries += 1
@@ -74,93 +65,90 @@ module Hetzner
         end
       end
 
-      def port_open? ip, port
+      def port_open?(ip, port)
         ssh_port_probe = TCPSocket.new ip, port
         IO.select([ssh_port_probe], nil, nil, 2)
         ssh_port_probe.close
         true
       end
 
-      def wait_for_ssh_down(options = {})
+      def wait_for_ssh_down
         loop do
           sleep 2
-          Timeout::timeout(4) do
-            if port_open? @ip, 22
-              logger.debug "SSH UP"
-            else
-              raise Errno::ECONNREFUSED
-            end
+          Timeout.timeout(4) do
+            raise Errno::ECONNREFUSED unless port_open? @ip, 22
+
+            logger.debug 'SSH UP'
           end
         end
       rescue Timeout::Error, Errno::ECONNREFUSED
-        logger.debug "SSH DOWN"
+        logger.debug 'SSH DOWN'
       end
 
-      def wait_for_ssh_up(options = {})
+      def wait_for_ssh_up
         loop do
-          Timeout::timeout(4) do
-            if port_open? @ip, 22
-              logger.debug "SSH UP"
-              return true
-            else
-              raise Errno::ECONNREFUSED
-            end
+          Timeout.timeout(4) do
+            raise Errno::ECONNREFUSED unless port_open? @ip, 22
+
+            logger.debug 'SSH UP'
+            return true
           end
         end
       rescue Errno::ECONNREFUSED, Timeout::Error
-        logger.debug "SSH DOWN"
+        logger.debug 'SSH DOWN'
         sleep 2
         retry
       end
 
-      def installimage(options = {})
+      def installimage
         template = render_template
 
         remote do |ssh|
           ssh.exec! "echo \"#{template}\" > /tmp/template"
           logger.info "remote executing: #{@bootstrap_cmd}"
           output = ssh.exec!(@bootstrap_cmd)
-          logger.info output
+          logger.info output.gsub(`clear`, '')
         end
       end
 
-      def reboot(options = {})
+      def reboot
         remote do |ssh|
-          ssh.exec!("reboot")
+          ssh.exec!('reboot')
         end
+      rescue IOError, Net::SSH::Disconnect
+        logger.debug 'SSH connection was closed as anticipated.'
       end
 
-      def verify_installation(options = {})
+      def verify_installation
         remote do |ssh|
-          working_hostname = ssh.exec!("cat /etc/hostname")
-          unless @hostname == working_hostname.chomp
-            raise InstallationError, "hostnames do not match: assumed #{@hostname} but received #{working_hostname}"
-          end
+          working_hostname = ssh.exec!('cat /etc/hostname')
+          working_hostname.chomp!
+          logger.debug "hostnames do not match: assumed #{@hostname} but received #{working_hostname}" unless @hostname == working_hostname.chomp
         end
       end
 
-      def copy_ssh_keys(options = {})
-        if @public_keys
-          remote do |ssh|
-            ssh.exec!("mkdir /root/.ssh")
-            Array(@public_keys).each do |key|
-              pub = File.read(File.expand_path(key))
-              ssh.exec!("echo \"#{pub}\" >> /root/.ssh/authorized_keys")
-            end
+      def copy_ssh_keys
+        return unless @public_keys
+
+        remote do |ssh|
+          ssh.exec!('mkdir /root/.ssh')
+          Array(@public_keys).each do |key|
+            pub = File.read(File.expand_path(key))
+            ssh.exec!("echo \"#{pub}\" >> /root/.ssh/authorized_keys")
           end
         end
       end
 
-      def update_local_known_hosts(options = {})
-        remote(:paranoid => true) do |ssh|
+      def update_local_known_hosts
+        remote(verify_host_key: :accept_new_or_local_tunnel) do |ssh|
           # dummy
         end
       rescue Net::SSH::HostKeyMismatch => e
         e.remember_host!
-        logger.info "remote host key added to local ~/.ssh/known_hosts file."
+        logger.info 'remote host key added to local ~/.ssh/known_hosts file.'
       end
 
-      def post_install(options = {})
+      def post_install
         return unless @post_install
 
         post_install = render_post_install
@@ -173,7 +161,18 @@ module Hetzner
         logger.info output
       end
 
-      
+      def post_install_remote
+        remote do |ssh|
+          @post_install_remote.split("\n").each do |cmd|
+            cmd.chomp!
+            logger.info "executing #{cmd}"
+            ssh.exec!(cmd)
+          end
+        end
+      rescue IOError, Net::SSH::Disconnect
+        logger.debug 'SSH connection was closed.'
+      end
+
       def render_template
         eruby = Erubis::Eruby.new @template.to_s
 
@@ -181,7 +180,7 @@ module Hetzner
         params[:hostname] = @hostname
         params[:ip]       = @ip
 
-        return eruby.result(params)
+        eruby.result(params)
       end
 
       def render_post_install
@@ -192,8 +191,8 @@ module Hetzner
         params[:ip]       = @ip
         params[:login]    = @login
         params[:password] = @password
-        
-        return eruby.result(params)
+
+        eruby.result(params)
       end
 
       def use_api(api_obj)
@@ -204,19 +203,16 @@ module Hetzner
         @logger = logger_obj
         @logger.formatter = default_log_formatter
       end
-      
-      def remote(options = {}, &block)
 
-        default = { :paranoid => false, :password => @password }
+      def remote(options = {}, &block)
+        default = { verify_host_key: :never, password: @password }
         default.merge! options
-        
-        Net::SSH.start(@ip, @login, default) do |ssh|
-          block.call ssh
-        end
+
+        Net::SSH.start(@ip, @login, default, &block)
       end
 
-      def local(&block)
-        block.call
+      def local
+        yield
       end
 
       def reset_retries
@@ -224,19 +220,24 @@ module Hetzner
       end
 
       def rolling_sleep
-        sleep @retries * @retries * 3 + 1 # => 1, 4, 13, 28, 49, 76, 109, 148, 193, 244, 301, 364 ... seconds
+        # => 1, 4, 13, 28, 49, 76, 109, 148, 193, 244, 301, 364 ... seconds
+        sleep @retries * @retries * 3 + 1
       end
 
       def default_log_formatter
-         proc do |severity, datetime, progname, msg|
-           caller[4]=~/`(.*?)'/
-           "[#{datetime.strftime "%H:%M:%S"}][#{sprintf "%-15s", ip}][#{$1}] #{msg}\n"
-         end
+        proc do |_severity, datetime, _progname, msg|
+          caller(5..5).first =~ /`(.*?)'/
+          "[#{datetime.strftime '%H:%M:%S'}][#{format '%-15s', ip}]" \
+          "[#{Regexp.last_match(1)}] #{msg}\n"
+        end
       end
 
       class NoTemplateProvidedError < ArgumentError; end
+
       class CantActivateRescueSystemError < StandardError; end
+
       class CantResetSystemError < StandardError; end
+
       class InstallationError < StandardError; end
     end
   end

data/lib/hetzner/bootstrap/template.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hetzner
   class Bootstrap
     class Template
@@ -12,9 +14,10 @@ module Hetzner
         #
         # also run:   $ installimage -h
         #
-        if param.is_a? Hetzner::Bootstrap::Template
-          return param
-        elsif param.is_a? String
+        case param
+        when Hetzner::Bootstrap::Template
+          param
+        when String
           @raw_template = param
         end
       end
@@ -24,4 +27,4 @@ module Hetzner
       end
     end
   end
-end
+end

data/lib/hetzner/bootstrap/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Hetzner
   class Bootstrap
-    VERSION = '1.0.2'
+    VERSION = '2.0.0'
   end
 end

data/spec/hetzner_bootstrap_spec.rb

@@ -1,51 +1,46 @@
+# frozen_string_literal: true
+
 require 'hetzner-api'
-require 'spec_helper'
+require 'hetzner-bootstrap'
 
-describe "Bootstrap" do
-  before(:all) do
-    @api = Hetzner::API.new API_USERNAME, API_PASSWORD
-    @bootstrap = Hetzner::Bootstrap.new :api => @api
+# rubocop:disable Metrics/BlockLength
+describe 'Bootstrap' do
+  let(:bs) do
+    Hetzner::Bootstrap.new(api: Hetzner::API.new(API_USERNAME, API_PASSWORD))
   end
 
-  context "add target" do
-    
-    it "should be able to add a server to operate on" do
-      @bootstrap.add_target proper_target
-      @bootstrap.targets.should have(1).target
-      @bootstrap.targets.first.should be_instance_of Hetzner::Bootstrap::Target
-    end
+  context 'add target' do
+    it 'should be able to add a server to operate on' do
+      bs.add_target proper_target
 
-    it "should have the default template if none is specified" do
-      @bootstrap.add_target proper_target
-      @bootstrap.targets.first.template.should be_instance_of Hetzner::Bootstrap::Template
+      expect(bs.targets.size).to be_eql(1)
+      expect(bs.targets.first).to be_instance_of(Hetzner::Bootstrap::Target)
     end
 
-    it "should raise an NoTemplateProvidedError when no template option provided" do
-      lambda {
-      @bootstrap.add_target improper_target_without_template
-      }.should raise_error(Hetzner::Bootstrap::Target::NoTemplateProvidedError)
+    it 'should have the default template if none is specified' do
+      bs.add_target proper_target
+
+      expect(bs.targets.first.template).to be_instance_of Hetzner::Bootstrap::Template
     end
-  
   end
 
   def proper_target
-    return {
-      :ip            => "1.2.3.4",
-      :login         => "root",
-#      :password      => "halloMartin!",
-      :rescue_os     => "linux",
-      :rescue_os_bit => "64",
-      :template      => default_template
+    {
+      ip: '1.2.3.4',
+      login: 'root',
+      #      :password      => "halloMartin!",
+      rescue_os: 'linux',
+      rescue_os_bit: '64',
+      template: default_template
     }
   end
 
   def improper_target_without_template
-    proper_target.select { |k,v| k != :template }
+    proper_target.except(:template)
   end
 
   def default_template
-    "bla"
+    'string'
   end
 end
-
-
+# rubocop:enable Metrics/BlockLength