openshift-origin-console 1.3.2

data/app/models/alias.rb

@@ -0,0 +1,10 @@
+#
+# The REST API model object representing a domain name alias to an application.
+#
+class Alias < RestApi::Base
+  schema do
+    string :name
+  end
+
+  belongs_to :application
+end

data/app/models/application.rb

@@ -0,0 +1,148 @@
+#
+# The REST API model object representing an application instance.
+#
+
+# Explicitly require the gear group to prevent race conditions with autoload - http://bit.ly/SVrPH3
+require 'gear_group'
+
+class Application < RestApi::Base
+  include AsyncAware
+
+  schema do
+    string :name, :creation_time
+    string :uuid, :domain_id
+    string :git_url, :app_url, :initial_git_url, :initial_git_branch
+    string :server_identity
+    string :gear_profile, :scale
+    string :building_with, :build_job_url, :building_app
+  end
+
+  custom_id :name
+  def id #FIXME provided as legacy support for accessing .name via .id
+    name
+  end
+
+  belongs_to :domain
+  alias_attribute :domain_name, :domain_id
+  alias_attribute :scalable, :scale
+
+  has_many :aliases
+  has_many :cartridges
+  has_many :gears
+  has_many :gear_groups
+
+  attr_accessible :name, :scale, :gear_profile, :cartridges, :cartridge_names, :initial_git_url, :initial_git_branch
+
+  def find_cartridge(name)
+    Cartridge.find name, child_options
+  end
+
+  def cartridges
+    persisted? ? (@cartridges ||= Cartridge.find(:all, child_options)) : []
+  end
+  def cartridges=(arr)
+    attributes[:cartridges] = Array(arr).map do |a|
+      if a.is_a?(String)
+        a
+      elsif a.respond_to?(:[])
+        a[:name] || a['name']
+      else
+        a.name
+      end
+    end
+  end
+
+  def cartridge_names
+    persisted? ? cartridges.map(&:name) : Array(attributes[:cartridges])
+  end
+  alias_method :cartridge_names=, :cartridges=
+
+  def gears
+    Gear.find :all, child_options
+  end
+  def gear_groups
+    @gear_groups ||= GearGroup.find(:all, child_options)
+  end
+  def cartridge_gear_groups
+    @cartridge_gear_groups ||= GearGroup.infer(cartridges, self)
+  end
+
+  def gear_groups_with_state
+    async{ @_gear_groups = cartridge_gear_groups }
+    async{ @_gear_groups_with_state = gear_groups }
+    join!(30)
+
+    @_gear_groups.each{ |g| g.merge_gears(@_gear_groups_with_state) }
+    @_gear_groups
+  end
+
+  def web_url
+    app_url
+  end
+
+  #FIXME would prefer this come from REST API
+  def ssh_url
+    uri = URI.parse(git_url)
+    uri.scheme = 'ssh'
+    uri.path = ''
+    uri.fragment = nil
+    uri
+  end
+
+  # Helper to return the segment that would be provided for command line calls
+  def ssh_string
+    uri = ssh_url
+    user = "#{uri.userinfo}@" if uri.userinfo
+    port = ":#{uri.port}" if uri.port
+    [user,uri.host,port].join
+  end
+
+  def framework_name
+    @framework_name ||= CartridgeType.cached.find(framework, :as => as).display_name rescue framework
+  end
+
+  def embedded
+    @attributes[:embedded]
+  end
+
+  def scales?
+    scale
+  end
+
+  def scale_status_url
+    "#{web_url}haproxy-status/"
+  end
+
+  def builds?
+    building_with.present?
+  end
+
+  # FIXME it is assumed that eventually this will be server functionality
+  def destroy_build_cartridge
+    return true if !builds?
+    cart = Cartridge.new({:application => self, :as => as, :name => building_with}, true)
+    cart.destroy
+  rescue ActiveResource::ConnectionError => e
+    raise unless set_remote_errors(e, true)
+    #end.tap{ |success| cart.errors.full_messages.each{ |m| errors.add(:base, m) } unless success }
+  end
+
+  def reload
+    @gear_groups = nil
+    @cartridge_gear_groups = nil
+    super
+  end
+
+  protected
+    def child_options
+      { :params => { :domain_id => domain_id, :application_name => self.name},
+        :as => as }
+    end
+
+    class << self
+      def rescue_parent_missing(e, options=nil)
+        parent = RestApi::ResourceNotFound.new(Domain.model_name, (options[:params][:domain_id] rescue nil), e.response)
+        raise parent if parent.domain_missing?
+      end
+    end
+end

data/app/models/application_associations.rb

@@ -0,0 +1,36 @@
+module ApplicationAssociations
+
+  def self.when_belongs_to(klass, options)
+    klass.prefix = "#{RestApi::Base.prefix}domains/:domain_id/applications/:application_name/"
+    klass.class_eval do
+      schema do
+        string :application_name
+      end
+      def application_name=(id)
+        if self.prefix_options[:application_name].nil?
+          self.prefix_options[:application_name] = id
+        else
+          super
+        end
+      end
+      def application_name
+        super or self.prefix_options[:application_name]
+      end
+      def domain_id=(id)
+        self.prefix_options[:domain_id] = id
+      end
+      def domain_id
+        self.prefix_options[:domain_id]
+      end
+      def application
+        Application.find application_name, :params => {:domain_id => domain_id}, :as => as
+      end
+      def application=(application)
+        self.application_name = application.name
+        self.domain_id = application.domain_id
+        self.as = application.as if self.as.nil?
+      end
+    end
+  end
+
+end

data/app/models/application_template.rb

@@ -0,0 +1,90 @@
+class ApplicationTemplate < RestApi::Base
+  allow_anonymous
+
+  schema do
+    string :descriptor_yaml, :display_name
+  end
+
+  custom_id :name
+
+  [:description, :website, :version, :git_url, :git_project_url].each do |s|
+    define_attribute_method s
+    define_method s do
+      metadata.attributes[s]
+    end
+  end
+  {:name => 'Name', :provides => 'Requires'}.each_pair do |s,v|
+    define_attribute_method s
+    define_method s do
+      descriptor[v]
+    end
+  end
+
+  def descriptor
+    @descriptor ||= YAML.load(descriptor_yaml) || {}
+  end
+
+  def display_name
+    attributes['display_name'] || name
+  end
+  def tags
+    @tags ||= super.map{|t| t.to_sym} << :template
+  end
+  alias_method :categories, :tags
+
+  def provides
+    Array(super)
+  end
+
+  def template
+    self
+  end
+
+  def credentials
+    creds = metadata.attributes[:credentials]
+    creds.map{|x| x.attributes.to_hash } unless creds.nil?
+  end
+
+  def credentials_message
+    creds = credentials
+    return if creds.blank?
+
+    str =  "Your application contains pre-configured accounts, here are their credentials. " +
+           "You may want to change them as soon as possible.\n"
+
+    credentials.each do |cred|
+      str << "\n"
+      [:username, :password].each do |type|
+        str << "%s: %s\n" % [type.to_s.upcase,cred[type.to_s]]
+      end
+    end
+
+    str
+  end
+
+  def scalable
+    false
+  end
+  alias_method :scalable?, :scalable
+
+  def cartridges
+    @cartridges ||= descriptor['Requires'] || []
+  end
+
+  alias_method :initial_git_url, :git_url
+  def initial_git_branch
+    nil
+  end
+
+  cache_find_method :single, lambda{ |*args| [:template, :find, :by_id, args.shift] }
+  cache_find_method :every
+
+  protected
+    def self.find_single(s, opts=nil)
+      all(opts).find{ |t| t.name == s }
+    end
+
+    def self.disabled?
+      !RestApi.info.link('LIST_TEMPLATES') rescue true
+    end
+end

data/app/models/application_type.rb

@@ -0,0 +1,258 @@
+class ApplicationType
+  include ActiveModel::Conversion
+  include ActiveModel::MassAssignmentSecurity
+  include RestApi::Cacheable
+  extend ActiveModel::Naming
+
+  PROTECTED_TAGS = [:new, :premium, :blacklist, :featured]
+  def self.user_tags(tags)
+    tags - PROTECTED_TAGS
+  end
+
+  class NotFound < RestApi::ResourceNotFound
+    def initialize(id, response=nil)
+      super(ApplicationType.model_name, id, response)
+    end
+  end
+
+  CartridgeSpecInvalid = Class.new(StandardError)
+
+  attr_accessor :id, :display_name, :version, :description
+  attr_accessor :cartridges, :initial_git_url, :initial_git_branch, :cartridges_spec
+  attr_accessor :template # DEPRECATED
+  attr_accessor :website, :license, :license_url
+  attr_accessor :tags, :learn_more_url
+  attr_accessor :help_topics
+  attr_accessor :priority
+  attr_accessor :scalable
+  alias_method :scalable?, :scalable
+  attr_accessor :source
+
+  attr_accessible :initial_git_url, :cartridges, :initial_git_branch, :scalable
+  alias_attribute :categories, :tags
+
+  def initialize(attributes={}, persisted=false)
+    attributes.each do |name,value|
+      send("#{name}=", value)
+    end
+    @persisted = persisted
+  end
+
+  def persisted?
+    @persisted
+  end
+
+  def new?
+    tags.include?(:new)
+  end
+
+  def to_params
+    persisted? ? {:id => id} : [:cartridges, :initial_git_url, :initial_git_branch].inject({}){ |h, s| h[s] = send(s); h }
+  end
+
+  def cartridges=(cartridges)
+    @cartridges = Array(cartridges)
+  end
+
+  def cartridge_specs
+    begin
+      s = (@cartridges_spec || cartridges || [])
+      if s.is_a? Array
+        s
+      else
+        s = s.strip
+        if s[0] == '['
+          ActiveSupport::JSON.decode(s).map{ |s| s.is_a?(Hash) ? s['name'] : s }
+        else
+          s.split(',').map(&:strip)
+        end
+      end
+    rescue
+      raise ApplicationType::CartridgeSpecInvalid, $!, $@
+    end
+  end
+
+  def <=>(other)
+    return 0 if id == other.id
+    c = source_priority - other.source_priority
+    return c unless c == 0
+    c = priority - other.priority
+    return c unless c == 0
+    display_name <=> other.display_name
+  end
+
+  def tags
+    @tags || []
+  end
+
+  def priority
+    @priority || 0
+  end
+
+  def source_priority
+    case source
+    when :template; -1
+    when :cartridge; -2
+    else; 0
+    end
+  end
+
+  def cartridge?; source == :cartridge; end
+  def template?; source == :template; end
+  def quickstart?; source == :quickstart; end
+
+  def matching_cartridges
+    self.class.matching_cartridges(cartridge_specs)
+  end
+
+  def >>(app)
+    if template
+      app.template = template.uuid
+    else
+      app.cartridges = cartridges if cartridges.present?
+      app.initial_git_url = initial_git_url if initial_git_url
+      app.initial_git_branch = initial_git_branch if initial_git_branch
+    end
+    app
+  end
+
+  #
+  # Default mass assignment support
+  #
+  def assign_attributes(values, options = {})
+    sanitize_for_mass_assignment(values, options[:as]).each do |k, v|
+      send("#{k}=", v)
+    end
+    self
+  end
+
+  cache_find_method :every
+
+  class << self
+    def all(*arguments)
+      find(:all, *arguments)
+    end
+
+    def search(query, opts={})
+      find(:all, {:search => query}.merge(opts))
+    end
+
+    def tagged(tag, opts={})
+      find(:all, {:tag => tag}.merge(opts))
+    end
+
+    def find(*arguments)
+      option = arguments.shift
+      case option
+      when String
+        find_single(option, *arguments)
+      when :all
+        find_every(*arguments)
+      when Symbol
+        find_every(*arguments).select { |t| t.tags.include? option }
+      else
+        raise "Unsupported scope"
+      end
+    end
+
+    def matching_cartridges(cartridge_specs)
+      valid, invalid = {}, []
+      Array(cartridge_specs).uniq.each do |c|
+        if (matches = CartridgeType.cached.matches(c)).present?
+          valid[c] = matches
+        else
+          invalid << c
+        end
+      end
+      [valid, invalid]
+    end
+
+    def custom(attrs={})
+      attrs = {} if attrs.nil? || attrs.is_a?(String)
+      attrs[:scalable] = true unless attrs.has_key?(:scalable)
+      new(:id => 'custom', :display_name => 'From Scratch').assign_attributes(attrs)
+    end
+
+    protected
+      def find_single(id, *arguments)
+        case (match = /^([^!]+)!(.+)/.match(id) || [])[1]
+        when 'quickstart'; from_quickstart(Quickstart.find match[2])
+        when 'cart'; from_cartridge_type(CartridgeType.cached.find match[2])
+        when 'template'; from_application_template(ApplicationTemplate.cached.find match[2])
+        else raise NotFound.new(id)
+        end
+        #find_every(*arguments).find{ |t| t.id == id } or raise NotFound, id
+      end
+
+      def find_every(opts={})
+        source = opts[:source].nil? ? nil : Array(opts[:source])
+
+        types = []
+        case
+        when opts[:search]
+          query = opts[:search].downcase
+          types.concat CartridgeType.cached.standalone
+          types.concat ApplicationTemplate.cached.all
+          types.keep_if &LOCAL_SEARCH.curry[query]
+          types.concat Quickstart.search(query)
+        when opts[:tag]
+          tag = opts[:tag].to_sym rescue (return [])
+          types.concat CartridgeType.cached.standalone
+          types.concat ApplicationTemplate.cached.all unless tag == :cartridge
+          types.keep_if &TAG_FILTER.curry[[tag]]
+          types.concat Quickstart.search(tag.to_s) unless tag == :cartridge
+        else
+          types.concat CartridgeType.cached.standalone
+          types.concat ApplicationTemplate.cached.all
+          types.concat Quickstart.cached.promoted
+        end
+        raise "nil types" unless types
+
+        types.select do |t|
+          not (t.tags.include?(:blacklist) or (Rails.env.production? and t.tags.include?(:in_development)))
+        end.map do |t|
+          case t
+          when ApplicationTemplate; from_application_template(t)
+          when CartridgeType; from_cartridge_type(t)
+          when Quickstart; from_quickstart(t)
+          end
+        end
+      end
+
+      def from_cartridge_type(type)
+        attrs = {:id => "cart!#{type.name}", :source => :cartridge}
+        [:display_name, :tags, :description, :website, :version, :license, :license_url, :help_topics, :priority, :scalable].each do |m|
+          attrs[m] = type.send(m)
+        end
+        attrs[:cartridges] = [type.name]
+
+        new(attrs, type.persisted?)
+      end
+      def from_application_template(type)
+        attrs = { :id => "template!#{type.name}", :source => :template }
+        [:display_name, :tags, :description, :website, :version, :template, :cartridges, :scalable, :initial_git_url, :initial_git_branch].each do |m|
+          attrs[m] = type.send(m)
+        end
+
+        new(attrs, type.persisted?)
+      end
+      def from_quickstart(type)
+        attrs = { :id => "quickstart!#{type.id}", :source => :quickstart }
+        [:display_name, :tags, :description, :website, :initial_git_url, :initial_git_branch, :cartridges_spec, :priority, :scalable, :learn_more_url].each do |m|
+          attrs[m] = type.send(m)
+        end
+
+        new(attrs, type.persisted?)
+      end
+  end
+
+  protected
+    LOCAL_SEARCH = lambda do |query, t|
+      t.description.downcase.include?(query) or
+        t.display_name.downcase.include?(query) or
+        (t.tags.include?(query.to_sym) rescue false)
+    end
+    TAG_FILTER = lambda do |query, t|
+      (t.tags & query) == query
+    end
+end