fluke/devops-service/lib/executors/server_executor.rb

require "lib/knife/knife_factory"
require "hooks"

module Devops
  module Executor
    class ServerExecutor
      include Hooks

      #params:
      #  out - container for output data
      #  deploy_info - hash with deploy data
      define_hook :before_deploy
      define_hook :after_deploy

      define_hook :before_create
      define_hook :after_create

      #params:
      #  out - container for output data
      define_hook :before_bootstrap
      define_hook :after_bootstrap

      def initialize server, out
        if server
          @project = Devops::Db.connector.project(server.project)
          @deploy_env = @project.deploy_env(server.deploy_env)
        end
        @knife_instance = KnifeFactory.instance
        @server = server
        @out = out
        @out.class.send(:define_method, :flush) { } unless @out.respond_to?(:flush)
      end

      def project= p
        @project = p
      end

      def deploy_env= e
        @deploy_env = e
      end

      def create_server options
        @server = Devops::Model::Server.new({"project" => @project.id, "deploy_env" => @deploy_env.identifier, "created_by" => options["created_by"], "provider" => @deploy_env.provider})
        provider = @server.provider_instance
        mongo = ::Devops::Db.connector
        begin
          @out << "Create server...\n"
          @out.flush

          @server.run_list = options["run_list"] || []
          @server.chef_node_name = options["name"]
          @server.key = options["key"] || provider.ssh_key

          i = mongo.image(@deploy_env.image)
          @server.remote_user = i.remote_user

          res = {}
          @out << "\nBefore create hooks...\n"
          res[:before] = self.run_hook :before_create
          return false unless provider.create_server(@server, @deploy_env.image, @deploy_env.flavor, @deploy_env.subnets, @deploy_env.groups, @out)
          mongo.server_insert @server
          @out << "\nAfter create hooks...\n"
          res[:after] = self.run_hook :after_create

          @out.flush
          DevopsLogger.logger.info "Server with parameters: #{@server.to_hash.inspect} is running"
          unless options["without_bootstrap"]
            @server.run_list = Set.new.merge(@project.run_list).merge(@deploy_env.run_list).merge(@server.run_list).to_a
            @server.chef_node_name = provider.create_default_chef_node_name(@server) if @server.chef_node_name.nil?
            bootstrap_options = {
              bootstrap_template: i.bootstrap_template
            }
            return two_phase_bootstrap(bootstrap_options)
          else
            return 0
          end
        rescue => e
          DevopsLogger.logger.error e.message
          roll_back
          mongo.server_delete @server.id
          return 5
        end

      end

      def bootstrap options
        @out << "\n\nBootstrap...\n"
        @out.flush
        k = Devops::Db.connector.key(@server.key)
        cert_path = k.path
        options[:cert_path] = k.path
        @out << "\nBefore bootstrap hooks...\n"
        res = self.run_hook(:before_bootstrap, @out)
        @out << "Done\n"
        if @server.private_ip.nil?
          @out << "Error: Private IP is null"
          return false
        end
        ja = {
          :provider => @server.provider,
          :devops_host => `hostname`.strip
        }
        ip = @server.private_ip
        unless @server.public_ip.nil?
          ip = @server.public_ip
          @out << "\nPublic IP is present\n"
        end
        @out << "\nWaiting for SSH..."
        @out.flush
        i = 0
        cmd = "ssh -i #{cert_path} -q #{@server.remote_user}@#{ip} 'exit' 2>&1"
        begin
          sleep(5)
          res = `#{cmd}`
          i += 1
          if i == 120
            @out << "\nCan not connect to #{@server.remote_user}@#{ip}"
            @out << "\n" + res
            DevopsLogger.logger.error "Can not connect with command 'ssh -i #{cert_path} #{@server.remote_user}@#{ip}':\n#{res}"
            return false
          end
          raise ArgumentError.new("Can not connect with command '#{cmd}' ") unless $?.success?
        rescue ArgumentError => e
          retry
        end

        r = @knife_instance.knife_bootstrap(@out, ip, self.bootstrap_options(ja, options))
        if r == 0
          @out << "Chef node name: #{@server.chef_node_name}\n"
          ::Devops::Db.connector.server_set_chef_node_name @server
          @out << "Chef node name has been updated\n"
          @out << "After bootstrap hooks...\n"
          res = self.run_hook(:after_bootstrap, @out)
          @out << "Done\n"
          DevopsLogger.logger.info "Server with id '#{@server.id}' is bootstraped"
        else
        end
        @out.flush
        r
      end

      def bootstrap_options attributes, options
        bootstrap_options = [
          "-x #{@server.remote_user}",
          "-i #{options[:cert_path]}",
          "--json-attributes '#{attributes.to_json}'",
          "-N #{@server.chef_node_name}"
        ]
        bootstrap_options.push "--sudo" unless @server.remote_user == "root"
        bootstrap_options.push "-t #{options[:bootstrap_template]}" if options[:bootstrap_template]
        rl = options[:run_list]
        bootstrap_options.push "-r #{rl.join(",")}" unless rl.nil?# rl.empty?
        bootstrap_options.push "-c #{options[:config]}" if options[:config]
        bootstrap_options
      end

      def two_phase_bootstrap options
        provider = @server.provider_instance
        mongo = ::Devops::Db.connector
        options[:run_list] = provider.run_list
        status = bootstrap(options)
        if status == 0
          if check_server
            @out << "Server #{@server.chef_node_name} is created"
          else
            @out << roll_back
            mongo.server_delete @server.id
            return 5
          end
          @out << "\n"
          @out.flush

          run_list = @server.run_list + provider.run_list
          @out << "\nRun list: #{run_list.inspect}"
    #      s.options[:run_list] += run_list
          @knife_instance.set_run_list(@server.chef_node_name, run_list)
          status = deploy_server({})
          if status != 0
            msg = "Failed on chef-client with project run list, server with id '#{@server.id}'"
            DevopsLogger.logger.error msg
            @out << "\n" + msg + "\n"
          end
        else
          msg = "Failed while bootstraping server with id '#{s.id}'"
          DevopsLogger.logger.error msg
          @out << "\n" + msg + "\n"
          @out << roll_back
          mongo.server_delete @server.id
        end
        return status
      end

      def check_server
        @knife_instance.chef_node_list.include?(@server.chef_node_name) and @knife_instance.chef_client_list.include?(@server.chef_node_name)
      end

      def unbootstrap
        k = Devops::Db.connector.key(@server.key)
        cert_path = k.path
        i = 0
        begin
          r = `ssh -i #{cert_path} -q #{@server.remote_user}@#{@server.private_ip} rm -Rf /etc/chef`
          raise(r) unless $?.success?
        rescue => e
          DevopsLogger.logger.error "Unbootstrap error: " + e.message
          i += 1
          sleep(1)
          retry unless i == 5
          return e.message
        end
        nil
      end

      def deploy_server_with_tags tags, deploy_info
        old_tags_str = nil
        new_tags_str = nil
        unless tags.empty?
          old_tags_str = @knife_instance.tags_list(@server.chef_node_name).join(" ")
          @out << "Server tags: #{old_tags_str}\n"
          @knife_instance.tags_delete(@server.chef_node_name, old_tags_str)

          new_tags_str = tags.join(" ")
          @out << "Server new tags: #{new_tags_str}\n"
          cmd = @knife_instance.tags_create(@server.chef_node_name, new_tags_str)
          unless cmd[1]
            m = "Error: Cannot add tags '#{new_tags_str}' to server '#{@server.chef_node_name}'"
            DevopsLogger.logger.error(m)
            @out << m + "\n"
            return 3
          end
          DevopsLogger.logger.info("Set tags for '#{@server.chef_node_name}': #{new_tags_str}")
        end

        deploy_server deploy_info

        unless tags.empty?
          @out << "Restore tags\n"
          cmd = @knife_instance.tags_delete(@server.chef_node_name, new_tags_str)
          DevopsLogger.logger.info("Deleted tags for #{@server.chef_node_name}: #{new_tags_str}")
          cmd = @knife_instance.tags_create(@server.chef_node_name, old_tags_str)
          DevopsLogger.logger.info("Set tags for #{@server.chef_node_name}: #{old_tags_str}")
        end
        return r
      end

      def deploy_server deploy_info
        @out << "\nBefore deploy hooks...\n"
        res = self.run_hook(:before_deploy, @out, deploy_info)
        @out << "Done\n"
        @out << "\nRun chef-client on '#{@server.chef_node_name}'\n"
        cmd = "chef-client --no-color"
        if deploy_info["use_json_file"]
          deploy_info.delete["use_json_file"]
          @out << "Build information:\n"
          json = JSON.pretty_generate(deploy_info)
          @out << json
          @out << "\n"
          file = "#{@server.project}_#{@server.deploy_env}_#{Time.new.to_i}"
          dir = DevopsConfig.config[:project_info_dir]
          File.open(File.join(dir, file), "w") do |f|
            f.write json
          end
          @out.flush
          cmd << " -j http://#{DevopsConfig.config[:address]}:#{DevopsConfig.config[:port]}/#{DevopsConfig.config[:url_prefix]}/v2.0/deploy/data/#{file}"
        end
        ip = if @server.public_ip.nil?
          @server.private_ip
        else
          @out << "Public IP detected\n"
          @server.public_ip
        end
        @out.flush
        k = Devops::Db.connector.key(@server.key)
        lline = @knife_instance.ssh_stream(@out, cmd, ip, @server.remote_user, k.path)
        r = /Chef\sClient\sfinished/i
        if lline[r].nil?
          1
        else
          @out << "\nAfter deploy hooks...\n"
          res = self.run_hook(:after_deploy, @out, deploy_info)
          @out << "Done\n"
          0
        end
      end

      def delete_from_chef_server node_name
        {
          :chef_node => @knife_instance.chef_node_delete(node_name),
          :chef_client => @knife_instance.chef_client_delete(node_name)
        }
      end

=begin
      def delete_etc_chef s, cert_path
        cmd = "ssh -i #{cert_path} -t -q #{s.remote_user}@#{s.private_ip}"
        cmd += " sudo " unless s.remote_user == "root"
        cmd += "rm -Rf /etc/chef"
        r = `#{cmd}`
        raise(r) unless $?.success?
      end
=end

      def delete_server
        mongo = ::Devops::Db.connector
        if @server.static?
          if !@server.chef_node_name.nil?
            unbootstrap
          end
          mongo.server_delete @server.id
          msg = "Static server '#{@server.id}' is removed"
          DevopsLogger.logger.info msg
          return msg, nil
        end
        r = delete_from_chef_server(@server.chef_node_name)
        provider = @server.provider_instance
        begin
          r[:server] = provider.delete_server @server
        rescue Fog::Compute::OpenStack::NotFound, Fog::Compute::AWS::NotFound
          r[:server] = "Server with id '#{@server.id}' not found in '#{provider.name}' servers"
          DevopsLogger.logger.warn r[:server]
        end
        mongo.server_delete @server.id
        info = "Server '#{@server.id}' with name '#{@server.chef_node_name}' for project '#{@server.project}-#{@server.deploy_env}' is removed"
        DevopsLogger.logger.info info
        r.each{|key, log| DevopsLogger.logger.info("#{key} - #{log}")}
        return info, r
      end

      def roll_back
        unless @server.id.nil?
          @out << "Server '#{@server.chef_node_name}' with id '#{@server.id}' is not created\n"
          @out << delete_from_chef_server(@server.chef_node_name).values.join("\n")
          begin
            @out << @server.provider_instance.delete_server(@server)
          rescue => e
            @out << e.message
          end
          @out << "\nRolled back\n"
        end
      end

    end
  end
end