openshift-origin-controller 1.3.2

data/COPYRIGHT

@@ -0,0 +1 @@
+Copyright 2012 Red Hat, Inc. and/or its affiliates.

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in openshift-origin-controller.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,12 @@
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

data/README.md

@@ -0,0 +1,3 @@
+Notice of Export Control Law
+
+This software distribution includes cryptographic software that is subject to the U.S. Export Administration Regulations (the "*EAR*") and other U.S. and foreign laws and may not be exported, re-exported or transferred (a) to any country listed in Country Group E:1 in Supplement No. 1 to part 740 of the EAR (currently, Cuba, Iran, North Korea, Sudan & Syria); (b) to any prohibited destination or to any end user who has been prohibited from participating in U.S. export transactions by any federal agency of the U.S. government; or (c) for use in connection with the design, development or production of nuclear, chemical or biological weapons, or rocket systems, space launch vehicles, or sounding rockets, or unmanned air vehicle systems.You may not download this software or technical information if you are located in one of these countries or otherwise subject to these restrictions. You may not provide this software or technical information to individuals or entities located in one of these countries or otherwise subject to these restrictions. You are also responsible for compliance with foreign law requirements applicable to the import, export and use of this software and technical information.

data/Rakefile

@@ -0,0 +1,9 @@
+#require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end

data/app/controllers/app_events_controller.rb

@@ -0,0 +1,115 @@
+class AppEventsController < BaseController
+  respond_to :xml, :json
+  before_filter :authenticate, :check_version
+
+  # POST /domains/[domain_id]/applications/[application_id]/events
+  def create
+    domain_id = params[:domain_id]
+    id = params[:application_id]
+    event = params[:event]
+    server_alias = params[:alias]
+
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_error(:not_found, "Domain #{domain_id} not found", 127,
+                        "APPLICATION_EVENT") if !domain || !domain.hasAccess?(@cloud_user)
+
+    @domain_name = domain.namespace
+    application = get_application(id)
+    return render_error(:not_found, "Application '#{id}' not found", 101,
+                        "APPLICATION_EVENT") unless application
+    
+    @application_name = application.name
+    @application_uuid = application.uuid
+    return render_error(:unprocessable_entity, "Alias must be specified for adding or removing application alias.", 126,
+                        "APPLICATION_EVENT", "event") if ['add-alias', 'remove-alias'].include?(event) && !server_alias
+    return render_error(:unprocessable_entity, "Reached gear limit of #{@cloud_user.max_gears}", 104,
+                        "APPLICATION_EVENT") if (event == 'scale-up') && (@cloud_user.consumed_gears >= @cloud_user.max_gears)
+
+    msg = "Added #{event} to application #{id}"
+    begin
+      case event
+        when "start"
+          application.start
+          msg = "Application #{id} has started"
+        when "stop"
+          application.stop
+          msg = "Application #{id} has stopped"
+        when "force-stop"
+          application.force_stop
+          msg = "Application #{id} has forcefully stopped"
+        when "restart"
+          application.restart
+          msg = "Application #{id} has restarted"
+        when "expose-port"
+          application.expose_port
+          msg = "Application #{id} has exposed port"
+        when "conceal-port"
+          application.conceal_port
+          msg = "Application #{id} has concealed port"
+        when "show-port"
+          r = application.show_port
+          msg = "Application #{id} called show port"
+          msg += ": #{r.resultIO.string.chomp}" if !r.resultIO.string.empty?
+        when "add-alias"
+          applications = Application.find_all(@cloud_user)
+          applications.each do |app|
+            app.aliases.each do |a|
+              if a.casecmp(server_alias) == 0
+                return render_error(:unprocessable_entity, "Alias already in use.", 140,
+                   "APPLICATION_EVENT", "event")
+              end 
+            end unless app.aliases.nil?
+          end
+          r = application.add_alias(server_alias)
+          msg = "Application #{id} has added alias"
+          msg += ": #{r.resultIO.string.chomp}" if !r.resultIO.string.empty?
+        when "remove-alias"
+          r = application.remove_alias(server_alias)
+          msg = "Application #{id} has removed alias"
+          msg += ": #{r.resultIO.string.chomp}" if !r.resultIO.string.empty?
+        when "scale-up"
+          application.scaleup
+          msg = "Application #{id} has scaled up"
+        when "scale-down"
+          application.scaledown
+          msg = "Application #{id} has scaled down"
+        when 'tidy'
+          r = application.tidy
+          msg = "Application #{id} called tidy"
+          msg += ": #{r.resultIO.string.chomp}" if !r.resultIO.string.empty?
+        when 'reload'
+          r = application.reload
+          msg = "Application #{id} called reload"
+          msg += ": #{r.resultIO.string.chomp}" if !r.resultIO.string.empty?
+        when "thread-dump"
+          r = application.threaddump
+          msg = !r.errorIO.string.empty? ? r.errorIO.string.chomp : r.resultIO.string.chomp
+          #TODO: We need to reconsider how we are reporting messages to the client
+          success_msg = "Application event '#{event}' successful" unless msg.include?("not supported")
+          message = Message.new(:result, msg, 0)
+          application = get_application(id)
+          if $requested_api_version >= 1.2
+            app = RestApplication12.new(application, get_url, nolinks)
+          else
+            app = RestApplication10.new(application, get_url, nolinks)
+          end
+          render_success(:ok, "application", app, "#{event.sub('-', '_').upcase}_APPLICATION",
+			   success_msg, true, nil, [message])
+	  return
+       else
+          return render_error(:unprocessable_entity, "Invalid application event '#{event}' specified",
+                              126, "APPLICATION_EVENT", "event")
+        end
+    rescue Exception => e
+      return render_exception(e, "#{event.sub('-', '_').upcase}_APPLICATION")
+    end
+    application = get_application(id)
+    if $requested_api_version >= 1.2
+      app = RestApplication12.new(application, get_url, nolinks)
+    else
+      app = RestApplication10.new(application, get_url, nolinks)
+    end
+    render_success(:ok, "application", app, "#{event.sub('-', '_').upcase}_APPLICATION",
+                   "Application event '#{event}' successful", true)
+  end
+end

data/app/controllers/application_templates_controller.rb

@@ -0,0 +1,19 @@
+class ApplicationTemplatesController < BaseController
+  respond_to :xml, :json
+  before_filter :check_version
+
+  def index
+    templates = ApplicationTemplate.find_all.map{|t| RestApplicationTemplate.new(t, get_url, nolinks)}
+    render_success(:ok, "application_templates", templates, "LIST_TEMPLATES", "Showing all templates")
+  end
+  
+  def show
+    id_or_tag = params[:id]
+    template = ApplicationTemplate.find(id_or_tag)
+    return render_success(:ok, "application_template", RestApplicationTemplate.new(template, get_url, nolinks),
+                          "SHOW_TEMPLATE", "Showing template for '#{id_or_tag}'") if template
+
+    templates = ApplicationTemplate.find_all(id_or_tag).map{|t| RestApplicationTemplate.new(t, get_url, nolinks)}
+    render_success(:ok, "application_templates", templates, "LIST_TEMPLATES",  "Showing template for '#{id_or_tag}'")
+  end
+end

data/app/controllers/applications_controller.rb

@@ -0,0 +1,214 @@
+class ApplicationsController < BaseController
+  respond_to :xml, :json
+  before_filter :authenticate, :check_version
+  include LegacyBrokerHelper
+  include CartridgeHelper
+  # GET /domains/[domain id]/applications
+  def index
+    domain_id = params[:domain_id]
+
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_error(:not_found, "Domain '#{domain_id}' not found", 127,
+                        "LIST_APPLICATIONS") if !domain || !domain.hasAccess?(@cloud_user)
+
+    @domain_name = domain.namespace
+    applications = Application.find_all(@cloud_user)
+    apps = Array.new
+    include_cartridges = (params[:include] == "cartridges")
+    
+    applications.each do |application|
+      if application.domain.uuid = domain.uuid
+        if $requested_api_version == 1.0
+          app = RestApplication10.new(application, get_url, nolinks)
+        elsif $requested_api_version < 1.3
+          app = RestApplication12.new(application, get_url, nolinks)
+        else
+          app = RestApplication.new(application, get_url, nolinks)
+        end
+        if include_cartridges
+          app.cartridges = get_cartridges(application)
+        end
+        apps.push(app)
+      end
+    end if applications
+    render_success(:ok, "applications", apps, "LIST_APPLICATIONS", "Found #{apps.length} applications for domain '#{domain_id}'")
+  end
+  
+  # GET /domains/[domain_id]/applications/<id>
+  def show
+    domain_id = params[:domain_id]
+    id = params[:id]
+    
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_error(:not_found, "Domain '#{domain_id}' not found", 127,
+                        "SHOW_APPLICATION") if !domain || !domain.hasAccess?(@cloud_user)
+
+    @domain_name = domain.namespace
+    application = get_application(id)
+    return render_error(:not_found, "Application '#{id}' not found", 101,
+                        "SHOW_APPLICATION") if !application or application.domain.uuid != domain.uuid
+
+    @application_name = application.name
+    @application_uuid = application.uuid
+    if $requested_api_version == 1.0
+      app = RestApplication10.new(application, get_url, nolinks)
+    elsif $requested_api_version < 1.3
+      app = RestApplication12.new(application, get_url, nolinks)
+    else
+      app = RestApplication.new(application, get_url, nolinks)
+    end
+    include_cartridges = (params[:include] == "cartridges")
+    if include_cartridges
+      app.cartridges = get_cartridges(application)
+    end
+    render_success(:ok, "application", app, "SHOW_APPLICATION", "Application '#{id}' found")
+  end
+  
+  # POST /domains/[domain_id]/applications
+  def create
+    domain_id = params[:domain_id]
+    app_name = params[:name]
+    cartridges = Array(params[:cartridges] || params[:cartridge])
+    scale = get_bool(params[:scale])
+    init_git_url = params[:initial_git_url]
+    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)
+    
+    @domain_name = domain.namespace
+    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(template_id)
+      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
+      framework_cartridges = []
+      other_cartridges = []
+      Rails.logger.debug "Selected cartridges: #{cartridges.inspect}"
+      carts = get_cached("cart_list_standalone", :expires_in => 21600.seconds) {Application.get_available_cartridges("standalone")}
+      if !cartridges
+        
+        return render_error(:unprocessable_entity, "You must specify a cartridge. Valid values are (#{carts.join(', ')})",
+                            109, "ADD_APPLICATION", "cartridge")
+      else
+        cartridges.each do |cart|
+          framework_cartridges.push(cart) unless not carts.include?(cart)
+          other_cartridges.push(cart) unless carts.include?(cart)
+        end
+        if framework_cartridges.empty?
+          return render_error(:unprocessable_entity, "Each application must contain one web cartridge.  None of the specified cartridges #{cartridges.to_sentence} is a web cartridge. Please include one of the following cartridges: #{carts.to_sentence}.",
+                            109, "ADD_APPLICATION", "cartridge")
+        elsif framework_cartridges.length > 1
+          return render_error(:unprocessable_entity, "Each application must contain only one web cartridge.  Please include a single web cartridge from this list: #{carts.to_sentence}.",
+                            109, "ADD_APPLICATION", "cartridge")
+        end
+      end
+      begin
+        application = Application.new(@cloud_user, app_name, nil, node_profile, framework_cartridges[0], nil, scale, domain, init_git_url)
+      rescue Exception => e
+        return render_error(:internal_server_error, "Error returned from server #{e.message}", 1, "ADD_APPLICATION")
+      end
+    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
+ 
+    @application_name = application.name
+    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
+      cart_reply = []
+      other_cartridges.each do |cart|
+        cart_reply << application.add_dependency(cart)
+      end if other_cartridges and !other_cartridges.empty?
+      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}", get_extra_log_args)
+        application.destroy_dns
+        raise
+      end
+    rescue Exception => e
+      application.destroy(true)
+      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)
+    elsif $requested_api_version < 1.3
+      app = RestApplication12.new(application, get_url, nolinks)
+    else
+      app = RestApplication.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
+    cart_reply.each do |reply|
+      messages.push(Message.new(:info, reply.resultIO.string, 0, :result))
+    end unless cart_reply.empty?
+    include_cartridges = (params[:include] == "cartridges")
+    if include_cartridges
+      app.cartridges = get_cartridges(application)
+    end
+    render_success(:created, "application", app, "ADD_APPLICATION", log_msg, nil, nil, messages) 
+  end
+  
+  # DELELTE domains/[domain_id]/applications/[id]
+  def destroy
+    domain_id = params[:domain_id]
+    id = params[:id]
+    
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_format_error(:not_found, "Domain #{domain_id} not found", 127,
+                               "DELETE_APPLICATION") if !domain || !domain.hasAccess?(@cloud_user)
+    
+    @domain_name = domain.namespace
+    application = get_application(id)
+    return render_format_error(:not_found, "Application #{id} not found.", 101,
+                               "DELETE_APPLICATION") if !application or application.domain.uuid != domain.uuid
+    
+    @application_name = application.name
+    @application_uuid = application.uuid
+    begin
+      Rails.logger.debug "Deleting application #{id}"
+      application.cleanup_and_delete()
+    rescue Exception => e
+      return render_format_exception(e, "DELETE_APPLICATION")
+    end
+    render_format_success(:no_content, nil, nil, "DELETE_APPLICATION", "Application #{id} is deleted.", true) 
+  end
+end

data/app/controllers/base_controller.rb

@@ -0,0 +1,367 @@
+require 'action_dispatch/http/mime_types'
+module Mime
+  class Type
+    class << self
+      def lookup(string)
+         LOOKUP[string.split(';').first]
+       end
+    end
+  end
+end
+class BaseController < ActionController::Base
+  respond_to :json, :xml
+  before_filter :check_version, :only => :show
+  before_filter :check_nolinks
+  API_VERSION = 1.3
+  SUPPORTED_API_VERSIONS = [1.0,1.1,1.2, 1.3]
+
+  include UserActionLogger
+  
+  # Initialize domain/app variables to be used for logging in user_action.log
+  # The values will be set in the controllers handling the requests
+  @domain_name = nil
+  @application_name = nil
+  @application_uuid = nil
+
+  def show
+    blacklisted_words = OpenShift::ApplicationContainerProxy.get_blacklisted
+    unless nolinks
+      links = {
+        "API" => Link.new("API entry point", "GET", URI::join(get_url, "api")),
+        "GET_ENVIRONMENT" => Link.new("Get environment information", "GET", URI::join(get_url, "environment")),
+        "GET_USER" => Link.new("Get user information", "GET", URI::join(get_url, "user")),      
+        "LIST_DOMAINS" => Link.new("List domains", "GET", URI::join(get_url, "domains")),
+        "ADD_DOMAIN" => Link.new("Create new domain", "POST", URI::join(get_url, "domains"), [
+          Param.new("id", "string", "Name of the domain",nil,blacklisted_words)
+        ]),
+        "LIST_CARTRIDGES" => Link.new("List cartridges", "GET", URI::join(get_url, "cartridges")),
+        "LIST_TEMPLATES" => Link.new("List application templates", "GET", URI::join(get_url, "application_templates")),
+        "LIST_ESTIMATES" => Link.new("List available estimates", "GET" , URI::join(get_url, "estimates"))
+      }
+      links.merge!(if base_url = Rails.application.config.openshift[:community_quickstarts_url]
+        base_url = URI.join(get_url, base_url).to_s
+        {
+          "LIST_QUICKSTARTS"   => Link.new("List quickstarts", "GET", URI::join(base_url, "v1/quickstarts/promoted.json")),
+          "SHOW_QUICKSTART"    => Link.new("Retrieve quickstart with :id", "GET", URI::join(base_url, "v1/quickstarts/:id"), [
+            Param.new(":id", "string", "Unique identifier of the quickstart", nil, [])
+          ]),
+          "SEARCH_QUICKSTARTS" => Link.new("Search quickstarts", "GET", URI::join(base_url, "v1/quickstarts.json"), [
+            Param.new("search", "string", "The search term to use for the quickstart", nil, [])
+          ]),
+        }
+      else
+        {
+          "LIST_QUICKSTARTS"   => Link.new("List quickstarts", "GET", URI::join(get_url, "quickstarts")),
+          "SHOW_QUICKSTART"    => Link.new("Retrieve quickstart with :id", "GET", URI::join(get_url, "quickstarts/:id"), [
+            Param.new(":id", "string", "Unique identifier of the quickstart", nil, [])
+          ]),
+        }
+      end)
+    end
+    
+    @reply = RestReply.new(:ok, "links", links)
+    respond_with @reply, :status => @reply.status
+  end
+  
+  protected
+  
+  def authenticate
+    login = nil
+    password = nil
+    @request_id = gen_req_uuid
+    
+    if request.headers['User-Agent'] == "OpenShift"
+      if params['broker_auth_key'] && params['broker_auth_iv']
+        login = params['broker_auth_key']
+        password = params['broker_auth_iv']
+      else  
+        if request.headers['broker_auth_key'] && request.headers['broker_auth_iv']
+          login = request.headers['broker_auth_key']
+          password = request.headers['broker_auth_iv']
+        end
+      end
+    end
+    if login.nil? or password.nil?
+      authenticate_with_http_basic { |u, p|
+        login = u
+        password = p
+      }
+    end      
+    begin
+      auth = OpenShift::AuthService.instance.authenticate(request, login, password)
+      @login = auth[:username]
+      @auth_method = auth[:auth_method]
+
+      if not request.headers["X-Impersonate-User"].nil?
+        @parent_user = CloudUser.find @login
+        subuser_name = request.headers["X-Impersonate-User"]
+
+        if @parent_user.nil?
+          Rails.logger.debug "#{@login} tried to impersonate user but #{@login} user does not exist"
+          raise OpenShift::AccessDeniedException.new "Insufficient privileges to access user #{subuser_name}"
+        end
+
+        if @parent_user.capabilities.nil? || !@parent_user.capabilities["subaccounts"] == true
+          Rails.logger.debug "#{@parent_user.login} tried to impersonate user but does not have require capability."
+          raise OpenShift::AccessDeniedException.new "Insufficient privileges to access user #{subuser_name}"
+        end
+
+        sub_user = CloudUser.find subuser_name
+        if sub_user && sub_user.parent_user_login != @parent_user.login
+          Rails.logger.debug "#{@parent_user.login} tried to impersinate user #{subuser_name} but does not own the subaccount."
+          raise OpenShift::AccessDeniedException.new "Insufficient privileges to access user #{subuser_name}"
+        end
+
+        if sub_user.nil?
+          Rails.logger.debug "Adding user #{subuser_name} as sub user of #{@parent_user.login} ...inside base_controller"
+          @cloud_user = CloudUser.new(subuser_name,nil,nil,nil,{},@parent_user.login)
+          @cloud_user.parent_user_login = @parent_user.login
+          init_user
+        else
+          @cloud_user = sub_user
+        end
+      else
+        @cloud_user = CloudUser.find @login
+        if @cloud_user.nil?
+          Rails.logger.debug "Adding user #{@login}...inside base_controller"
+          @cloud_user = CloudUser.new(@login)
+          init_user
+        end
+      end
+      
+      @cloud_user.auth_method = @auth_method unless @cloud_user.nil?
+    rescue OpenShift::UserException => e
+      render_format_exception(e)
+    rescue OpenShift::AccessDeniedException
+      log_action(@request_id, 'nil', login, "AUTHENTICATE", true, "Access denied")
+      request_http_basic_authentication
+    end
+  end
+
+  def init_user()
+    begin
+      @cloud_user.save
+    rescue Exception => e
+      cu = CloudUser.find @login
+      raise unless cu && (@cloud_user.parent_user_login == cu.parent_user_login)
+      @cloud_user = cu
+    end
+  end
+
+  def get_application(id)
+    app = Application.find(@cloud_user, id)
+    app.user_agent = request.headers['User-Agent'] if app
+    app
+  end
+  
+  def rest_replies_url(*args)
+    return "/broker/rest/api"
+  end
+  
+  def get_url
+    #Rails.logger.debug "Request URL: #{request.url}"
+    url = URI::join(request.url, "/broker/rest/")
+    #Rails.logger.debug "Request URL: #{url.to_s}"
+    return url.to_s
+  end
+
+  def nolinks
+    ignore_links = params[:nolinks]
+    if ignore_links
+      ignore_links.downcase!
+      return true if ["true", "1"].include?(ignore_links)
+      return false if ["false", "0"].include?(ignore_links)
+      raise OpenShift::UserException.new("Invalid value for 'nolinks'. Valid options: [true, false, 1, 0]", 167)
+    end
+    return false
+  end
+ 
+  def check_version
+    accept_header = request.headers['Accept']
+    mime_types = accept_header.split(%r{,\s*})
+    version_header = API_VERSION
+    mime_types.each do |mime_type|
+      values = mime_type.split(%r{;\s*})
+      values.each do |value|
+        value = value.downcase
+        if value.include?("version")
+          version_header = value.split("=")[1].delete(' ').to_f
+        end
+      end
+    end
+    
+    #$requested_api_version = request.headers['X_API_VERSION'] 
+    if not version_header
+      $requested_api_version = API_VERSION
+    else
+      $requested_api_version = version_header
+    end
+    
+    if not SUPPORTED_API_VERSIONS.include? $requested_api_version
+      invalid_version = $requested_api_version
+      $requested_api_version = API_VERSION
+      return render_format_error(:not_acceptable, "Requested API version #{invalid_version} is not supported. Supported versions are #{SUPPORTED_API_VERSIONS.map{|v| v.to_s}.join(",")}")
+    end
+  end
+
+  def check_nolinks
+    begin
+      nolinks
+    rescue Exception => e
+      return render_format_exception(e)
+    end
+  end
+
+  def get_bool(param_value)
+    if param_value.is_a? TrueClass or param_value.is_a? FalseClass
+      return param_value
+    elsif param_value.is_a? String and param_value.upcase == "TRUE"
+      return true
+    else
+      return false
+    end
+  end
+
+  def gen_req_uuid
+    # The request id can be generated differently to make it a bit more meaningful
+    File.open("/proc/sys/kernel/random/uuid", "r") do |file|
+      file.gets.strip.gsub("-","")
+    end
+  end
+ 
+  def get_cloud_user_info(cloud_user)
+    if cloud_user
+      return { :uuid  => cloud_user.uuid, :login => cloud_user.login }
+    else
+      return { :uuid  => 0, :login => 'anonymous' }
+    end
+  end
+
+  def get_extra_log_args
+    args = {}
+    args["APP"] = @application_name if @application_name
+    args["DOMAIN"] = @domain_name if @domain_name
+    args["APP_UUID"] = @application_uuid if @application_uuid
+    
+    return args
+  end
+  
+  def get_error_messages(object, orig_field=nil, display_field=nil)
+    messages = []
+    object.errors.keys.each do |key|
+      field = key.to_s
+      field = display_field if orig_field && (key.to_s == orig_field)
+      err_msgs = object.errors.get(key)
+      err_msgs.each do |err_msg|
+        messages.push(Message.new(:error, err_msg[:message], err_msg[:exit_code], field))
+      end if err_msgs
+    end if object && object.errors && object.errors.keys
+    return messages
+  end
+
+  #Due to the bug in rails, 'format' is explicitly used for PUT, DELETE rest calls
+  def render_response(reply, format=false)
+    if format
+      respond_with(reply) do |fmt|
+        fmt.xml { render :xml => reply, :status => reply.status }
+        fmt.json { render :json => reply, :status => reply.status }
+      end
+    else
+      respond_with reply, :status => reply.status
+    end
+  end
+
+  def render_error_internal(status, msg, err_code=nil, log_tag=nil,
+                            field=nil, msg_type=nil, messages=nil, format=false, internal_error=false)
+    reply = RestReply.new(status)
+    user_info = get_cloud_user_info(@cloud_user)
+
+    logger_msg = nil
+    if msg
+      msg_type = :error unless msg_type
+      reply.messages.push(Message.new(msg_type, msg, err_code, field))
+      logger_msg = msg
+    end
+    if messages && !messages.empty?
+      reply.messages.concat(messages)
+      unless logger_msg
+        msg = []
+        messages.each { |m| msg.push(m.text) }
+        logger_msg = msg.join(', ')
+      end
+    end
+    log_action(@request_id, user_info[:uuid], user_info[:login], log_tag, !internal_error, logger_msg, get_extra_log_args) if log_tag
+    render_response(reply, format)
+  end
+
+  def render_exception_internal(ex, log_tag, format)
+    Rails.logger.error ex
+    Rails.logger.error ex.backtrace
+
+    error_code = ex.respond_to?('code') ? ex.code : 1
+    message = ex.message
+    if ex.kind_of? OpenShift::UserException
+      status = :unprocessable_entity
+    elsif ex.kind_of? OpenShift::DNSException
+      status = :service_unavailable
+    elsif ex.kind_of? OpenShift::NodeException
+      status = :internal_server_error
+      if ex.resultIO && ex.resultIO.errorIO
+        error_code = ex.resultIO.exitcode
+        message = ex.resultIO.errorIO.string.strip
+      end
+    else
+      status = :internal_server_error
+    end
+    
+    internal_error = status != :unprocessable_entity
+    render_error_internal(status, message, error_code, log_tag, nil, nil, nil, format, internal_error)
+  end
+
+  def render_success_internal(status, type, data, log_tag, log_msg=nil, publish_msg=false,
+                              msg_type=nil, messages=nil, format=false)
+    reply = RestReply.new(status, type, data)
+    user_info = get_cloud_user_info(@cloud_user)
+
+    logger_msg = nil
+    if log_msg
+      msg_type = :info unless msg_type
+      reply.messages.push(Message.new(msg_type, log_msg)) if publish_msg
+      logger_msg = log_msg
+    end
+    if messages && !messages.empty?
+      reply.messages.concat(messages)
+      unless logger_msg
+        msg = []
+        messages.each { |m| msg.push(m.text) }
+        logger_msg = msg.join(', ')
+      end
+    end
+    log_action(@request_id, user_info[:uuid], user_info[:login], log_tag, true, logger_msg, get_extra_log_args) if log_tag
+    render_response(reply, format)
+  end
+
+  def render_format_error(status, msg, err_code=nil, log_tag=nil, field=nil, msg_type=nil, messages=nil)
+    render_error_internal(status, msg, err_code, log_tag, field, msg_type, messages, true)
+  end
+
+  def render_format_exception(ex, log_tag=nil)
+    render_exception_internal(ex, log_tag, true)
+  end
+
+  def render_format_success(status, type, data, log_tag, log_msg=nil, publish_msg=false, msg_type=nil, messages=nil)
+    render_success_internal(status, type, data, log_tag, log_msg, publish_msg, msg_type, messages, true)
+  end
+
+  def render_error(status, msg, err_code=nil, log_tag=nil, field=nil, msg_type=nil, messages=nil)
+    render_error_internal(status, msg, err_code, log_tag, field, msg_type, messages, false)
+  end
+
+  def render_exception(ex, log_tag=nil)
+    render_exception_internal(ex, log_tag, false)
+  end
+
+  def render_success(status, type, data, log_tag, log_msg=nil, publish_msg=false, msg_type=nil, messages=nil)
+    render_success_internal(status, type, data, log_tag, log_msg, publish_msg, msg_type, messages, false)
+  end
+end