# File lib/openshift-origin-controller/app/controllers/applications_controller.rb, line 50
  def create
    domain_id = params[:domain_id]
    app_name = params[:name]
    cartridge = params[:cartridge]
    scale = get_bool(params[:scale])

    template_id = params[:template]
    node_profile = params[:gear_profile]
    node_profile.downcase! if node_profile

    domain = Domain.get(@cloud_user, domain_id)
    return render_error(:not_found, "Domain '#{domain_id}' not found", 127,
                        "ADD_APPLICATION") if !domain || !domain.hasAccess?(@cloud_user)

    return render_error(:unprocessable_entity, "Application name is required and cannot be blank",
                        105, "ADD_APPLICATION", "name") if !app_name or app_name.empty?

    application = get_application(app_name)
    return render_error(:unprocessable_entity, "The supplied application name '#{app_name}' already exists",
                        100, "ADD_APPLICATION", "name") if application

    Rails.logger.debug "Checking to see if user limit for number of apps has been reached"
    return render_error(:unprocessable_entity, "#{@login} has already reached the gear limit of #{@cloud_user.max_gears}",
                        104, "ADD_APPLICATION") if (@cloud_user.consumed_gears >= @cloud_user.max_gears)

    application = nil
    if template_id
      template = ApplicationTemplate.find(params[:template])
      return render_error(:unprocessable_entity, "Invalid template #{template_id}", 125,
                          "ADD_APPLICATION", "template") unless template
      application = Application.new(@cloud_user, app_name, nil, node_profile, nil, template, scale, domain)
    else
      if !cartridge or not CartridgeCache.cartridge_names('standalone').include?(cartridge)
        carts = Application.get_available_cartridges("standalone")
        return render_error(:unprocessable_entity, "Invalid cartridge #{cartridge}. Valid values are (#{carts.join(', ')})",
                            109, "ADD_APPLICATION", "cartridge")
      end
      application = Application.new(@cloud_user, app_name, nil, node_profile, cartridge, nil, scale, domain)
    end

    app_configure_reply = nil

    Rails.logger.debug "Validating application"
    if not application.valid?
      messages = get_error_messages(application)
      return render_error(:unprocessable_entity, nil, nil, "ADD_APPLICATION", nil, nil, messages)
    end

    begin
      application.user_agent = request.headers['User-Agent']
      Rails.logger.debug "Creating application #{application.name}"
      application.create
      Rails.logger.debug "Configuring dependencies #{application.name}"
      app_configure_reply = application.configure_dependencies
      Rails.logger.debug "Executing connections for #{application.name}"
      application.execute_connections
      begin
        Rails.logger.debug "Creating dns"
        application.create_dns
      rescue Exception => e
        log_action(@request_id, @cloud_user.uuid, @cloud_user.login, "ADD_APPLICATION", false, "Failed to create dns for application #{application.name}: #{e.message}")
        application.destroy_dns
        raise
      end
    rescue Exception => e
      application.destroy
      if application.persisted?
        application.delete
      end
      return render_exception(e, "ADD_APPLICATION")
    end

    if $requested_api_version == 1.0
      app = RestApplication10.new(application, get_url, nolinks)
    else
      app = RestApplication12.new(application, get_url, nolinks)
    end
    messages = []
    log_msg = "Application #{application.name} was created."
    messages.push(Message.new(:info, log_msg))

    current_ip = application.get_public_ip_address
    messages.push(Message.new(:info, "#{current_ip}", 0, "current_ip")) unless !current_ip or current_ip.empty?
    messages.push(Message.new(:info, app_configure_reply.resultIO.string, 0, :result)) if app_configure_reply
    render_success(:created, "application", app, "ADD_APPLICATION", log_msg, nil, nil, messages)
  end