openshift-origin-controller 1.3.2

data/app/controllers/cartridges_controller.rb

@@ -0,0 +1,48 @@
+class CartridgesController < BaseController
+  respond_to :xml, :json
+  before_filter :check_version
+  include LegacyBrokerHelper
+  
+  def show
+    index
+  end
+  
+  # GET /cartridges
+  def index
+    type = params[:id]
+    
+    cartridges = Array.new
+    if type.nil? or type == "standalone"
+      cart_type = "standalone"
+      cache_key = "cart_list_#{cart_type}"
+      carts = get_cached(cache_key, :expires_in => 21600.seconds) do
+        Application.get_available_cartridges(cart_type)
+      end
+      carts.each do |cart|
+        if $requested_api_version >= 1.1
+          cartridge = RestCartridge11.new(cart_type, cart, nil, get_url, nil, nolinks)
+        else
+          cartridge = RestCartridge10.new(cart_type, cart, nil, get_url, nil, nolinks)
+        end
+        cartridges.push(cartridge)
+      end
+    end
+    
+    if type.nil? or type == "embedded"
+      cart_type = "embedded"
+      cache_key = "cart_list_#{cart_type}"
+      carts = get_cached(cache_key, :expires_in => 21600.seconds) do
+        Application.get_available_cartridges(cart_type)
+      end
+      carts.each do |cart|
+	    if $requested_api_version >= 1.1
+          cartridge = RestCartridge11.new(cart_type, cart, nil, get_url, nil, nolinks)
+        else
+          cartridge = RestCartridge10.new(cart_type, cart, nil, get_url, nil, nolinks)
+        end
+        cartridges.push(cartridge)
+      end
+    end
+    render_success(:ok, "cartridges", cartridges, "LIST_CARTRIDGES", "List #{type.nil? ? 'all' : type} cartridges") 
+  end
+end

data/app/controllers/descriptors_controller.rb

@@ -0,0 +1,23 @@
+class DescriptorsController < BaseController
+  respond_to :xml, :json
+  before_filter :authenticate, :check_version
+  
+  def show
+    domain_id = params[:domain_id]
+    application_id = params[:application_id]
+    
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_error(:not_found, "Domain #{domain_id} not found", 127,
+                        "SHOW_DESCRIPTOR") if !domain || !domain.hasAccess?(@cloud_user)
+
+    @domain_name = domain.namespace
+    application = Application.find(@cloud_user,application_id)
+    return render_error(:not_found, "Application '#{application_id}' not found for domain '#{domain_id}'",
+                        101, "SHOW_DESCRIPTOR") unless application
+    
+    @application_name = application.name
+    @application_uuid = application.uuid
+    render_success(:ok, "descriptor", application.to_descriptor.to_yaml, "SHOW_DESCRIPTOR",
+                   "Show descriptor for application '#{application_id}' for domain '#{domain_id}'")
+  end
+end

data/app/controllers/dns_resolvable_controller.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'dnsruby'
+
+class DnsResolvableController < BaseController
+  respond_to :xml, :json
+  before_filter :authenticate, :check_version
+  
+  # GET /domains/[domain_id]/applications/<id>/dns_resolvable
+  def show
+    domain_id = params[:domain_id]
+    id = params[:application_id]
+    
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_error(:not_found, "Domain #{domain_id} not found", 127,
+                        "DNS_RESOLVABLE") if !domain || !domain.hasAccess?(@cloud_user)
+
+    @domain_name = domain.namespace
+    application = Application.find(@cloud_user,id)
+    return render_error(:not_found, "Application '#{id}' not found", 101,
+                        "DNS_RESOLVABLE") unless application
+                        
+    @application_name = application.name
+    @application_uuid = application.uuid
+    name = "#{application.name}-#{application.domain.namespace}.#{Rails.configuration.openshift[:domain_suffix]}" 
+    nameservers = NameServerCache.get_name_servers             
+    
+    dns = Dnsruby::Resolver.new(:nameserver => nameservers[rand(nameservers.length)])
+    begin
+      dns.query(name, Dnsruby::Types.A)
+      render_success(:ok, "boolean", true, "DNS_RESOLVABLE", "Resolved DNS #{name}")
+    rescue 
+      render_error(:not_found, "Could not resolve DNS #{name}", 170, "DNS_RESOLVABLE")
+    end
+  end
+end

data/app/controllers/domains_controller.rb

@@ -0,0 +1,156 @@
+class DomainsController < BaseController
+  respond_to :xml, :json
+  before_filter :authenticate, :check_version
+
+  # GET /domains
+  def index
+    domains = Array.new
+    Rails.logger.debug "Getting domains for user #{@cloud_user.login}"
+    Rails.logger.debug @cloud_user.domains
+    @cloud_user.domains.each do |domain|
+      if $requested_api_version >= 1.3
+          domains.push(RestDomain.new(domain, get_url, nolinks))
+      else
+          domains.push(RestDomain10.new(domain, get_url, nolinks))
+      end
+    end
+    render_success(:ok, "domains", domains, "LIST_DOMAINS")
+  end
+
+  # GET /domains/<id>
+  def show
+    id = params[:id]
+    Rails.logger.debug "Getting domain #{id}"
+
+    domain = Domain.get(@cloud_user, id)
+    if domain and domain.hasAccess?(@cloud_user)
+      @domain_name = domain.namespace
+      if $requested_api_version >= 1.3
+        domain = RestDomain.new(domain, get_url, nolinks)
+      else
+        domain = RestDomain10.new(domain, get_url, nolinks)
+      end
+      return render_success(:ok, "domain", domain, "SHOW_DOMAIN", "Found domain #{id}")
+    end
+    render_error(:not_found, "Domain #{id} not found.", 127, "SHOW_DOMAIN")
+  end
+
+  # POST /domains
+  def create
+    namespace = params[:id]
+    Rails.logger.debug "Creating domain with namespace #{namespace}"
+
+    domain = Domain.new(namespace, @cloud_user)
+    if not domain.valid?
+      Rails.logger.error "Domain is not valid"
+      messages = get_error_messages(domain, "namespace", "id")
+      return render_error(:unprocessable_entity, nil, nil, "ADD_DOMAIN", nil, nil, messages)
+    end
+
+    begin
+      dom_available = Domain.namespace_available?(namespace)
+    rescue Exception => e
+      return render_exception(e, "ADD_DOMAIN") 
+    end
+
+    return render_error(:unprocessable_entity, "Namespace '#{namespace}' is already in use. Please choose another.", 103, "ADD_DOMAIN", "id") if !dom_available 
+
+    return render_error(:conflict, "Domain already exists for user. Update the domain to modify.", 158, "ADD_DOMAIN") if !@cloud_user.domains.empty?
+
+    @domain_name = namespace
+    begin
+      domain.save
+    rescue Exception => e
+      return render_exception(e, "ADD_DOMAIN") 
+    end
+
+    if $requested_api_version >= 1.3
+      domain = RestDomain.new(domain, get_url, nolinks)
+    else
+      domain = RestDomain10.new(domain, get_url, nolinks)
+    end
+    render_success(:created, "domain", domain, "ADD_DOMAIN", "Created domain with namespace #{namespace}", true)
+  end
+
+  # PUT /domains/<existing_id>
+  def update
+    id = params[:existing_id]
+    new_namespace = params[:id]
+    domain = Domain.get(@cloud_user, id)
+
+    new_domain = Domain.new(new_namespace, @cloud_user)
+    if not new_domain.valid?
+      messages = get_error_messages(new_domain, "namespace", "id")
+      return render_format_error(:unprocessable_entity, nil, nil, "UPDATE_DOMAIN", nil, nil, messages)
+    end
+    return render_format_error(:not_found, "Domain '#{id}' not found", 127, 
+                               "UPDATE_DOMAIN") if !domain || !domain.hasAccess?(@cloud_user)
+
+    return render_format_error(:forbidden, "User does not have permission to modify domain '#{id}'",
+                               132, "UPDATE_DOMAIN") if domain && !domain.hasFullAccess?(@cloud_user)
+
+    Rails.logger.debug "Updating domain #{domain.namespace} to #{new_namespace}"
+    begin
+      dom_available = Domain.namespace_available?(new_namespace)
+    rescue Exception => e
+      return render_format_exception(e, "UPDATE_DOMAIN") 
+    end
+
+    return render_format_error(:unprocessable_entity, "Namespace '#{new_namespace}' already in use. Please choose another.",
+                               103, "UPDATE_DOMAIN", "id") if !dom_available
+
+    domain.namespace = new_namespace
+    if domain.invalid?
+      messages = get_error_messages(domain, "namespace", "id")
+      return render_format_error(:unprocessable_entity, nil, nil, "UPDATE_DOMAIN", nil, nil, messages)
+    end
+
+    @domain_name = id
+    begin
+      domain.save
+    rescue Exception => e
+      return render_format_exception(e, "UPDATE_DOMAIN") 
+    end
+
+    @cloud_user = CloudUser.find(@login)
+    if $requested_api_version >= 1.3
+      domain = RestDomain.new(domain, get_url, nolinks)
+    else
+      domain = RestDomain10.new(domain, get_url, nolinks)
+    end
+    render_format_success(:ok, "domain", domain, "UPDATE_DOMAIN", "Updated domain #{id} to #{new_namespace}")
+  end
+
+  # DELETE /domains/<id>
+  def destroy
+    id = params[:id]
+    force = get_bool(params[:force])
+
+    domain = Domain.get(@cloud_user, id)
+    return render_format_error(:not_found, "Domain #{id} not found", 127,
+                               "DELETE_DOMAIN") if !domain || !domain.hasAccess?(@cloud_user)
+
+    return render_format_error(:forbidden, "User does not have permission to delete domain '#{id}'",
+                               132, "DELETE_DOMAIN") if domain && !domain.hasFullAccess?(@cloud_user)
+
+    if force
+      Rails.logger.debug "Force deleting domain #{id}"
+      @cloud_user.applications.each do |app|
+        app.cleanup_and_delete if app.domain.uuid == domain.uuid
+      end if @cloud_user.applications
+    else
+      @cloud_user.applications.each do |app|
+        return render_format_error(:bad_request, "Domain contains applications. Delete applications first or set force to true.", 
+                                   128, "DELETE_DOMAIN") if app.domain.uuid == domain.uuid
+      end if @cloud_user.applications
+    end
+
+    @domain_name = id
+    begin
+      domain.delete
+      render_format_success(:no_content, nil, nil, "DELETE_DOMAIN", "Domain #{id} deleted.", true)
+    rescue Exception => e
+      return render_format_exception(e, "DELETE_DOMAIN") 
+    end
+  end
+end

data/app/controllers/emb_cart_controller.rb

@@ -0,0 +1,276 @@
+class EmbCartController < BaseController
+  respond_to :xml, :json
+  before_filter :authenticate, :check_version
+  include LegacyBrokerHelper
+  include CartridgeHelper
+
+  # GET /domains/[domain_id]/applications/[application_id]/cartridges
+  def index
+    domain_id = params[:domain_id]
+    id = params[:application_id]
+
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_error(:not_found, "Domain #{domain_id} not found", 127,
+                        "LIST_APP_CARTRIDGES") if !domain || !domain.hasAccess?(@cloud_user)
+
+    @domain_name = domain.namespace
+
+    Rails.logger.debug "Getting cartridges for application #{id} under domain #{domain_id}"
+    application = get_application(id)
+    return render_error(:not_found, "Application '#{id}' not found for domain '#{domain_id}'",
+                        101, "LIST_APP_CARTRIDGES") unless application
+    #used for user action log
+    @application_name = application.name
+    @application_uuid = application.uuid
+    
+    cartridges = get_cartridges(application)
+
+    render_success(:ok, "cartridges", cartridges, "LIST_APP_CARTRIDGES",
+                   "Listing cartridges for application #{id} under domain #{domain_id}")
+  end
+  
+  # GET /domains/[domain_id]/applications/[application_id]/cartridges/[id]
+  def show
+    domain_id = params[:domain_id]
+    application_id = params[:application_id]
+    id = params[:id]
+    #include=status_messages
+    status_messages = (params[:include] == "status_messages")
+    
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_error(:not_found, "Domain #{domain_id} not found", 127,
+                        "SHOW_APP_CARTRIDGE") if !domain || !domain.hasAccess?(@cloud_user)
+    #used for user action log
+    @domain_name = domain.namespace
+    Rails.logger.debug "Getting cartridge #{id} for application #{application_id} under domain #{domain_id}"
+    application = get_application(application_id)
+    return render_error(:not_found, "Application '#{application_id}' not found for domain '#{domain_id}'",
+                        101, "SHOW_APP_CARTRIDGE") if !application
+   
+    @application_name = application.name
+    @application_uuid = application.uuid
+    cartridge = nil 
+    application.embedded.each do |key, value|
+      if key == id
+        app_status = application.status(key, false) if status_messages
+        if $requested_api_version == 1.0
+          cartridge = RestCartridge10.new("embedded", key, application, get_url, app_status, nolinks)
+        else
+          cartridge = RestCartridge11.new("embedded", key, application, get_url, app_status, nolinks)
+        end
+        break
+      end
+    end if application.embedded
+
+    if !cartridge and id == application.framework and $requested_api_version != 1.0
+      app_status = application.status(application.framework, false) if status_messages
+      app_status.each do |gear_status|
+        #FIXME: work around until cartridge status hook provides better interface
+        message = "#{application.framework} is started."
+        message = "#{application.framework} is stopped or inaccessible." if gear_status['message'].match(/(stopped)|(inaccessible)/)
+        gear_status['message'] = message
+      end if app_status
+      cartridge = RestCartridge11.new("standalone", application.framework, application, get_url, app_status, nolinks)
+    end
+    return render_success(:ok, "cartridge", cartridge, "SHOW_APP_CARTRIDGE",
+           "Showing cartridge #{id} for application #{application_id} under domain #{domain_id}") if cartridge
+
+    render_error(:not_found, "Cartridge #{id} not found for application #{application_id}",
+                 129, "SHOW_APP_CARTRIDGE")
+  end
+
+  # POST /domains/[domain_id]/applications/[application_id]/cartridges
+  def create
+    domain_id = params[:domain_id]
+    id = params[:application_id]
+
+    name = params[:name]
+    # :cartridge param is deprecated because it isn't consistent with
+    # the rest of the apis which take :name. Leave it here because
+    # some tools may still use it
+    name = params[:cartridge] unless name
+    colocate_with = params[:colocate_with]
+
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_error(:not_found, "Domain #{domain_id} not found", 127,
+                        "EMBED_CARTRIDGE") if !domain || !domain.hasAccess?(@cloud_user)
+
+    @domain_name = domain.namespace
+    application = get_application(id)
+    return render_error(:not_found, "Application '#{id}' not found for domain '#{domain_id}'",
+                        101, "EMBED_CARTRIDGE") unless application
+
+    @application_name = application.name
+    @application_uuid = application.uuid
+    begin
+      #container = OpenShift::ApplicationContainerProxy.find_available(application.server_identity)
+      container = OpenShift::ApplicationContainerProxy.find_available(nil)
+      if not check_cartridge_type(name, container, "embedded")
+        carts = get_cached("cart_list_embedded", :expires_in => 21600.seconds) {
+                           Application.get_available_cartridges("embedded")}
+        return render_error(:bad_request, "Invalid cartridge. Valid values are (#{carts.join(', ')})",
+                            109, "EMBED_CARTRIDGE", "cartridge")
+      end
+    rescue Exception => e
+      return render_exception(e, "EMBED_CARTRIDGE")
+    end
+    
+    #TODO: Need a proper method to let us know if cart will get its own gear
+    if application.scalable && colocate_with.nil? && (@cloud_user.consumed_gears >= @cloud_user.max_gears) && name != 'jenkins-client-1.4'
+      return render_error(:unprocessable_entity, "#{@cloud_user.login} has already reached the gear limit of #{@cloud_user.max_gears}",
+                          104, "EMBED_CARTRIDGE")
+    end
+
+    cart_create_reply = ""
+    begin
+      application.add_group_override(name, colocate_with) if colocate_with
+      cart_create_reply = application.add_dependency(name)
+    rescue Exception => e
+      return render_exception(e, "EMBED_CARTRIDGE")
+    end
+
+    application = get_application(id)
+
+    application.embedded.each do |key, value|
+      if key == name
+        if $requested_api_version == 1.0
+          cartridge = RestCartridge10.new("embedded", key, application, get_url, nil, nolinks)
+        else
+          cartridge = RestCartridge11.new("embedded", key, application, get_url, nil, nolinks)
+        end
+        messages = []
+        log_msg = "Added #{name} to application #{id}"
+        messages.push(Message.new(:info, log_msg))
+        messages.push(Message.new(:info, cart_create_reply.resultIO.string, 0, :result))
+        messages.push(Message.new(:info, cart_create_reply.appInfoIO.string, 0, :appinfo))
+        return render_success(:created, "cartridge", cartridge, "EMBED_CARTRIDGE", log_msg, nil, nil, messages)
+
+      end
+    end if application.embedded
+    render_error(:internal_server_error, "Cartridge #{name} not embedded within application #{id}", nil, "EMBED_CARTRIDGE")
+  end
+
+  # DELETE /domains/[domain_id]/applications/[application_id]/cartridges/[id]
+  def destroy
+    domain_id = params[:domain_id]
+    id = params[:application_id]
+    cartridge = params[:id]
+
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_format_error(:not_found, "Domain #{domain_id} not found", 127,
+                               "REMOVE_CARTRIDGE") if !domain || !domain.hasAccess?(@cloud_user)
+
+    @domain_name = domain.namespace
+    application = get_application(id)
+    return render_format_error(:not_found, "Application '#{id}' not found for domain '#{domain_id}'",
+                               101, "REMOVE_CARTRIDGE") unless application
+    
+    @application_name = application.name
+    @application_uuid = application.uuid
+    return render_format_error(:bad_request, "Cartridge #{cartridge} not embedded within application #{id}",
+                               129, "REMOVE_CARTRIDGE") if !application.embedded or !application.embedded.has_key?(cartridge)
+
+    begin
+      Rails.logger.debug "Removing #{cartridge} from application #{id}"
+      application.remove_dependency(cartridge)
+    rescue Exception => e
+      return render_format_exception(e, "REMOVE_CARTRIDGE")
+    end
+      
+    application = get_application(id)
+    if $requested_api_version == 1.0
+      app = RestApplication10.new(application, get_url, nolinks)
+    else
+      app = RestApplication12.new(application, get_url, nolinks)
+    end
+    render_format_success(:ok, "application", app, "REMOVE_CARTRIDGE", "Removed #{cartridge} from application #{id}", true)
+  end
+
+  # UPDATE /domains/[domain_id]/applications/[application_id]/cartridges/[id]
+  def update
+    domain_id = params[:domain_id]
+    app_id = params[:application_id]
+    cartridge_name = params[:id]
+    additional_storage = params[:additional_gear_storage]
+    scales_from = params[:scales_from]
+    scales_to = params[:scales_to]
+    
+    domain = Domain.get(@cloud_user, domain_id)
+    return render_format_error(:not_found, "Domain #{domain_id} not found", 127,
+                        "UPDATE_CARTRIDGE") if !domain || !domain.hasAccess?(@cloud_user)
+
+    @domain_name = domain.namespace
+    application = get_application(app_id)
+    return render_format_error(:not_found, "Application '#{app_id}' not found for domain '#{domain_id}'",
+                        101, "UPDATE_CARTRIDGE") unless application
+    #used for user action log
+    @application_name = application.name
+    @application_uuid = application.uuid
+    return render_format_error(:bad_request, "Cartridge #{cartridge_name} for application #{app_id} not found",
+                               129, "UPDATE_CARTRIDGE") if ((!application.embedded or !application.embedded.has_key?(cartridge_name)) and application.framework!=cartridge_name)              
+    
+    storage_map = {}
+    application.comp_instance_map.values.each do |cinst|
+      if cinst.parent_cart_name==cartridge_name
+        group_name = cinst.group_instance_name
+        storage_map[group_name] = [] unless storage_map.has_key?(group_name)
+        storage_map[group_name] << cinst
+      end
+    end
+    return render_format_error(:not_found, "Cartridge '#{cartridge_name}' for application '#{app_id}' not found",
+                        129, "UPDATE_CARTRIDGE") unless storage_map.keys.length>0
+                
+    #only update attributes that are specified                  
+    if additional_storage and additional_storage!=0
+      max_storage = @cloud_user.capabilities['max_storage_per_gear']
+      return render_format_error(:forbidden, "User is not allowed to change storage quota", 164,
+                                 "UPDATE_CARTRIDGE") unless max_storage
+      num_storage = nil
+      begin 
+        num_storage = Integer(additional_storage)
+      rescue => e
+        return render_format_error(:unprocessable_entity, "Invalid storage value provided.", 165, "UPDATE_CARTRIDGE", "additional_gear_storage")
+      end
+      begin
+        # first check against max_storage limit
+        storage_map.each do |group_name, component_instance_list|
+          ginst = application.group_instance_map[group_name]
+          current_sum = 0
+          component_instance_list.each { |cinst| current_sum += cinst.addtl_fs_gb }
+          current_sum = ginst.addtl_fs_gb-current_sum
+          current_sum += ginst.get_cached_min_storage_in_gb
+          current_sum += num_storage
+          return render_format_error(:forbidden, "Total additional storage for all cartridges on gear should be less than max_storage_per_gear (new_storage: #{current_sum}, max: #{max_storage}).", 166, "UPDATE_CARTRIDGE", "additional_gear_storage") if current_sum>max_storage
+        end
+        # now actually change the quota
+        storage_map.each do |group_name, component_instance_list|
+          each_component_share = (Float(num_storage))/component_instance_list.length
+          ginst = application.group_instance_map[group_name]
+          component_instance_list.each { |cinst| cinst.set_additional_quota(application, each_component_share) }
+        end
+        application.save
+      rescue Exception => e
+        return render_format_exception(e, "UPDATE_CARTRIDGE")
+      end             
+    end
+
+    if scales_from or scales_to
+      begin
+        application.set_user_min_max(storage_map, scales_from, scales_to)
+      rescue OpenShift::UserException=>e
+        return render_format_error(:unprocessable_entity, e.message, 168,
+                         "UPDATE_CARTRIDGE") 
+      rescue Exception=>e
+        return render_format_error(:forbidden, e.message, 164,
+                         "UPDATE_CARTRIDGE") 
+      end
+    end
+    cart_type = cartridge_name==application.framework ? "standalone" : "embedded"
+    if $requested_api_version == 1.0
+      cartridge = RestCartridge10.new(cart_type, cartridge_name, application, get_url, nil, nolinks)
+    else
+      cartridge = RestCartridge11.new(cart_type, cartridge_name, application, get_url, nil, nolinks)
+    end
+    render_format_success(:ok, "cartridge", cartridge, "UPDATE_CARTRIDGE", "Updated #{cartridge_name} from application #{app_id}", true)
+  end
+end