openshift-origin-console 1.3.2

data/app/models/async_aware.rb

@@ -0,0 +1,60 @@
+#
+# Prototype support for simple parallel requests.  It is the callers
+# responsibility to ensure that blocks are side-effect free.
+#
+module AsyncAware
+  extend ActiveSupport::Concern
+
+  def async(&block)
+    (@threads ||= []) << Thread.start do
+      begin
+        Thread.current[:out] = yield block
+      rescue => e
+        Thread.current[:out] = e
+      end
+    end
+  end
+  def join(limit=nil)
+    running = @threads
+    t1 = Time.now.to_i
+
+    threads = begin
+      @threads.map{ |t| limit ? t.join(limit) : t.join }
+    ensure
+      @threads.each(&:kill)
+      @threads = nil
+    end
+
+    #puts                  "**** Joined #{Time.now.to_i - t1} (limit=#{limit})"
+    #puts running.map{ |t| "     #{t.inspect}: #{threads.include?(t) ? "" : "(did not finish) "}#{t[:out].inspect}" }.join("\n")
+
+    running.map do |t| 
+      if threads.include?(t) 
+        t[:out]
+      else
+        begin; raise(ThreadTimedOut.new(t, limit)); rescue => e; e; end
+      end
+    end
+  end
+
+  #
+  # Throw the first exception encountered
+  #
+  def join!(limit=nil)
+    join(limit).tap do |results|
+      exceptions = results.select{ |r| r.is_a? StandardError }
+      exceptions[1..-1].each{ |e| Rails.logger.error "#{e.class} (#{e})\n  #{Rails.backtrace_cleaner.clean(e.backtrace).join("\n  ")}" } if exceptions.size > 1
+      raise exceptions.first unless exceptions.empty?
+    end
+  end
+
+  class ThreadTimedOut < StandardError
+    attr_reader :thread
+    def initialize(thread, timeout)
+      @thread, @timeout = thread, timeout
+    end
+    def to_s
+      "The thread #{thread.inspect} did not complete within #{@timeout} seconds."
+    end
+  end
+end

data/app/models/capabilities.rb

@@ -0,0 +1,62 @@
+module Capabilities
+  extend ActiveSupport::Concern
+
+  included do
+    has_one :capabilities, :class_name => 'rest_api/base/attribute_hash'
+    include Helpers
+  end
+
+  def gear_sizes
+    @gear_sizes ||= capabilities[:gear_sizes].map(&:to_sym)
+  end
+
+  def to_capabilities
+    Capabilities::Cacheable.from(self)
+  end
+
+  module Helpers
+    def gears_free?
+      gears_free > 0
+    end
+
+    def gears_free
+      [max_gears - consumed_gears, 0].max
+    end
+  end
+
+  class Cacheable
+    include Helpers
+
+    # Changing this order will break serialization of cached data
+    ATTRS = [:max_gears, :consumed_gears, :gear_sizes].each{ |s| attr_reader s }
+
+    def initialize(*args)
+      arg = args.each
+      ATTRS.each{ |t| send("#{t}=", arg.next) }
+    rescue StopIteration
+    end
+
+    def self.from(obj)
+      new(*(obj.is_a?(Array) ? obj : ATTRS.map{ |s| obj.send(s) })) if obj
+    end
+
+    def to_capabilities
+      self
+    end
+
+    def to_a
+      ATTRS.map{ |s| send(s) }
+    end
+
+    private
+      def max_gears=(i)
+        @max_gears = Integer(i)
+      end
+      def consumed_gears=(i)
+        @consumed_gears = Integer(i)
+      end
+      def gear_sizes=(arr)
+        @gear_sizes = Array(arr)
+      end
+  end
+end

data/app/models/cartridge.rb

@@ -0,0 +1,122 @@
+#
+# The REST API model object representing a cartridge instance.
+#
+class Cartridge < RestApi::Base
+  include Comparable
+
+  #use_patch_on_update
+
+  schema do
+    string :name, 'type'
+    integer :supported_scales_from, :supported_scales_to
+    integer :scales_from, :scales_to, :current_scale
+    string :scales_with
+    string :gear_profile
+  end
+  custom_id :name
+
+  attr_accessor :git_url, :ssh_url, :ssh_string
+  attr_reader :gears
+
+  belongs_to :application
+  has_one :cartridge_type
+  has_many :collocated_with, :class_name => 'string'
+  has_many :properties, :class_name => 'rest_api/base/attribute_hash'
+  has_one  :help_topics, :class_name => 'rest_api/base/attribute_hash'
+
+  delegate :display_name, :tags, :priority, :to => :cartridge_type, :allow_nil => false
+
+  def collocated_with
+    @attributes[:collocated_with] ||= []
+  end
+
+  def supported_scales_from
+    super || 1
+  end
+  def supported_scales_to
+    super || 1
+  end
+  def type
+    @attributes[:type]
+  end
+
+  def type=(type)
+    @attributes[:type]=type
+  end
+
+  def runs_on(new_gears)
+    gears.concat(new_gears)
+  end
+  def gears
+    @gears ||= []
+  end
+  def gear_count
+    @gears.length
+  end
+
+  # deprecated
+  def scales
+    @scales || ScaleRelation::Null
+  end
+
+  def scales?
+    @scales.present? || supported_scales_from != supported_scales_to
+  end
+
+  # deprecated with args
+  def scales_with(*args)
+    args.length == 0 ? super : begin
+      @scales = ScaleRelation.new args[0], args[1].is_a?(String) ? args[1] : args[1].name, args[2]
+    end
+  end
+
+  #
+  # The build attributes are used for view manipulation only
+  #
+  # deprecated
+  def buildable?
+    git_url.present? and tags.include? :web_framework
+  end
+  def builds
+    @builds || BuildRelation::Null
+  end
+  def builds?
+    @builds.present?
+  end
+  def builds_with(cart, gear_group)
+    @builds = BuildRelation.new cart, gear_group.is_a?(String) ? gear_group : gear_group.name
+  end
+
+  def grouping
+    @grouping ||= [name].concat(collocated_with).uniq.sort
+  end
+
+  def <=>(other)
+    return 0 if name == other.name
+    cartridge_type <=> other.cartridge_type
+  end
+
+  def cartridge_type
+    @cartridge_type ||= CartridgeType.cached.find(name)
+  end
+end
+
+class Cartridge::ScaleRelation
+  attr_accessor :with, :on, :times
+
+  def initialize(with, on, times)
+    @with, @on, @times = with, on, times
+  end
+
+  Null = new(nil,nil,1)
+end
+
+class Cartridge::BuildRelation
+  attr_accessor :with, :on
+
+  def initialize(with, on)
+    @with, @on = with, on
+  end
+
+  Null = new(nil,nil)
+end

data/app/models/cartridge_type.rb

@@ -0,0 +1,140 @@
+class CartridgeType < RestApi::Base
+  include ActiveModel::Conversion
+  extend ActiveModel::Naming
+  include Comparable
+
+  schema do
+    string :name, 'type'
+    string :tags
+  end
+
+  custom_id :name
+
+  allow_anonymous
+
+  attr_accessor :version, :description
+  attr_accessor :display_name
+  attr_accessor :provides
+  attr_accessor :cartridge
+  attr_accessor :website, :license, :license_url
+  attr_accessor :learn_more_url
+  attr_accessor :conflicts, :requires
+  attr_accessor :help_topics
+  attr_accessor :priority
+
+  has_many :properties, :class_name => 'rest_api/base/attribute_hash'
+
+  self.element_name = 'cartridges'
+
+  def initialize(attributes={},persisted=false)
+    attributes = attributes.with_indifferent_access
+    name = attributes['name'].presence || attributes[:name].presence
+    defaults = self.class.defaults(name)
+    defaults.keys.each{ |k| attributes.delete(k) if attributes[k].blank? }
+    attributes.reverse_merge!(defaults)
+    super attributes, persisted
+  end
+
+  def type
+    (@attributes[:type] || :embedded).to_sym
+  end
+
+  def embedded?;    type == :embedded; end
+  def standalone?;  type == :standalone; end
+
+  def display_name
+    @display_name || name
+  end
+
+  # Legacy, use #tags
+  def categories
+    @categories || []
+  end
+  def categories=(cats)
+    @categories = cats.map{ |c| c.to_sym }.compact.uniq
+  end
+
+  def tags
+    @tags ||= (super || [] rescue []).map{ |t| t.to_sym}.concat(categories).compact
+  end
+  def tags=(tags)
+    @tags = nil
+    @attributes[:tags] = tags
+  end
+
+  def conflicts
+    @conflicts || []
+  end
+
+  def requires
+    @requires || []
+  end
+
+  def help_topics
+    @help_topics || {}
+  end
+
+  def priority
+    @priority || 0
+  end
+
+  def scalable
+    self.attributes['supported_scales_to'] != self.attributes['supported_scales_from']
+  end
+  alias_method :scalable?, :scalable
+
+  def <=>(other)
+    return 0 if name == other.name
+    c = self.class.tag_compare(tags, other.tags)
+    return c unless c == 0
+    c = priority - other.priority
+    return c unless c == 0
+    display_name <=> other.display_name
+  end
+
+  def self.embedded(*arguments)
+    all(*arguments).select(&:embedded?)
+  end
+
+  def self.standalone(*arguments)
+    all(*arguments).select(&:standalone?)
+  end
+
+  def self.matches(s, opts=nil)
+    every = all(opts)
+    s.split('|').map{ |s| s.gsub('*','') }.map do |s|
+      Array(every.find{ |t| t.name == s } || every.select do |t| 
+        t.name.include?(s) 
+      end)
+    end.flatten.uniq
+  end
+
+  cache_find_method :every
+
+  def self.tag_compare(a,b)
+    [:web_framework, :database].each do |t|
+      if a.include? t
+        return -1 unless b.include? t
+      else
+        return 1 if b.include? t
+      end
+    end
+    0
+  end
+
+  class Property < RestApi::Base
+  end
+
+  protected
+    def self.find_single(scope, options)
+      all(options).find{ |t| t.to_param == scope } or new(:name => scope, :as => options[:as])
+    end
+
+    def self.type_map
+      Rails.application.config.cartridge_types_by_name
+    end
+
+    def self.defaults(name)
+      type_map[name.to_s] || {}
+    end
+end

data/app/models/domain.rb

@@ -0,0 +1,44 @@
+#
+# The REST API model object representing the domain, which may contain multiple applications.
+#
+class Domain < RestApi::Base
+  schema do
+    string :id
+    string :suffix
+  end
+
+  on_exit_code(158, :on_invalid => (Domain::UserAlreadyHasDomain = Class.new(ActiveResource::ResourceInvalid)))
+  on_exit_code(103, :on_invalid => (Domain::AlreadyExists = Class.new(ActiveResource::ResourceInvalid)))
+
+  custom_id :id, true # domain id is mutable, FIXME rename method to primary_key
+  alias_attribute :name, :id
+
+  has_many :applications
+  def applications
+    @applications ||= Application.find :all, { :params => { :domain_id => self.id }, :as => as }
+  end
+  def find_application(name)
+    Application.find name, { :params => { :domain_id => self.id }, :as => as}
+  end
+
+  #FIXME should have an observer pattern that clears cached associations on reload
+  def reload
+    @applications = nil
+    super
+  end
+
+  def user
+    User.find :one, :as => as
+  end
+
+  def destroy_recursive
+    connection.delete(element_path({:force => true}.merge(prefix_options)), self.class.headers)
+  end
+
+  # FIXME: Temporary until multiple domains are supported
+  def self.find_one(options)
+    domain = first(options)
+    raise RestApi::ResourceNotFound.new(model_name, nil) if domain.nil?
+    domain
+  end
+end

data/app/models/domain_associations.rb

@@ -0,0 +1,33 @@
+module DomainAssociations
+
+  def self.when_belongs_to(klass, options)
+    klass.prefix = "#{RestApi::Base.prefix}domains/:domain_id/"
+    klass.class_eval do
+      # domain_id overlaps with the attribute returned by the server
+      def domain_id=(id)
+        if self.prefix_options[:domain_id].nil?
+          self.prefix_options[:domain_id] = id
+        else
+          super
+        end
+      end
+      def domain_id
+        super or self.prefix_options[:domain_id]
+      end
+
+      def domain
+        Domain.find(domain_id, :as => as)
+      end
+
+      def domain=(domain)
+        self.domain_id = if domain.kind_of?(Domain) 
+            self.as = domain.as if self.as.nil?
+            domain.id
+          else
+            domain
+          end
+      end
+    end
+  end
+
+end