openshift-origin-console 1.3.2

data/app/models/embedded.rb

@@ -0,0 +1,11 @@
+class Embedded < RestApi::Base
+  def info(cart)
+    @attributes[cart].info rescue nil
+  end
+
+  #FIXME: Bug 820651 should make this cleaner to retrieve
+  def jenkins_build_url
+    client = info('jenkins-client-1.4')
+    ((client || '').chomp)[/Job URL: ([^\s]*)\s*/, 1]
+  end
+end

data/app/models/gear.rb

@@ -0,0 +1,13 @@
+class Gear < RestApi::Base
+  schema do
+    string :id, :gear_profile, :state
+  end
+  #custom_id :id
+
+  belongs_to :application
+  has_many :components, :class_name => 'rest_api/base/attribute_hash'
+
+  def state
+    (super || :unknown).to_sym
+  end
+end

data/app/models/gear_group.rb

@@ -0,0 +1,104 @@
+class GearGroup < RestApi::Base
+  schema do
+    string :name, :gear_profile
+    integer :scales_from, :scales_to
+    integer :supported_scales_from, :supported_scales_to
+  end
+  custom_id :name
+
+  belongs_to :application
+
+  has_many :gears
+  has_many :cartridges
+
+  def gears
+    @attributes['gears'] ||= []
+  end
+  def cartridges
+    @attributes['cartridges'] ||= []
+  end
+
+  def gear_profile
+    (@attributes['gear_profile'] || :small).to_sym
+  end
+
+  def states
+    gears.map{ |g| g.state }
+  end
+
+  def exposes
+    @exposes ||= cartridges.inject({}) { |h, c| h[c.name] = c; h }
+  end
+  def exposes?(cart=nil, &block)
+    if cart
+      exposes.has_key? cart
+    elsif block_given?
+      cartridges.any? &block
+    end
+  end
+
+  def cartridge_names
+    exposes.keys
+  end
+
+  def scales?
+    supported_scales_to != supported_scales_from
+  end
+  def builds?
+    @builds
+  end
+
+  def supported_scales_from
+    super || 1
+  end
+
+  def supported_scales_to
+    super || -1
+  end
+
+  def ==(other)
+    super && other.gears == gears && other.cartridges == cartridges
+  end
+
+  def merge_gears(others)
+    Array(others).select{ |o| !(cartridges & o.cartridges).empty? }.each{ |o| gears.concat(o.gears) }
+    gears.uniq!
+    self
+  end
+
+  def self.infer(cartridges, application)
+    groups = cartridges.group_by(&:grouping).map do |a|
+      GearGroup.new({
+        :cartridges => a[1].sort!, 
+        :gear_profile => a[1].first.gear_profile
+      }, true)
+    end
+    groups.delete_if{ |g| g.send(:move_features, groups[0]) }
+    groups.sort!{ |a,b| a.cartridges.first <=> b.cartridges.first }
+
+    if groups.first
+      cart = groups.first.cartridges.first
+      cart.git_url = application.git_url
+      cart.ssh_url = application.ssh_url
+      cart.ssh_string = application.ssh_string
+    end
+    groups
+  end
+
+  protected
+    #
+    # Return true if the group is now empty
+    #
+    def move_features(to)
+      cartridges.delete_if do |c|
+        if c.tags.include?(:ci_builder) and not c.tags.include?(:web_framework)
+          to.cartridges.select{ |d| d.tags.include?(:web_framework) }.each{ |d| d.builds_with(c, self) }.present?
+        end
+      end
+      cartridges.delete_if{ |c| cartridges.any?{ |other| other != c && other.scales_with == c.name } }
+      if self != to && cartridges.empty?
+        to.gears.concat(gears)
+        gears.clear
+      end
+    end
+end

data/app/models/key.rb

@@ -0,0 +1,87 @@
+#
+# The REST API model object representing an SSH public key.
+#
+class Key < RestApi::Base
+  #self.element_name = 'key'
+  #self.primary_key = 'name'
+
+  class DuplicateName < ActiveResource::ResourceConflict ; end
+  on_exit_code 120, DuplicateName
+
+  schema do
+    string :name, 'type', :content, :raw_content
+  end
+  custom_id :name, true
+  def id # support ID for legacy code which retrieves keys by .id
+    name
+  end
+
+  # type is a method on Object in 1.8.7 and must be overriden so that the attribute 
+  # will be read (method_missing is how ActiveResource attributes are looked up)
+  def type
+    @attributes[:type]
+  end
+
+  belongs_to :user
+
+  attr_alters :raw_content, [:content, :type]
+  # Raw content is decomposed into content and type
+  def raw_content=(contents)
+    if contents
+      parts = contents.split
+      case parts.length
+      when 0
+        self.type = self.content = nil
+      when 1
+        self.type = nil
+        self.content = parts[0]
+      else
+        self.type, self.content = parts
+      end
+    end
+    super
+  end
+
+  validates :name, :presence => true, :allow_blank => false
+  #validates_format_of 'type',
+  #                    :with => /^ssh-(rsa|dss)$/,
+  #                    :message => "is not ssh-rsa or ssh-dss"
+  validates :content, :presence => true, :allow_blank => false
+
+  Inf = 1.0/0.0 # Replace with Float::INFINITY in 1.9 ruby
+  def make_unique!(format='key %s')
+    unless persisted?
+      keys = Key.find(:all, :as => as)
+      if keys.any? {|k| k.name == name }
+        self.name = format % (2..keys.length+2).find do |i|
+          not keys.any? {|k| k.name == format % i}
+        end
+      end
+    end
+    self
+  end
+
+  def display_content
+    if content.length > 20
+      "#{content[1..8]}..#{content[-8..-1]}"
+    else
+      content
+    end
+  end
+
+  #
+  # Until the empty default key is attached from domain, ignore in lists
+  #
+  def default?
+    'default' == name
+  end
+  def empty_default?
+    default? and (!content or content.blank? or 'nossh' == content)
+  end
+
+  class << self
+    def default(options=nil)
+      Key.find('default', options)
+    end
+  end
+end

data/app/models/quickstart.rb

@@ -0,0 +1,135 @@
+class Quickstart < RestApi::Base
+  include RestApi::Cacheable
+  allow_anonymous
+
+  instance_variable_set(:@connection, nil)
+
+  schema do
+    string :id, :name, :href, :initial_git_url, :initial_git_branch
+    string :website
+    string :body, :summary
+    integer :priority
+  end
+
+  Disabled = Class.new(StandardError)
+  SearchDisabled = Class.new(StandardError)
+
+  alias_attribute :display_name, :name
+  alias_attribute :description, :summary
+
+  def name
+    entity_decoded(super)
+  end
+
+  def priority
+    super.to_i rescue 0
+  end
+
+  def learn_more_url
+    URI.join(self.class.site, href).to_s if href
+  end
+
+  def tags
+    @tags ||= ApplicationType.user_tags(tags_from(attributes[:tags])) + admin_tags + (3.days.ago < updated ? [:new] : [])
+  end
+
+  def updated
+    @updated ||= Time.at(attributes[:updated].to_i)
+  end
+
+  def cartridges_spec
+    entity_decoded(attributes[:cartridges])
+  end
+
+  # This is a short-term fix for BZ877849
+  # The drupal quickstart nodes need to be augmented with a flag to
+  # indicate whether or not they can be scaled.
+  NON_SCALABLE = Regexp.new(['wordpress','drupal','spring','capedwarf','javaee'].join('|'),true)
+  def scalable
+    retval = !self.name.match(NON_SCALABLE)
+  ensure
+    Rails.logger.debug("Handling #{self.name} quickstart as non-scalable") unless retval
+  end
+  alias_method :scalable?, :scalable
+
+  def >>(application)
+    #application.cartridges = cartridges
+    application.initial_git_url = initial_git_url
+    application
+  end
+
+  cache_method :find_every, :expires_in => 10.minutes
+
+  class << self
+    def promoted(opts={})
+      all({:from => (api_links[:list] or raise Disabled)}.merge(opts))
+    rescue Disabled
+      []
+    end
+
+    def search(terms, opts={})
+      all(opts.merge(
+        :from => (api_links[:search] or raise SearchDisabled),
+        :params => {
+          (api_links[:search_param] or raise SearchDisabled) => terms
+        }
+      ))
+    rescue SearchDisabled
+      terms.downcase!
+      promoted(opts).select do |q|
+        q.description.downcase.include?(terms) or
+          q.display_name.downcase.include?(terms) or
+          (q.tags.include?(terms.to_sym) rescue false)
+      end
+    end
+
+    def disabled?
+      !api_links[:list] rescue true
+    end
+
+    def site
+      api_links[:site] or RestApi::Info.site
+    end
+    def prefix_parameters
+      {}
+    end
+
+    def reset!
+      @api_links = nil
+    end
+
+    protected
+      def collection_path(*args)
+        api_links[:list] rescue super
+      end
+      def element_path(id, prefix_options = {}, query_options = nil)
+        api_links[:get].gsub(/:id/, id.to_s) rescue super
+      end
+      def api_links
+        @api_links ||= begin
+          info = RestApi::Info.cached.find :one
+          {
+            :site => (URI.join(info.link("LIST_QUICKSTARTS"), '/') rescue nil),
+            :list => (info.link("LIST_QUICKSTARTS").path rescue nil),
+            :get => (info.link("SHOW_QUICKSTART").path rescue nil),
+            :search => (info.link("SEARCH_QUICKSTARTS").path rescue nil),
+            :search_param => (info.required_params('SEARCH_QUICKSTARTS').first[:name] rescue nil),
+          }
+        end
+      end
+
+      def instantiate_record(record, *args)
+        super record.is_a?(Array) ? record.first : record, *args
+      end
+  end
+
+  protected
+    def admin_tags
+      @admin_tags ||= tags_from(attributes[:admin_tags])
+    end
+
+  private
+    def tags_from(s)
+      (s.is_a?(Array) ? s : ((s || '').split(','))).map(&:strip).map(&:downcase).map(&:to_sym)
+    end
+end

data/app/models/rest_api.rb

@@ -0,0 +1,130 @@
+module RestApi
+  #
+  # An Authorization object should expose:
+  #
+  #  login - method returning an identifier for the user
+  #
+  # and one of:
+  #
+  #  ticket - the unique ticket for the session
+  #  password - a user password
+  #
+  class Authorization
+    attr_reader :login, :ticket, :password
+    def initialize(login,ticket=nil,password=nil)
+      @login = login
+      @ticket = ticket
+      @password = password
+    end
+    def cache_key
+      login
+    end
+  end
+
+  # During retrieval of info about the API, an error occurred
+  class ApiNotAvailable < StandardError ; end
+
+  # Raised when the authorization context is missing
+  class MissingAuthorizationError < StandardError ; end
+
+  # Raised when a newly created resource exists with the same unique primary key
+  class ResourceExistsError < StandardError ; end
+
+  class ResourceNotFound < ActiveResource::ResourceNotFound
+    attr_reader :id
+    def initialize(model, id, response=nil)
+      @id, @model = id, model
+      super(response)
+    end
+    def model
+      @model.constantize rescue RestApi::Base
+    end
+    def domain_missing?
+      @model == 'Domain' || RestApi::Base.remote_errors_for(response).any?{ |m| m[0] == 127 } rescue false
+    end
+    def to_s
+      "#{model.to_s.titleize}#{ " '#{id}'" unless id.nil?} does not exist"
+    end
+  end
+
+  # The server did not return the response we were expecting, possibly a server bug
+  class BadServerResponseError < StandardError ; end
+
+  class << self
+    #
+    # All code in the block will dump detailed HTTP logs
+    #
+    def debug(set=true,&block)
+      @debug = set
+      if block_given?
+        begin
+          yield block
+        ensure
+          @debug = false
+        end
+      end
+    end
+    def debug?
+      @debug || ENV['REST_API_DEBUG']
+    end
+    def force_http_debug
+      unless ActiveResource::Connection.respond_to? :configure_http_with_debug
+        ActiveResource::Connection.class_eval do
+          def configure_http_with_debug(http)
+            configure_http_without_debug(http)
+            http.set_debug_output $stderr
+            http
+          end
+          alias_method_chain :configure_http, :debug
+        end
+      end
+    end
+
+    #
+    # Is the API reachable?
+    #
+    def test?
+      info.present? rescue false
+    end
+
+    #
+    # Return the version information about the REST API
+    #
+    def info
+      RestApi::Info.cached.find :one
+    rescue Exception => e
+      raise ApiNotAvailable, <<-EXCEPTION, e.backtrace
+
+The REST API could not be reached at #{RestApi::Base.site}
+
+  Rails environment:     #{Rails.env}
+  Current configuration: #{config.inspect} #{config[:symbol] ? "(via :#{config[:symbol]})" : ''}
+
+  #{e.message}
+  #{e.backtrace.join("\n  ")}
+      EXCEPTION
+    end
+
+    def reset!
+      @info = nil
+    end
+
+    # FIXME: May be desirable to replace this with a standard ActiveSupport config object
+    def config
+      RestApi::Base.instance_variable_get("@last_config") || {}
+    end
+
+    def application_domain_suffix
+      @application_domain_suffix ||= RestApi::Environment.cached.find(:one).domain_suffix
+    end
+
+    def site
+      RestApi::Base.site
+    end
+
+    private
+      def symbol
+        RestApi::Base.instance_variable_get('@symbol')
+      end
+  end
+end