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_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)
        end

=begin
        def create_stack object
          object[:owner] = owner_from_request
          file = JobStarter.start_job(:worker, :stack_bootstrap,
            provider: object['provider'],
            stack_attributes: object,
            request: @request
          )
          puts "Syncing report is located here: #{file}"

          stack
        end
=end

        def create_stack
          object = parser.create
          project = Devops::Db.connector.project(object["project"])
          env = project.deploy_env(object["deploy_env"])
          raise InvalidRecord.new("Environment '#{env.identifier}' of project '#{project.id}' has no stack template") if env.stack_template.nil?
          object["stack_template"] = env.stack_template
          object["owner"] = parser.current_user
#          stack_model = Model::StackFactory.create(env.provider, object)
#          stack_model.owner = owner_from_request
          #Devops::Db.connector.stack_insert(stack_model)

          file = JobStarter.start_job(:worker, :stack_bootstrap,
            provider: env.provider,
            stack_attributes: object,
            request: @request
          )
          puts "Syncing report is located here: #{file}"
          [file]
        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.id)
          Devops::Db.connector.stack_delete(stack.id)
        end

        def sync_details id
          stack = self.stack(id)
          stack.sync_details!
          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 resources id
          stack = Devops::Db.connector.stack(id)
          stack.resources
        end

        def resource id, resource_id
          stack = Devops::Db.connector.stack(id)
          stack.resource(resource_id)
        end

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

        def deploy id
          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
          names = body["names"]
          tags = body["tags"] || []
          dir = DevopsConfig.config[:report_dir_v2]
          files = []
          jid = nil
          uri = URI.parse(parser.request.url)
          servers = Devops::Db.connector.stack_servers(stack_id, true)
          deploy_info = project.deploy_info(stack.deploy_env, nil)
          servers.each do |s|
            begin
              jid = DeployWorker.perform_async(dir, s.to_hash, tags, owner, DevopsConfig.config, deploy_info)
              Worker.set_status jid, Worker::STATUS::IN_QUEUE
              DevopsLogger.logger.info "Job '#{jid}' has been queued"
            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}"
              file = File.jon(dir, jid)
              File.open(file, "w") do |out|
                #unless attributes.nil?
                #  out << "Report attributes: #{attributes.inspect}\n"
                #end
                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
#                "attributes" => attributes
              }
              Devops::Db.connector.save_report(Report.new(o))
            end
            uri.path =  "#{DevopsConfig[:url_prefix]}/v2.0/report/" + jid
            files.push uri.to_s
          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).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

      end
    end
  end
end