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

require "db/mongo/models/stack/stack_factory"
require "lib/puts_and_flush"
module Devops; module Executor; class StackExecutor; end; end; end # predeclare for visibility
require_relative "stack_executor/stack_creation_waiter"
require_relative "stack_executor/stack_servers_persister"
require_relative "stack_executor/prioritized_groups_bootstrapper"
require_relative "stack_executor/stack_servers_fetcher"

module Devops
  module Executor
    class StackExecutor
      include PutsAndFlush
      attr_reader :out, :stack

      def initialize(options)
        @out = options.fetch(:out)
        @stack = options[:stack]
        @just_persisted_by_priority = {}
      end

      def create_stack(stack_attrs)
        stack_attrs.merge!('persisting_is_locked' => true)
        @stack = Devops::Model::StackFactory.create(stack_attrs["provider"], stack_attrs, out)
        mongo.stack_insert(@stack)
      end

      def wait_till_stack_is_created
        waiter.wait.ok?
      end

      def persist_new_servers
        fetcher.reset_states
        servers_to_persist = fetcher.servers_to_persist
        if servers_to_persist.any?
          out.puts 'Servers to persist:'
          servers_to_persist.each { |info| out.puts JSON.pretty_generate(info) }
          puts_and_flush "\n\nPersisting new servers:"
        else
          puts_and_flush 'There are no servers to persist.'
          return
        end

        fetcher.new_servers_by_priorities.each do |priority, provider_infos|
          servers = provider_infos.map {|info| persister.persist(info) }
          servers.each { |server| out.puts JSON.pretty_generate(server.to_hash) }
          @just_persisted_by_priority[priority] = servers
        end
        puts_and_flush "New servers have been persisted"
      end

      def bootstrap_just_persisted(jid)
        puts_and_flush "Bootstrapping just persisted servers" if @just_persisted_by_priority.values.flatten.any?
        @just_persisted_by_priority.each do |priority, servers|
          puts_and_flush "Servers with priority '#{priority}': #{servers.map(&:id).join(", ")}"
        end
        PrioritizedGroupsBootstrapper.new(out, jid, @just_persisted_by_priority).bootstrap_servers_by_priority
      end

      def delete_stale_servers
        fetcher.reset_states
        servers_to_delete = fetcher.stale_servers
        if servers_to_delete.any?
          out.puts "\nStale servers:"
          servers_to_delete.each { |server| out.puts JSON.pretty_generate(server.to_hash) }
          puts_and_flush 'Deleting stale servers.'
        else
          puts_and_flush "\nThere are no stale servers."
          return
        end

        servers_to_delete.each do |server|
          proper_remove_server(server)
        end
      end

      def delete_stack
        out.puts "Removing stack from cloud"
        stack.delete_stack_in_cloud!
        out.puts "Removing stack servers"
        mongo.stack_servers(@stack.name).each do |server|
          proper_remove_server(server)
        end
        out.puts "Removing stack from db"
        mongo.stack_delete(stack.id)
        out.flush
      end

      private

      def mongo
        Devops::Db.connector
      end

      def proper_remove_server(server)
        begin
          e = Devops::Executor::ServerExecutor.new(server, out)
          e.delete_server
        rescue StandardError => e
          puts_and_flush [e.message, e.backtrace].join("\n")
        end
      end

      def fetcher
        @fetcher ||= StackServersFetcher.new(stack, out)
      end

      def persister
        @persister ||= StackServersPersister.new(@stack)
      end

      def waiter
        StackCreationWaiter.new(stack, out)
      end

    end
  end
end