openshift-origin-controller 1.3.2

data/app/models/rest_domain.rb

@@ -0,0 +1,43 @@
+class RestDomain < OpenShift::Model
+  attr_accessor :id, :suffix, :links
+  include LegacyBrokerHelper
+  
+  def initialize(domain, url, nolinks=false)
+    self.id = domain.namespace
+    self.suffix = Rails.application.config.openshift[:domain_suffix] 
+    
+    unless nolinks      
+      valid_sizes = OpenShift::ApplicationContainerProxy.valid_gear_sizes(domain.user)
+      blacklisted_words = OpenShift::ApplicationContainerProxy.get_blacklisted
+
+      carts = get_cached("cart_list_standalone", :expires_in => 21600.seconds) do
+        Application.get_available_cartridges("standalone")
+      end
+
+      self.links = {
+        "GET" => Link.new("Get domain", "GET", URI::join(url, "domains/#{id}")),
+        "LIST_APPLICATIONS" => Link.new("List applications", "GET", URI::join(url, "domains/#{id}/applications")),
+        "ADD_APPLICATION" => Link.new("Create new application", "POST", URI::join(url, "domains/#{id}/applications"), 
+          [Param.new("name", "string", "Name of the application",nil,blacklisted_words)], 
+          [OptionalParam.new("cartridges", "array", "Array of one or more cartridge names. i.e. [\"php-5.3\", \"mongodb-2.2\"]", carts),
+          OptionalParam.new("template", "string", "UUID of the application template"),
+          OptionalParam.new("scale", "boolean", "Mark application as scalable", [true, false], false),
+          OptionalParam.new("gear_profile", "string", "The size of the gear", valid_sizes, valid_sizes[0]),
+          OptionalParam.new("init_git_url", "string", "Initial git URL"),
+        ]),
+        "UPDATE" => Link.new("Update domain", "PUT", URI::join(url, "domains/#{id}"),[
+          Param.new("id", "string", "Name of the domain")
+        ]),
+        "DELETE" => Link.new("Delete domain", "DELETE", URI::join(url, "domains/#{id}"),nil,[
+          OptionalParam.new("force", "boolean", "Force delete domain.  i.e. delete any applications under this domain", [true, false], false)
+        ])
+      }
+    end
+  end
+  
+  def to_xml(options={})
+    options[:tag_name] = "domain"
+    super(options)
+  end
+  
+end

data/app/models/rest_domain10.rb

@@ -0,0 +1,42 @@
+class RestDomain10 < OpenShift::Model
+  attr_accessor :id, :suffix, :links
+  include LegacyBrokerHelper
+  
+  def initialize(domain, url, nolinks=false)
+    self.id = domain.namespace
+    self.suffix = Rails.application.config.openshift[:domain_suffix] 
+    
+    unless nolinks      
+      valid_sizes = OpenShift::ApplicationContainerProxy.valid_gear_sizes(domain.user)
+      blacklisted_words = OpenShift::ApplicationContainerProxy.get_blacklisted
+
+      carts = get_cached("cart_list_standalone", :expires_in => 21600.seconds) do
+        Application.get_available_cartridges("standalone")
+      end
+
+      self.links = {
+        "GET" => Link.new("Get domain", "GET", URI::join(url, "domains/#{id}")),
+        "LIST_APPLICATIONS" => Link.new("List applications", "GET", URI::join(url, "domains/#{id}/applications")),
+        "ADD_APPLICATION" => Link.new("Create new application", "POST", URI::join(url, "domains/#{id}/applications"), 
+          [Param.new("name", "string", "Name of the application",nil,blacklisted_words)], 
+          [OptionalParam.new("cartridge", "string", "framework-type, e.g: php-5.3", carts),
+          OptionalParam.new("template", "string", "UUID of the application template"),
+          OptionalParam.new("scale", "boolean", "Mark application as scalable", [true, false], false),
+          OptionalParam.new("gear_profile", "string", "The size of the gear", valid_sizes, valid_sizes[0])
+        ]),
+        "UPDATE" => Link.new("Update domain", "PUT", URI::join(url, "domains/#{id}"),[
+          Param.new("id", "string", "Name of the domain")
+        ]),
+        "DELETE" => Link.new("Delete domain", "DELETE", URI::join(url, "domains/#{id}"),nil,[
+          OptionalParam.new("force", "boolean", "Force delete domain.  i.e. delete any applications under this domain", [true, false], false)
+        ])
+      }
+    end
+  end
+  
+  def to_xml(options={})
+    options[:tag_name] = "domain"
+    super(options)
+  end
+  
+end

data/app/models/rest_estimates.rb

@@ -0,0 +1,16 @@
+class RestEstimates < OpenShift::Model
+  attr_accessor :links 
+ 
+  def initialize(url, nolinks=false)
+    self.links = {
+      "GET_ESTIMATE" => Link.new("Get application estimate", "GET", URI::join(url, "estimates/application"), [
+        Param.new("descriptor", "string", "application requirements")
+      ]) 
+    } unless nolinks
+  end
+  
+  def to_xml(options={})
+    options[:tag_name] = "estimates"
+    super(options)
+  end
+end

data/app/models/rest_gear.rb

@@ -0,0 +1,14 @@
+class RestGear < OpenShift::Model
+  attr_accessor :uuid, :components
+  include LegacyBrokerHelper
+  
+  def initialize(uuid, components)
+    self.uuid = uuid
+    self.components = components
+  end
+  
+  def to_xml(options={})
+    options[:tag_name] = "gear"
+    super(options)
+  end
+end

data/app/models/rest_gear_group.rb

@@ -0,0 +1,26 @@
+class RestGearGroup < OpenShift::Model
+  attr_accessor :uuid, :name, :gear_profile, :cartridges, :gears, :scales_from, :scales_to, :links, :base_gear_storage, :additional_gear_storage
+
+  def initialize(group_instance, gear_states, url, nolinks=false)
+    app               = group_instance.app
+    self.uuid         = group_instance.uuid
+    self.name         = group_instance.name
+    self.gear_profile = group_instance.node_profile
+    self.gears        = group_instance.gears.map{ |gear| {:id => gear.uuid, :state => gear_states[gear.uuid] || 'unknown'} }
+    self.cartridges   = group_instance.component_instances.map { |comp_inst| app.comp_instance_map[comp_inst].cart_properties.merge({:name => app.comp_instance_map[comp_inst].parent_cart_name}) }
+    self.cartridges.delete_if{ |comp| comp[:name] == app.name }
+    storage = group_instance.get_quota
+    self.base_gear_storage = storage["base_gear_storage"]
+    self.additional_gear_storage = storage["additional_gear_storage"]
+    self.scales_to = group_instance.max
+    self.scales_from = group_instance.min
+    self.links = {
+      "GET" => Link.new("Get gear group", "GET", URI::join(url, "domains/#{app.domain.namespace}/applications/#{app.name}/gear_groups/#{uuid}"))
+    } unless nolinks
+  end
+
+  def to_xml(options={})
+    options[:tag_name] = "gear_group"
+    super(options)
+  end
+end

data/app/models/rest_key.rb

@@ -0,0 +1,24 @@
+class RestKey < OpenShift::Model
+  attr_accessor :name, :content, :type, :links
+  
+  def initialize(name, content, type, url, nolinks=false)
+    self.name= name
+    self.content = content
+    self.type = type || Key::DEFAULT_SSH_KEY_TYPE
+
+    self.links = {
+      "GET" => Link.new("Get SSH key", "GET", URI::join(url, "user/keys/#{name}")),
+      "UPDATE" => Link.new("Update SSH key", "PUT", URI::join(url, "user/keys/#{name}"), [
+        Param.new("type", "string", "Type of Key", Key::VALID_SSH_KEY_TYPES),
+        Param.new("content", "string", "The key portion of an ssh key (excluding ssh type and comment)"),
+      ]),
+      "DELETE" => Link.new("Delete SSH key", "DELETE", URI::join(url, "user/keys/#{name}"))
+    } unless nolinks
+  end
+  
+  def to_xml(options={})
+    options[:tag_name] = "key"
+    super(options)
+  end
+
+end

data/app/models/rest_reply.rb

@@ -0,0 +1,31 @@
+class RestReply < OpenShift::Model
+  attr_accessor :version, :status, :type, :data, :messages, :supported_api_versions
+
+  
+  def initialize(status=nil, type=nil, data=nil)
+    self.status = status
+    self.type = type
+    self.data = data
+    self.messages = []
+    self.version = $requested_api_version.to_s
+    self.supported_api_versions = BaseController::SUPPORTED_API_VERSIONS
+  end
+  
+  def process_result_io(result_io)
+    unless result_io.nil?
+      messages.push(Message.new(:debug, result_io.debugIO.string)) unless result_io.debugIO.string.empty?
+      messages.push(Message.new(:info, result_io.messageIO.string)) unless result_io.messageIO.string.empty?
+      messages.push(Message.new(:error, result_io.errorIO.string)) unless result_io.errorIO.string.empty?
+      messages.push(Message.new(:result, result_io.resultIO.string)) unless result_io.resultIO.string.empty?    
+    end
+  end
+  
+  def to_xml(options={})
+    options[:tag_name] = "response"
+    if not self.data.kind_of?Enumerable
+      new_data = self.data
+      self.data = [new_data]
+    end
+    super(options)
+  end
+end

data/app/models/rest_user.rb

@@ -0,0 +1,43 @@
+class RestUser < OpenShift::Model
+  attr_accessor :login, :consumed_gears, :max_gears, :capabilities, :plan_id, :usage_account_id, :links, :consumed_gear_sizes
+  
+  def initialize(cloud_user, url, nolinks=false)
+    self.login = cloud_user.login
+    self.consumed_gears = cloud_user.consumed_gears
+    self.max_gears = cloud_user.max_gears
+    self.capabilities = cloud_user.capabilities
+    self.plan_id = cloud_user.plan_id
+    self.usage_account_id = cloud_user.usage_account_id
+
+    unless nolinks
+      @links = {
+        "LIST_KEYS" => Link.new("Get SSH keys", "GET", URI::join(url, "user/keys")),
+        "ADD_KEY" => Link.new("Add new SSH key", "POST", URI::join(url, "user/keys"), [
+          Param.new("name", "string", "Name of the key"),
+          Param.new("type", "string", "Type of Key", Key::VALID_SSH_KEY_TYPES),
+          Param.new("content", "string", "The key portion of an ssh key (excluding ssh type and comment)"),
+        ])
+      }
+      @links["DELETE_USER"] = Link.new("Delete user. Only applicable for subaccount users.", "DELETE", URI::join(url, "user"), nil, [
+        OptionalParam.new("force", "boolean", "Force delete user. i.e. delete any domains and applications under this user", [true, false], false)
+      ]) if cloud_user.parent_user_login
+    end
+
+    consumed_map = {}
+    if cloud_user.applications
+      cloud_user.applications.each { |a|
+        a.gears.each { |g|
+          size = g.node_profile || Application.DEFAULT_NODE_PROFILE
+          consumed_map[size] = 0 if not consumed_map.has_key? size
+          consumed_map[size] = consumed_map[size] +1
+        }
+      }
+    end
+    self.consumed_gear_sizes = consumed_map
+  end
+  
+  def to_xml(options={})
+    options[:tag_name] = "user"
+    super(options)
+  end
+end

data/app/models/result_io.rb

@@ -0,0 +1,67 @@
+class ResultIO
+  attr_accessor :debugIO, :resultIO, :messageIO, :errorIO, :appInfoIO, :exitcode, :data, :cart_commands, :cart_properties, :hasUserActionableError
+  
+  def initialize
+    @debugIO = StringIO.new
+    @resultIO = StringIO.new
+    @messageIO = StringIO.new
+    @errorIO = StringIO.new
+    @appInfoIO = StringIO.new
+    @data = ""
+    @exitcode = 0
+    @cart_commands = []
+    @cart_properties = {}
+    @hasUserActionableError = false
+  end
+  
+  def append(resultIO)
+    self.debugIO << resultIO.debugIO.string
+    self.resultIO << resultIO.resultIO.string
+    self.messageIO << resultIO.messageIO.string
+    self.errorIO << resultIO.errorIO.string
+    self.appInfoIO << resultIO.appInfoIO.string
+    self.cart_commands += resultIO.cart_commands
+    self.cart_properties = resultIO.cart_properties.merge(self.cart_properties)
+    self.exitcode = resultIO.exitcode
+    self.data += resultIO.data
+
+    if resultIO.exitcode != 0
+      if resultIO.hasUserActionableError
+        unless (!self.hasUserActionableError) && self.exitcode != 0
+          self.hasUserActionableError = true
+        end
+      else
+        self.hasUserActionableError = false
+      end
+    end
+
+    self
+  end
+  
+  def to_s
+    str = "--DEBUG--\n#{@debugIO.string}\n" +
+          "--RESULT--\n#{@resultIO.string}\n" +
+          "--MESSAGE--\n#{@messageIO.string}\n" +
+          "--ERROR--\n#{@errorIO.string}\n" +
+          "--APP INFO--\n#{@appInfoIO.string}\n" +
+          "--CART COMMANDS--\n#{@cart_commands.join("\n")}\n" +
+          "--CART PROPERTIES--\n#{@cart_properties.inspect}\n" +
+          "--DATA--\n#{@data}\n" +
+          "--EXIT CODE--\n#{@exitcode}\n" +          
+          "--USER ACTIONABLE--\n#{@hasUserActionableError}\n"
+  end
+  
+  def to_json(*args)
+    reply = LegacyReply.new
+    reply.debug = @debugIO.string
+    reply.messages = @messageIO.string
+    if !@errorIO.string.empty?
+      reply.result = @errorIO.string
+    else
+      reply.result = @resultIO.string
+    end
+    reply.data = @data
+    reply.exit_code = @exitcode
+    reply.to_json(*args)
+  end
+end

data/app/models/usage_record.rb

@@ -0,0 +1,37 @@
+class UsageRecord < OpenShift::UserModel
+  
+  EVENTS = { :begin => "begin",
+             :end => "end",
+             :continue => "continue" }
+             
+  USAGE_TYPES = { :gear_usage => "GEAR_USAGE",
+                  :addtl_fs_gb => "ADDTL_FS_GB" }
+
+  attr_accessor :uuid, :event, :time, :sync_time, :user, :usage_type, :gear_uuid, :gear_size, :addtl_fs_gb
+  primary_key :uuid
+  exclude_attributes :user
+
+  def initialize(event=nil, user=nil, time=nil, uuid=nil, usage_type=nil)
+    self.uuid = uuid ? uuid : OpenShift::Model.gen_uuid
+    self.event = event
+    self.time = time ? time : Time.now.utc
+    self.user = user
+    self.usage_type = usage_type
+    self.sync_time = nil
+  end
+
+  # Deletes the usage record from the datastore
+  def delete
+    super(user.login)
+  end
+
+  # Saves the usage record to the datastore
+  def save
+    super(user.login)
+  end
+  
+  def delete_by_gear_uuid
+    OpenShift::DataStore.instance.delete_usage_record_by_gear_uuid(user.login, gear_uuid, usage_type)
+  end
+
+end

data/app/models/validators/app_validator.rb

@@ -0,0 +1,30 @@
+class AppValidator < ActiveModel::Validator
+  APP_NAME_MAX_LENGTH = 32 unless defined? APP_NAME_MAX_LENGTH
+  APP_NAME_MIN_LENGTH = 1 unless defined? APP_NAME_MIN_LENGTH
+  def validate(record)
+    attributes.each do |attribute|
+      value = record.read_attribute_for_validation(attribute)
+      if attribute == "name"
+        validate_name(record, attribute, valuse)
+      end
+    end
+  end
+
+  def validate_name(record, attribute, val)
+    if val.nil?
+      record.errors.add(attribute, {:message => "Name is required and cannot be blank.", :exit_code => 105})
+    end
+    if !(val =~ /\A[A-Za-z0-9]+\z/)
+      record.errors.add(attribute, {:message => "Invalid name. Name must only contain alphanumeric characters.", :exit_code => 105})
+    end
+    if val and val.length > APP_NAME_MAX_LENGTH
+      record.errors.add(attribute, {:message => "Name is too long.  Maximum length is #{APP_NAME_MAX_LENGTH} characters.", :exit_code => 105})
+    end
+    if val and val.length < APP_NAME_MIN_LENGTH
+      record.errors.add(attribute, {:message => "Name is too short.  Minimum length is #{APP_NAME_MIN_LENGTH} characters.", :exit_code => 105})
+    end
+    if val and OpenShift::ApplicationContainerProxy.blacklisted? val
+      record.errors.add(attribute, {:message => "Name is not allowed.  Please choose another.", :exit_code => 105})
+    end
+  end
+end

data/app/models/validators/key_validator.rb

@@ -0,0 +1,30 @@
+class KeyValidator < ActiveModel::Validator
+    KEY_NAME_MAX_LENGTH = 256 unless defined? KEY_NAME_MAX_LENGTH
+    KEY_NAME_MIN_LENGTH = 1 unless defined? KEY_NAME_MIN_LENGTH
+  def validate(record)
+    if !record.content
+      record.errors.add("content", {:message => "Key content is required and cannot be blank.", :exit_code => 108})
+    end
+    if record.content and !(record.content=~ /\A[A-Za-z0-9\+\/=]+\z/)
+      record.errors.add("content", {:message => "Invalid key content.", :exit_code => 108})
+    end
+    if !record.name
+      record.errors.add("name", {:message => "Key name is required and cannot be blank.", :exit_code => 117})
+    end
+    if record.name and  !(record.name =~ /\A[A-Za-z0-9]+\z/)
+      record.errors.add("name", {:message => "Invalid key name. Name must only contain alphanumeric characters.", :exit_code => 117})
+    end
+    if record.name and record.name.length > KEY_NAME_MAX_LENGTH
+      record.errors.add("name", {:message => "Key name is too long.  Maximum length is #{KEY_NAME_MAX_LENGTH} characters.", :exit_code => 117})
+    end
+    if record.name and record.name.length < KEY_NAME_MIN_LENGTH
+      record.errors.add("name", {:message => "Key name is too short.  Minimum length is #{KEY_NAME_MIN_LENGTH} characters.", :exit_code => 117})
+    end
+    if !record.type
+      record.errors.add("type", {:message => "Key type is required and cannot be blank.", :exit_code => 116})
+    end
+    if record.type and !Key::VALID_SSH_KEY_TYPES.include?(record.type)
+      record.errors.add("type", {:message => "Invalid key type.  Valid types are #{Key::VALID_SSH_KEY_TYPES.join(',')}", :exit_code => 116})
+    end
+  end
+end

data/app/models/validators/namespace_validator.rb

@@ -0,0 +1,18 @@
+class NamespaceValidator < ActiveModel::EachValidator
+  NAMESPACE_MAX_LENGTH = 16 unless defined? NAMESPACE_MAX_LENGTH
+  NAMESPACE_MIN_LENGTH = 1 unless defined? NAMESPACE_MIN_LENGTH
+
+  def validate_each(record, attribute, val)
+    if !val
+      record.errors.add(attribute, {:message => "Namespace is required and cannot be blank.", :exit_code => 106})
+    elsif val and val.length < NAMESPACE_MIN_LENGTH
+      record.errors.add(attribute, {:message => "Namespace is too short.  Minimum length is #{NAMESPACE_MIN_LENGTH} characters.", :exit_code => 106})
+    elsif val and val.length > NAMESPACE_MAX_LENGTH
+      record.errors.add(attribute, {:message => "Namespace is too long.  Maximum length is #{NAMESPACE_MAX_LENGTH} characters.", :exit_code => 106})
+    elsif val and !(val =~ /\A[A-Za-z0-9]+\z/)
+      record.errors.add(attribute, {:message => "Invalid namespace. Namespace must only contain alphanumeric characters.", :exit_code => 106})
+    elsif val and OpenShift::ApplicationContainerProxy.blacklisted? val
+      record.errors.add(attribute, {:message => "Namespace is not allowed.  Please choose another.", :exit_code => 106})
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,36 @@
+Rails.application.routes.draw do
+  match 'cartridge'       => 'legacy_broker#cartridge_post', :via => [:post]
+  match 'embed_cartridge' => 'legacy_broker#embed_cartridge_post', :via => [:post]
+  match 'domain'          => 'legacy_broker#domain_post', :via => [:post]
+  match 'userinfo'        => 'legacy_broker#user_info_post', :via => [:post]
+  match 'cartlist'        => 'legacy_broker#cart_list_post', :via => [:post]
+  match 'ssh_keys'        => 'legacy_broker#ssh_keys_post', :via => [:post]    
+  scope "/rest" do
+    resource :api, :only => [:show], :controller => :base
+    resource :environment, :only => [:show], :controller => :environment
+    resource :user, :only => [:show, :destroy], :controller => :user do
+      resources :keys, :controller => :keys, :constraints => { :id => /[\w]+/ } 
+    end
+    resources :cartridges, :only => [:index, :show], :constraints => { :id => /standalone|embedded/ }
+    resources :quickstarts, :only => [:index, :show]
+    resources :application_templates
+    #keeping for backward compatibility
+    resources :application_template, :controller => :application_templates
+    resources :estimates, :constraints => { :id => /[\w]+/ }, :only => [:index, :show]
+
+    # Allow restful update of the domain name via the standard id parameter
+    match "domains/:existing_id" => "domains#update", :via => :put, :existing_id => /[A-Za-z0-9]+/
+    resources :domains, :constraints => { :id => /[A-Za-z0-9]+/ } do
+      resources :applications, :constraints => { :id => /[\w]+/ } do
+        resource :descriptor, :only => [:show]
+        resource :gears, :only => [:show]
+        resources :gear_groups, :constraints => { :id => /[A-Za-z0-9]+/ }, :only => [:index, :show]
+        resources :cartridges, :controller => :emb_cart, :only => [:index, :show, :create, :update, :destroy], :constraints => { :id => /([\w\-]+(-)([\d]+(\.[\d]+)*)+)/ } do
+            resources :events, :controller => :emb_cart_events, :only => [:create]
+        end
+        resources :events, :controller => :app_events, :only => [:create]
+        resource :dns_resolvable, :only => [:show], :controller => :dns_resolvable
+      end
+    end
+  end
+end