openshift-origin-controller 1.3.2

data/app/models/key.rb

@@ -0,0 +1,20 @@
+require 'validators/key_validator'
+
+class Key < OpenShift::Model
+  attr_accessor :name, :type, :content
+  include ActiveModel::Validations
+
+  VALID_SSH_KEY_TYPES = ['ssh-rsa', 'ssh-dss', 'ecdsa-sha2-nistp256-cert-v01@openssh.com', 'ecdsa-sha2-nistp384-cert-v01@openssh.com',
+                         'ecdsa-sha2-nistp521-cert-v01@openssh.com', 'ssh-rsa-cert-v01@openssh.com', 'ssh-dss-cert-v01@openssh.com',
+                         'ssh-rsa-cert-v00@openssh.com', 'ssh-dss-cert-v00@openssh.com', 'ecdsa-sha2-nistp256', 'ecdsa-sha2-nistp384', 'ecdsa-sha2-nistp521']
+  DEFAULT_SSH_KEY_TYPE = "ssh-rsa" unless defined? DEFAULT_SSH_KEY_TYPE
+  DEFAULT_SSH_KEY_NAME = "default" unless defined? DEFAULT_SSH_KEY_NAME
+
+  validates_with KeyValidator
+
+  def initialize(name, type, content)
+    self.name = name
+    self.type = type
+    self.content = content
+  end
+end

data/app/models/legacy_reply.rb

@@ -0,0 +1,15 @@
+class LegacyReply < OpenShift::Model
+  attr_accessor :api, :api_c, :broker_c, :debug, :messages, :result, :data, :exit_code  
+  
+  API_VERSION    = "1.1.3"
+  API_CAPABILITY = %w(placeholder)
+  C_CAPABILITY   = %w(namespace rhlogin ssh app_uuid debug alter cartridge cart_type action app_name api)
+
+  def initialize
+    @api = API_VERSION
+    @api_c = API_CAPABILITY
+    @broker_c = C_CAPABILITY
+    @debug = ""
+    @messages = nil
+  end
+end

data/app/models/legacy_request.rb

@@ -0,0 +1,126 @@
+class LegacyRequest < OpenShift::Model
+  attr_accessor :namespace, :rhlogin, :ssh, :app_uuid, :app_name, :node_profile, :debug, :alter, :delete, :cartridge, :api, :cart_type, :action, :server_alias, :api, :key_name, :key_type
+  attr_reader   :invalid_keys
+  
+  APP_MAX_LENGTH = 32
+  NS_MAX_LENGTH = 16
+
+  def initialize
+    @invalid_keys = []
+  end
+  
+  validates_each :invalid_keys do |record, attribute, val|
+    val.each do |key|
+      record.errors.add :base, {:message => "Unknown json key found: #{key}", :exit_code => 1}
+    end
+  end
+  
+  validates_each :rhlogin do |record, attribute, val|
+    if val =~ /["\$\^<>\|%\/;:,\\\*=~]/
+      record.errors.add attribute, {:message => "Invalid rhlogin: #{val}", :exit_code => 107}
+    end
+  end
+
+  validates_each :key_name, :allow_nil =>true do |record, attribute, val|
+    if !(val =~ /\A[A-Za-z0-9]+\z/)
+      record.errors.add attribute, {:message => "Invalid key name: #{val}", :exit_code => 117}
+    end
+  end
+  
+  validates_each :key_type, :allow_nil =>true do |record, attribute, val|
+    if !Key::VALID_SSH_KEY_TYPES.include?(val)
+      record.errors.add attribute, {:message => "Invalid key type: #{val}", :exit_code => 116}
+    end
+  end
+
+  validates_each :namespace, :allow_nil =>true do |record, attribute, val|
+    if !(val =~ /\A[A-Za-z0-9]+\z/)
+      record.errors.add attribute, {:message => "Invalid namespace: #{val}", :exit_code => 106}
+    end
+    if val and val.length > NS_MAX_LENGTH
+      record.errors.add attribute, {:message => "The supplied namespace '#{val}' is longer than the allowed length of #{NS_MAX_LENGTH} characters.", :exit_code => 106}
+    end
+  end
+  
+  validates_each :app_name, :allow_nil =>true do |record, attribute, val|
+    if !(val =~ /\A[A-Za-z0-9]+\z/)
+      record.errors.add attribute, {:message => "Invalid #{attribute} specified: #{val}", :exit_code => 105}
+    end
+    if val and val.length > APP_MAX_LENGTH
+      record.errors.add attribute, {:message => "The supplied application name '#{val}' is longer than the allowed length of #{APP_MAX_LENGTH} characters.", :exit_code => 105}
+    end
+  end
+  
+  validates_each :ssh, :allow_nil =>true do |record, attribute, val|
+    unless (val =~ /\A[A-Za-z0-9\+\/=]+\z/)
+      record.errors.add attribute, {:message => "Invalid ssh key: #{val}", :exit_code => 108}
+    end
+  end
+
+  validates_each :app_uuid, :allow_nil =>true do |record, attribute, val|
+    if !(val =~ /\A[a-f0-9]+\z/)
+      record.errors.add attribute, {:message => "Invalid application uuid: #{val}", :exit_code => 1}
+    end
+  end
+  
+  validates_each :node_profile, :allow_nil =>true do |record, attribute, val|
+  end
+  
+  validates_each :debug, :alter, :delete, :allow_nil =>true do |record, attribute, val|
+    if val != true && val != false && !(val =~ /\A(true|false)\z/)
+      record.errors.add attribute, {:message => "Invalid value for #{attribute} specified: #{val}", :exit_code => 1}
+    end
+  end
+  
+  validates_each :cartridge, :allow_nil =>true do |record, attribute, val|
+    if !(val =~ /\A[\w\-\.]+\z/)
+      record.errors.add attribute, {:message => "Invalid cartridge specified: #{val}", :exit_code => 1}
+    end
+  end
+  
+  validates_each :api, :allow_nil =>true do |record, attribute, val|
+    if !(val =~ /\A\d+\.\d+\.\d+\z/)
+      record.errors.add attribute, {:message => "Invalid API value specified: #{val}", :exit_code => 112}
+    end
+  end
+  
+  validates_each :cart_type, :allow_nil =>true do |record, attribute, val|
+    if !(val =~ /\A(standalone|embedded)\z/)
+      record.errors.add attribute, {:message => "Invalid cart_type specified: #{val}", :exit_code => 109}
+    end
+  end
+  
+  validates_each :action, :allow_nil =>true do |record, attribute, val|
+    if !(val =~ /\A[\w\-\.]+\z/)
+      record.errors.add attribute, {:message => "Invalid action specified: #{val}", :exit_code => 111}
+    end
+  end
+
+  validates_each :server_alias, :allow_nil =>true do |record, attribute, val|
+    if !(val =~ /\A[\w\-\.]+\z/) or (val =~ /#{Rails.configuration.openshift[:domain_suffix]}$/)
+      record.errors.add attribute, {:message => "Invalid ServerAlias specified: #{val}", :exit_code => 105}
+    end
+  end
+  
+  def alter
+    @alter == "true" || @alter == true
+  end
+  
+  def debug
+    @debug == "true" || @debug == true
+  end
+  
+  def delete
+    @delete == "true" || @delete == true
+  end
+
+  def attributes=(hash)
+    hash.each do |key,value|
+      begin
+        self.send("#{key}=",value)
+      rescue NoMethodError => e
+        @invalid_keys.push key
+      end
+    end
+  end
+end

data/app/models/link.rb

@@ -0,0 +1,11 @@
+class Link < OpenShift::Model
+  attr_accessor :rel, :method, :href, :required_params, :optional_params
+  
+  def initialize(rel, method, href, required_params=nil, optional_params=nil)
+    self.rel = rel
+    self.method = method
+    self.href = href.to_s
+    self.required_params = required_params || Array.new
+    self.optional_params = optional_params || Array.new
+  end
+end

data/app/models/message.rb

@@ -0,0 +1,10 @@
+class Message < OpenShift::Model
+  attr_accessor :severity, :text, :exit_code, :field
+  
+  def initialize(severity=:info, text=nil, exit_code=nil, field=nil)
+    self.severity = severity
+    self.text = text
+    self.exit_code = exit_code
+    self.field = field
+  end
+end

data/app/models/name_server_cache.rb

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'dnsruby'
+
+class NameServerCache
+  
+  def self.get_cached(key, opts={})
+    unless Rails.configuration.action_controller.perform_caching
+      if block_given?
+        return yield
+      end
+    end
+
+    val = Rails.cache.read(key)
+    unless val
+      if block_given?
+        val = yield
+        if val
+          Rails.cache.write(key, val, opts)
+        end
+      end
+    end
+
+    return val
+  end
+
+  def self.get_name_servers
+    dns = Dnsruby::DNS.new()
+    domain = Rails.application.config.openshift[:domain_suffix]
+    while domain && !domain.empty?
+      resources = dns.getresources(domain, Dnsruby::Types.NS)
+      unless resources.empty?
+        break
+      else
+        dp = domain.partition('.')
+        domain = dp[2]
+      end
+    end
+    raise OpenShift::UserException.new("Unable to find nameservers for domain '#{Rails.application.config.openshift[:domain_suffix]}'",
+                                       141) if resources.empty?
+    @nameservers = []
+    resources.each do |resource|
+      @nameservers.push(resource.domainname.to_s)
+    end                
+    get_cached("name_servers", :expires_in => 1.hour) {@nameservers}
+  end
+end

data/app/models/optional_param.rb

@@ -0,0 +1,12 @@
+class OptionalParam < OpenShift::Model
+  attr_accessor :name, :type, :description, :valid_options, :default_value
+  
+  def initialize(name=nil, type=nil, description=nil, valid_options=nil, default_value=nil)
+    self.name = name
+    self.type = type
+    self.description = description
+    valid_options = [valid_options] unless valid_options.kind_of?(Array)
+    self.valid_options = valid_options || Array.new
+    self.default_value = default_value
+  end
+end

data/app/models/param.rb

@@ -0,0 +1,13 @@
+class Param < OpenShift::Model
+  attr_accessor :name, :type, :description, :valid_options, :invalid_options
+  
+  def initialize(name=nil, type=nil, description=nil, valid_options=nil, invalid_options=nil)
+    self.name = name
+    self.type = type
+    self.description = description
+    self.valid_options = valid_options || Array.new
+    self.valid_options = [self.valid_options] unless self.valid_options.kind_of?(Array)
+    self.invalid_options = invalid_options || Array.new
+    self.invalid_options = [self.invalid_options] unless self.invalid_options.kind_of?(Array)
+  end
+end

data/app/models/remote_job.rb

@@ -0,0 +1,57 @@
+
+class RemoteJob < OpenShift::Model
+  attr_accessor :cartridge, :action, :args
+  
+  def initialize(target, action, args)
+    self.cartridge = target
+    self.action = action
+    self.args = args
+  end
+  
+  
+  def self.create_parallel_job
+    return { }
+  end
+
+  def self.has_jobs(handle)
+    !handle.empty?
+  end
+
+  def self.run_parallel_on_gears(gears, handle, &block)
+    gears.each { |gear|
+      block.call(handle, gear)
+    }
+    # now execute
+    begin
+      OpenShift::ApplicationContainerProxy.execute_parallel_jobs(handle)
+    rescue Exception=>e
+      Rails.logger.error e.message
+      Rails.logger.error e.inspect
+      Rails.logger.error e.backtrace.inspect        
+      raise e
+    end
+  end
+
+  def self.add_parallel_job(handle, tag, gear, rjob)
+    parallel_job = { 
+                     :tag => tag,
+                     :gear => gear.uuid,
+                     :job => { :cartridge => rjob.cartridge, :action => rjob.action, :args => rjob.args },
+                     :result_stdout => "",
+                     :result_stderr => "",
+                     :result_exit_code => ""
+                   }
+    job_list = handle[gear.get_proxy.id] || []
+    job_list << parallel_job
+    handle[gear.get_proxy.id] = job_list
+  end
+
+  def self.get_parallel_run_results(handle, &block)
+    handle.each { |id, job_list|
+      job_list.each { |parallel_job|
+        block.call(parallel_job[:tag], parallel_job[:gear], parallel_job[:result_stdout], parallel_job[:result_exit_code])
+      }
+    }
+  end
+
+end

data/app/models/rest_application.rb

@@ -0,0 +1,126 @@
+class RestApplication < OpenShift::Model
+  attr_accessor :framework, :creation_time, :uuid, :embedded, :aliases, :name, :gear_count, :links, :domain_id, 
+  :git_url, :app_url, :ssh_url, :gear_profile, :scalable, :health_check_path, :building_with, :building_app, 
+  :build_job_url, :initial_git_url, :cartridges
+  include LegacyBrokerHelper
+
+  def initialize(app, url, nolinks=false)
+    self.framework = app.framework
+    self.name = app.name
+    self.creation_time = app.creation_time
+    self.uuid = app.uuid
+    self.aliases = app.aliases || Array.new
+    self.gear_count = (app.gears.nil?) ? 0 : app.gears.length
+    self.embedded = app.embedded
+    self.domain_id = app.domain.namespace
+    self.gear_profile = app.node_profile
+    self.scalable = app.scalable
+    self.git_url = "ssh://#{@uuid}@#{@name}-#{@domain_id}.#{Rails.configuration.openshift[:domain_suffix]}/~/git/#{@name}.git/"
+    self.app_url = "http://#{@name}-#{@domain_id}.#{Rails.configuration.openshift[:domain_suffix]}/"
+    self.ssh_url = "ssh://#{@uuid}@#{@name}-#{@domain_id}.#{Rails.configuration.openshift[:domain_suffix]}"
+    self.health_check_path = app.health_check_path
+    self.building_with = nil
+    self.building_app = nil
+    self.build_job_url = nil
+    self.initial_git_url = app.init_git_url
+    
+    app.embedded.each { |cname, cinfo|
+      cart = CartridgeCache::find_cartridge(cname)
+      if cart.categories.include? "ci_builder"
+        self.building_with = cart.name
+        self.build_job_url = cinfo["job_url"]
+        break
+      end
+    }
+    app.user.applications.each { |user_app|
+      cart = CartridgeCache::find_cartridge(user_app.framework)
+      if cart.categories.include? "ci"
+        self.building_app = user_app.name
+        break
+      end
+    }
+
+    cart_type = "embedded"
+    cache_key = "cart_list_#{cart_type}"
+    unless nolinks
+      carts = nil
+      if app.scalable
+        carts = Application::SCALABLE_EMBEDDED_CARTS
+      else
+        carts = get_cached(cache_key, :expires_in => 21600.seconds) do
+          Application.get_available_cartridges("embedded")
+        end
+      end
+      # Update carts list
+      # - remove already embedded carts
+      # - remove conflicting carts
+      app.embedded.keys.each do |cname|
+        carts -= [cname]
+        cinfo = CartridgeCache.find_cartridge(cname)
+        carts -= cinfo.conflicts_feature if defined?(cinfo.conflicts_feature)
+      end if !app.embedded.empty?
+
+      self.links = {
+        "GET" => Link.new("Get application", "GET", URI::join(url, "domains/#{@domain_id}/applications/#{@name}")),
+        "GET_DESCRIPTOR" => Link.new("Get application descriptor", "GET", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/descriptor")),
+        "GET_GEARS" => Link.new("Get application gears", "GET", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/gears")),
+        "GET_GEAR_GROUPS" => Link.new("Get application gear groups", "GET", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/gear_groups")),
+        "START" => Link.new("Start application", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "start")
+        ]),
+        "STOP" => Link.new("Stop application", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "stop")
+        ]),
+        "RESTART" => Link.new("Restart application", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "restart")
+        ]),
+        "FORCE_STOP" => Link.new("Force stop application", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "force-stop")
+        ]),
+        "EXPOSE_PORT" => Link.new("Expose port", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "expose-port")
+        ]),
+        "CONCEAL_PORT" => Link.new("Conceal port", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "conceal-port")
+        ]),
+        "SHOW_PORT" => Link.new("Show port", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "show-port")
+        ]),
+        "ADD_ALIAS" => Link.new("Add application alias", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "add-alias"),
+          Param.new("alias", "string", "The server alias for the application")
+        ]),
+        "REMOVE_ALIAS" => Link.new("Remove application alias", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "remove-alias"),
+          Param.new("alias", "string", "The application alias to be removed")
+        ]),
+        "SCALE_UP" => Link.new("Scale up application", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "scale-up")
+        ]),
+        "SCALE_DOWN" => Link.new("Scale down application", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "scale-down")
+        ]),
+        "TIDY" => Link.new("Tidy the application framework", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "tidy")
+        ]),
+        "RELOAD" => Link.new("Reload the application", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "reload")
+        ]),
+        "THREAD_DUMP" => Link.new("Trigger thread dump", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/events"), [
+          Param.new("event", "string", "event", "thread-dump")
+        ]),
+        "DELETE" => Link.new("Delete application", "DELETE", URI::join(url, "domains/#{@domain_id}/applications/#{@name}")),
+        "ADD_CARTRIDGE" => Link.new("Add embedded cartridge", "POST", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/cartridges"),[
+          Param.new("cartridge", "string", "framework-type, e.g.: mongodb-2.2", carts)
+        ]),
+        "LIST_CARTRIDGES" => Link.new("List embedded cartridges", "GET", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/cartridges")),
+        "DNS_RESOLVABLE" => Link.new("Resolve DNS", "GET", URI::join(url, "domains/#{@domain_id}/applications/#{@name}/dns_resolvable"))
+      }
+    end
+  end
+
+  def to_xml(options={})
+    options[:tag_name] = "application"
+    super(options)
+  end
+end