fluke/devops-service/app/api2/handlers/stack.rb

require "lib/executors/server_executor"
require 'db/mongo/models/stack/stack_factory'
require "app/api2/parsers/stack"
require 'workers/stack_bootstrap_worker'
require_relative "request_handler"

module Devops
  module API2_0
    module Handler
      class Stack < RequestHandler

        set_parser Devops::API2_0::Parser::StackParser

        def stacks
          Devops::Db.connector.stacks
        end

        def stacks_for_provider provider
          Devops::Db.connector.stacks(provider: provider)
        end

        def create_stack
          object = parser.create
          stack_attrs = object['stack_attributes']
          project = Devops::Db.connector.project(stack_attrs['project'])
          env = project.deploy_env(stack_attrs['deploy_env'])
          raise InvalidRecord.new("Environment '#{env.identifier}' of project '#{project.id}' has no stack template") if env.stack_template.nil?
          add_stack_attributes(stack_attrs, env, parser)

          jid = Worker.start_async(StackBootstrapWorker,
            stack_attributes: stack_attrs,
            without_bootstrap: object['without_bootstrap'],
            skip_rollback: object['skip_rollback']
          )
          [jid]
        end

        def stack id
          Devops::Db.connector.stack(id)
        end

        def delete_stack name
          stack = self.stack(name)
          stack.delete_stack_in_cloud!
          Devops::Db.connector.stack_servers_delete(stack.name)
          Devops::Db.connector.stack_delete(stack.id)
        end

        def sync id
          stack = self.stack(id)
          stack.sync_status_and_events!
          Devops::Db.connector.stack_update(stack)

          stack
        end

        def stack_servers name
          stack = Devops::Db.connector.stack(name)
          Devops::Db.connector.stack_servers(stack.id)
        end

        def set_run_list id
          Devops::Db.connector.set_stack_run_list(id, parser.run_list)
        end

        def set_tags id
          tags = parser.tags
          prepare_tags do |id, provider|
            provider.set_tags id, tags
          end
        end

        def unset_tags id
          tags = parser.tags
          prepare_tags do |id, provider|
            provider.unset_tags id, tags
          end
        end

        def prepare_tags node_name
          stack = Devops::Db.connector.stack(id)
          Devops::Db.connector.check_project_auth stack.project, stack.deploy_env, parser.current_user
          stack_servers = Devops::Db.connector.stack_servers(id)
          provider = stack.provider_instance
          stack_servers.each do |s|
            yield s.id, provider
          end
        end

        def deploy id
          stack = self.stack(id)
          owner = parser.current_user
          project = Devops::Db.connector.check_project_auth(stack.project, stack.deploy_env, owner)
          deploy_env_model = project.deploy_env(stack.deploy_env)
          body = parser.deploy
          names = body["names"]
          tags = body["tags"] || []
          files = []
          jid = nil
          servers = Devops::Db.connector.stack_servers(id, true)
          servers.each do |s|
            begin
              deploy_info = project.deploy_info(deploy_env_model, nil)
              jid = Worker.start_async(DeployWorker,
                server_attrs: s.to_hash,
                owner: owner,
                tags: tags,
                deploy_info: deploy_info
              )
            rescue DeployInfoError => e
              msg = "Can not get deploy info: " + e.message
              DevopsLogger.logger.error msg
              jid = "error_#{s.chef_node_name}_#{Time.new.to_i}"
              dir = DevopsConfig.config[:report_dir_v2]
              file = File.jon(dir, jid)
              File.open(file, "w") do |out|
                out.write msg
              end
              o = {
                "file" => file,
                "_id" => jid,
                "created_by" => owner,
                "project" => s.project,
                "deploy_env" => s.deploy_env,
                "type" => Report::DEPLOY_TYPE,
                "status" => Worker::STATUS::FAILED
              }
              Devops::Db.connector.save_report(Report.new(o))
            end
            files.push jid
          end
          files
        end

        def deploy_stream id, out
          stack = self.stack(id)
          owner = parser.current_user
          status = []
          project = Devops::Db.connector.check_project_auth(stack.project, stack.deploy_env, owner)
          body = parser.deploy
          #TODO: deploy servers names
#          names = body["names"]
          tags = body["tags"] || []
          # find all stack reserved servers
          servers = Devops::Db.connector.stack_servers(stack_id, true)
          deploy_info = project.deploy_info(stack.deploy_env, nil)
          servers.each do |s|
            begin
              res = Devops::Executor::ServerExecutor.new(s, out, current_user: owner).deploy_server_with_tags(tags, deploy_info)
              status.push(res)
            rescue DeployInfoError => e
              msg = "Can not get deploy info: " + e.message
              DevopsLogger.logger.error msg
              out << msg + "\n"
              status.push 2
              next
            end
          end
          status
        rescue RecordNotFound  => e
          out << e.message
          [-10]
        end

        def reserve_servers(stack_id)
          stack = self.stack(stack_id)
          user = parser.current_user
          Devops::Db.connector.check_project_auth stack.project, stack.deploy_env, user

          # check if none of servers are reserved by somebody else
          servers = Devops::Db.connector.stack_servers(stack_id)
          servers.each do |server|
            if server.reserved_by.present? && server.reserved_by != user
              raise ConflictException.new("Server '#{server.chef_node_name}' already reserved by #{server.reserved_by}")
            end
          end

          # reserve them
          servers.each do |server|
            server.reserved_by = user
            Devops::Db.connector.server_update(server)
          end
        end

        def unreserve_servers(stack_id)
          stack = self.stack(stack_id)
          user = parser.current_user
          Devops::Db.connector.check_project_auth stack.project, stack.deploy_env, user

          servers = Devops::Db.connector.stack_servers(stack_id)
          servers.each do |server|
            server.reserved_by = nil
            Devops::Db.connector.server_update(server)
          end
        end

        def change_stack_template(stack_id)
          stack_template_id = parser.change_stack_template
          Devops::Db.connector.stack_template(stack_template_id)
          stack = Devops::Db.connector.stack(stack_id)
          stack.change_stack_template!(stack_template_id)
        end

        private

        def add_stack_attributes(stack_attrs, env, parser)
          stack_attrs['stack_template'] = env.stack_template
          stack_attrs['owner'] = parser.current_user
          stack_attrs['provider'] = env.provider
          stack_attrs['provider_account'] = env.provider_account
        end

      end
    end
  end
end