fluke/devops-service/db/mongo/models/deploy_env/deploy_env_base.rb

require "db/mongo/models/mongo_model"
require "providers/provider_factory"
require "db/mongo/models/model_with_provider"

module Devops
  module Model
    class DeployEnvBase < MongoModel

      include ModelWithProvider

      attr_accessor :identifier, :run_list, :expires, :users

      set_validators ::Validators::DeployEnv::RunList,
                     ::Validators::DeployEnv::Expiration,
                     ::Validators::DeployEnv::Users

      set_field_validators :identifier, ::Validators::FieldValidator::NotNil,
                                        ::Validators::FieldValidator::FieldType::String,
                                        ::Validators::FieldValidator::NotEmpty,
                                        ::Validators::FieldValidator::Name

      set_field_validators :run_list, ::Validators::FieldValidator::NotNil,
                                      ::Validators::FieldValidator::FieldType::Array,
                                      ::Validators::FieldValidator::RunList

      set_field_validators :users, ::Validators::FieldValidator::NotNil,
                                   ::Validators::FieldValidator::FieldType::Array

      set_field_validators :expires, ::Validators::FieldValidator::Nil,
                                     ::Validators::FieldValidator::FieldType::String,
                                     ::Validators::FieldValidator::Expires

      def initialize d={}
        self.identifier = d["identifier"]
        b = d["run_list"] || []
        self.run_list = b.uniq
        self.expires = d["expires"]
        self.provider = d["provider"]
        b = d["users"] || []
        self.users = b.uniq
      end

      def to_hash
        {
          "identifier" => self.identifier,
          "run_list" => self.run_list,
          "expires" => self.expires,
          "provider" => self.provider,
          "users" => self.users
        }
      end

      def add_users users
        self.users = (self.users + users).uniq
      end

      def rename project_id, new_name
        old_name = self.identifier
        self.identifier = new_name
        self.validate_identifier!
        begin
          project = Devops::Db.connector.project(project_id)
          project.deploy_env(self.identifier)
          raise InvalidRecord.new("Environment with identifier '#{new_name}' already exist in project '#{project_id}'")
        rescue RecordNotFound => e
          res = create_role(project_id)
          knife = knife_instance
          old_role_name = knife.role_name(project_id, old_name)
          self.run_list.delete("role[#{old_role_name}]")
          role = res[:new] || res[:exist]
          self.run_list << "role[#{role[0]}]" unless role.nil?
          Devops::Db.connector.set_project_deploy_env_field(project_id, old_name, {"identifier" => new_name, "run_list" => self.run_list})
          msg = "Project '#{project_id}': environment '#{old_name}' has been renamed to '#{new_name}'." + Project.create_roles_response(res)
          DevopsLogger.logger.info(msg)
          msg
        end
      end

      def update_field project_id, field, value
        self.send(field + "=", value)
        self.send("validate_" + field + "!")
        Devops::Db.connector.set_project_deploy_env_field(project_id, self.identifier, {field => value})
      end

      def build_error_message(message)
        "Deploy environment '#{self.identifier}'. " + message
      end

      def create_role project_id
        knife = knife_instance
        if knife.nil?
          DevopsLogger.logger.error "Can not get knife instance"
          return nil
        end
        all_roles = knife.roles
        info = {}
        if all_roles.nil?
          msg = "Can't get roles list from chef"
          DevopsLogger.logger.error msg
          return {error: [msg]}
        end
        role_name = knife.role_name(project_id, self.identifier)
        begin
          if all_roles.include? role_name
            info[:exist] = [role_name]
          else
            knife.create_role role_name, project_id, self.identifier
            info[:new] = [role_name]
            DevopsLogger.logger.info "Role '#{role_name}' created"
          end
          self.run_list << "role[#{role_name}]"
        rescue => er
          info[:error] = [role_name]
          DevopsLogger.logger.error "Role '#{role_name}' can not be created: #{er.message}"
        end
        info
      end

      def knife_instance
        KnifeFactory.instance
      end

    end
  end
end