openshift-origin-console 1.3.2

data/app/controllers/building_controller.rb

@@ -0,0 +1,81 @@
+class BuildingController < ConsoleController
+
+  def show
+    user_default_domain
+    @application = @domain.find_application params[:application_id]
+    redirect_to new_application_building_path(@application) unless @application.builds?
+  end
+
+  def new
+    user_default_domain
+    @application = @domain.find_application params[:application_id]
+    @jenkins_server = if @application.building_app
+        @domain.find_application(@application.building_app) if @application.building_app
+      else
+        Application.new({:name => 'jenkins'}, false)
+      end
+    @cartridge_type = CartridgeType.cached.all.find{ |c| c.tags.include? :ci_builder }
+    @cartridge = Cartridge.new :name => @cartridge_type.name
+  end
+
+  def create
+    @domain = Domain.find :one, :as => current_user
+    @application = @domain.find_application(params[:application_id])
+    @jenkins_server = @domain.find_application(@application.building_app) if @application.building_app
+    @cartridge_type = CartridgeType.cached.all.find{ |c| c.tags.include? :ci_builder }
+    @cartridge = Cartridge.new :name => @cartridge_type.name
+
+    unless @jenkins_server
+      framework = CartridgeType.cached.all.find{ |c| c.tags.include? :ci }
+      @jenkins_server = Application.new(
+        :name => params[:application][:name],
+        :cartridge => framework.name,
+        :domain => @domain,
+        :as => current_user)
+
+      if @jenkins_server.save
+        message = @jenkins_server.remote_results
+      else
+        render :new and return
+      end
+    end
+
+    @cartridge.application = @application
+
+    success, attempts = @cartridge.save, 1
+    while (!success && @cartridge.has_exit_code?(157, :on => :cartridge) && attempts < 2)
+      logger.debug "  Jenkins server could not be contacted, sleep and then retry\n    #{@cartridge.errors.inspect}"
+      sleep(10)
+      success = @cartridge.save
+      attempts += 1
+    end
+
+    if success
+      redirect_to application_building_path(@application), :flash => {:info_pre => @cartridge.remote_results.concat(message || []).concat(['Your application is now building with Jenkins.'])}
+    else
+      if @cartridge.has_exit_code?(157, :on => :cartridge)
+        message = 'The Jenkins server is not yet registered with DNS. Please wait a few minutes before trying again.'
+      else
+        @cartridge.errors.full_messages.each{ |m| @jenkins_server.errors.add(:base, m) }
+      end
+      flash.now[:info_pre] = message
+      render :new
+    end
+  end
+
+  def delete
+    user_default_domain
+    @application = @domain.find_application params[:application_id]
+    redirect_to new_application_building_path(@application) unless @application.builds?
+  end
+
+  def destroy
+    @domain = Domain.find :one, :as => current_user
+    @application = @domain.find_application params[:application_id]
+    if @application.destroy_build_cartridge
+      redirect_to application_path(@application), :flash => {:success => "#{@application.name} is no longer building through Jenkins."}
+    else
+      render :delete
+    end
+  end
+end

data/app/controllers/capability_aware.rb

@@ -0,0 +1,18 @@
+module CapabilityAware
+  extend ActiveSupport::Concern
+
+  included do
+    around_filter UserSessionSweeper
+  end
+
+  # Call this with :refresh => true to force a
+  # refresh of the values stored in session
+  def user_capabilities(args = {})
+    @user_capabilities = nil if args[:refresh]
+    @user_capabilities ||=
+      (Capabilities::Cacheable.from(session[:user_capabilities]) rescue nil) ||
+      User.find(:one, :as => current_user).to_capabilities.tap{ |c| session[:user_capabilities] = c.to_a }
+  end
+end
+RestApi::Base.observers << UserSessionSweeper
+UserSessionSweeper.instance

data/app/controllers/cartridge_types_controller.rb

@@ -0,0 +1,53 @@
+class CartridgeTypesController < ConsoleController
+
+  def index
+    user_default_domain
+
+    @application = @domain.find_application params[:application_id]
+    installed_carts = @application.cartridges
+
+    types = CartridgeType.cached.embedded
+
+    @blocked = []
+
+    @installed, types = types.partition{ |t| installed_carts.any?{ |c| c.name == t.name } }
+    @blacklist, types = types.partition{ |t| t.tags.include?(:blacklist) }
+
+    @conflicts, types = types.partition{ |t| conflicts? t }
+    @requires, types  = types.partition{ |t| requires? t }
+
+    @installed.sort!; @conflicts.sort!; @requires.sort!
+    @carts = types.sort!
+  end
+
+  def show
+    user_default_domain
+    @application = @domain.find_application params[:application_id]
+
+    @cartridge_type = CartridgeType.cached.find params[:id]
+    @cartridge = Cartridge.new :as => current_user
+  end
+
+  def conflicts?(cart_type)
+    t = cart_type
+
+    return false if @installed.nil? || t.conflicts.empty?
+
+    # if this cart can conflict and a conflicting cart is installed
+    # add this cart to the conflicted list
+    @installed.each { |c| return true if t.conflicts.include? c.name }
+    return false
+  end
+
+  def requires?(cart_type)
+    t = cart_type
+
+    return true if @installed.nil? && !t.requires.empty?
+    return false if t.requires.empty?
+
+    # if this cart has requirements and the required cart is not
+    # installed add this cart to the requires list
+    @installed.each { |c| return false if t.requires.include? c.name }
+    return true
+  end
+end

data/app/controllers/cartridges_controller.rb

@@ -0,0 +1,43 @@
+class CartridgesController < ConsoleController
+
+  def index
+     # on index get, redirect back to application details page
+     redirect_to application_path(params['application_id'])
+  end
+
+  def show
+    user_default_domain
+    @application = @domain.find_application params[:application_id]
+    @application_type = ApplicationType.find @application.framework
+    Rails.logger.debug @application.cartridges
+    @cartridge = @application.find_cartridge params[:id]
+  end
+
+  def create
+    cart_params = params[:cartridge]
+    @domain = Domain.find :one, :as => current_user
+    @application = @domain.find_application params[:application_id]
+    # TODO: check for app errors and redirect to app list if error
+
+    @cartridge = Cartridge.new cart_params
+
+    @cartridge.application = @application
+    @cartridge.as = current_user
+
+    @cartridge_type = CartridgeType.find cart_params[:name], :as => current_user
+
+    if @cartridge.save
+      @wizard = true
+
+      message = @cartridge.remote_results
+      flash.now[:info_pre] = message
+
+      render :next_steps
+    else
+      Rails.logger.debug @cartridge.errors.inspect
+      @application_id = @application.id
+      render 'cartridge_types/show'
+    end
+  end
+end
+

data/app/controllers/console/auth/basic.rb

@@ -0,0 +1,65 @@
+#
+# The simplest possible security strategy - this controller mixin
+# will challenge the user with BASIC authentication, pass that
+# information to the broker, and then cache the ticket and the user
+# identifier in the session until the ticket expires.
+#
+module Console::Auth::Basic
+  extend ActiveSupport::Concern
+
+  class BasicUser < RestApi::Authorization
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    def initialize(opts={})
+      opts.each_pair { |key,value| instance_variable_set("@#{key}", value) }
+    end
+    def email_address
+      nil
+    end
+
+    def persisted?
+      false
+    end
+  end
+
+  included do
+    helper_method :current_user, :user_signed_in?, :previously_signed_in?
+
+    rescue_from ActiveResource::UnauthorizedAccess, :with => :console_access_denied
+  end
+
+  # return the current authenticated user or nil
+  def current_user
+    @authenticated_user
+  end
+
+  # This method should test authentication and handle if the user
+  # is unauthenticated
+  def authenticate_user!
+    authenticate_or_request_with_http_basic(auth_realm) do |login,password|
+      if login.present?
+        @authenticated_user = BasicUser.new :login => login, :password => password
+      else
+        raise Console::AccessDenied
+      end
+    end
+  end
+
+  def user_signed_in?
+    not current_user.nil?
+  end
+
+  def previously_signed_in?
+    cookies[:prev_login] ? true : false
+  end
+
+  protected
+    def auth_realm
+      "Authenticate to #{RestApi.site.host}"
+    end
+
+    def console_access_denied
+      request_http_basic_authentication(auth_realm)
+    end
+end

data/app/controllers/console/auth/none.rb

@@ -0,0 +1,5 @@
+#
+# An empty module - exposes none of the default implementations
+#
+module Console::Auth::None
+end

data/app/controllers/console/auth/remote_user.rb

@@ -0,0 +1,69 @@
+#
+# The simplest possible security strategy - this controller mixin
+# will look for user info as a header on the request, and pass that
+# info down to the broker.  The broker should be configured to 
+# authenticate with those headers.
+# 
+module Console::Auth::RemoteUser
+  extend ActiveSupport::Concern
+
+  class RemoteUser < RestApi::Authorization
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    def initialize(username, headers)
+      @username = username
+      @headers = headers.freeze
+    end
+    def login
+      @username
+    end
+    def email_address
+      nil
+    end
+    def to_headers
+      @headers
+    end
+    def persisted?
+      false
+    end
+  end
+
+  included do
+    helper_method :current_user, :user_signed_in?, :previously_signed_in?
+
+    rescue_from ActiveResource::UnauthorizedAccess, :with => :console_access_denied
+  end
+
+  # return the current authenticated user or nil
+  def current_user
+    @authenticated_user
+  end
+
+  # This method should test authentication and handle if the user
+  # is unauthenticated
+  def authenticate_user!
+    @authenticated_user ||= begin
+        name = request.env[Console.config.remote_user_header]
+        raise Console::AccessDenied unless name
+        display_name = request.env[Console.config.remote_user_name_header] unless Console.config.remote_user_name_header.nil?
+        name = display_name || name
+        logger.debug "  Identified user #{name} from headers"
+        RemoteUser.new(
+          name,
+          Console.config.remote_user_copy_headers.inject({}) do |h, name|
+            value = request.headers[name]
+            h[name] = value if value.present?
+            h
+          end)
+      end
+  end
+
+  def user_signed_in?
+    not current_user.nil?
+  end
+
+  def previously_signed_in?
+    cookies[:prev_login] ? true : false
+  end
+end

data/app/controllers/console/rescue.rb

@@ -0,0 +1,48 @@
+module Console
+  module Rescue
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from ActiveResource::ConnectionError, :with => :generic_error
+      rescue_from ActiveResource::ResourceNotFound, :with => :page_not_found
+      rescue_from RestApi::ResourceNotFound, :with => :resource_not_found
+      rescue_from Console::AccessDenied, :with => :console_access_denied
+    end
+
+    protected
+      def resource_not_found(e)
+        if respond_to? :domain_is_missing
+          domain_is_missing if e.respond_to?(:domain_missing?) && e.domain_missing?
+        end
+        alternatives = if Application == e.model
+                         @domain.applications.map do |app|
+                           ["Application #{app.name}", application_path(app)]
+                         end.tap do |links|
+                           links << ['Create a new application', new_application_path] if links.empty?
+                         end if @domain rescue nil
+                       elsif ApplicationType == e.model
+                          [['See other application types', application_types_path]]
+                       end
+        page_not_found(e, e.message, alternatives)
+      end
+
+      def page_not_found(e=nil, message=nil, alternatives=nil)
+        @reference_id = request.uuid
+        logger.warn "Page not found - Reference ##{@reference_id}"
+        @message, @alternatives = message, alternatives
+        render 'console/not_found'
+      end
+
+      def generic_error(e=nil, message=nil, alternatives=nil)
+        @reference_id = request.uuid
+        logger.error "Unhandled exception reference ##{@reference_id}: #{e.message}\n#{e.backtrace.join("\n  ")}"
+        @message, @alternatives = message, alternatives
+        render 'console/error'
+      end
+
+      def console_access_denied(e)
+        logger.debug "Access denied: #{e}"
+        redirect_to unauthorized_path
+      end
+  end
+end

data/app/controllers/console_controller.rb

@@ -0,0 +1,19 @@
+class ConsoleController < Console.config.parent_controller.constantize
+  include Console.config.security_controller.constantize
+  include CapabilityAware
+  include DomainAware
+  include SshkeyAware
+
+  layout 'console'
+
+  before_filter :authenticate_user!
+
+  def active_tab
+    nil
+  end
+
+  protected
+    def to_boolean(param)
+      ['1','on','true'].include?(param.to_s.downcase) if param
+    end
+end

data/app/controllers/console_index_controller.rb

@@ -0,0 +1,14 @@
+class ConsoleIndexController < ConsoleController
+  skip_before_filter :authenticate_user!, :only => :unauthorized
+
+  def index
+    redirect_to applications_path
+  end
+  def unauthorized
+    render 'console/unauthorized'
+  end
+
+  def help
+    render 'console/help'
+  end
+end

data/app/controllers/domain_aware.rb

@@ -0,0 +1,26 @@
+module DomainAware
+  extend ActiveSupport::Concern
+
+  included do
+    around_filter DomainSessionSweeper
+  end
+
+  def user_default_domain
+    @domain ||= begin
+      if name = session[:domain]
+        logger.debug "  Using cached domain #{name}"
+        Domain.new({:id => name, :as => current_user}, true)
+      else
+        Domain.find(:one, :as => current_user).tap do |domain|
+          session[:domain] = domain.id
+        end
+      end
+    end
+  end
+
+  def domain_is_missing
+    session.delete :domain
+  end
+end
+RestApi::Base.observers << DomainSessionSweeper
+DomainSessionSweeper.instance