openshift-origin-controller 1.3.2

data/app/models/application_template.rb

@@ -0,0 +1,27 @@
+class ApplicationTemplate < OpenShift::UserModel
+  attr_accessor :uuid, :display_name, :descriptor_yaml, :git_url, :tags, :gear_cost, :metadata
+  primary_key :uuid
+  
+  def initialize(display_name=nil,descriptor_yaml=nil,git_url=nil,tags=[], gear_cost=0, metadata = {})
+    self.display_name, self.descriptor_yaml, self.git_url, self.tags, self.gear_cost, self.metadata =
+      display_name, descriptor_yaml, git_url, tags, gear_cost, metadata
+      self.uuid = OpenShift::Model.gen_uuid
+  end
+  
+  def self.find(id)
+    super(nil,id)
+  end
+  
+  def self.find_all(tag=nil)
+    tag = {:tag => tag} unless tag.nil?
+    super(nil,tag)
+  end
+  
+  def save
+    super(nil)
+  end
+  
+  def delete
+    super(nil)
+  end
+end

data/app/models/cartridge_cache.rb

@@ -0,0 +1,51 @@
+class CartridgeCache
+  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.cartridges
+    get_cached("all_cartridges", :expires_in => 1.day) {OpenShift::ApplicationContainerProxy.find_one().get_available_cartridges}
+  end
+
+  FRAMEWORK_CART_NAMES = [#RHEL6 cartridges
+                          "python-2.6", "jenkins-1.4", "ruby-1.8", "ruby-1.9",
+                          "diy-0.1", "php-5.3", "jbossas-7", "jbosseap-6.0", "jbossews-1.0",
+                          "perl-5.10", "nodejs-0.6", "zend-5.6",
+                         ]
+  def self.cartridge_names(cart_type=nil)
+    cart_names = cartridges.map{|c| c.name}
+
+    if cart_type == 'standalone'
+      return cart_names & FRAMEWORK_CART_NAMES
+    elsif cart_type == 'embedded'
+      return (cart_names - FRAMEWORK_CART_NAMES)
+    else
+      return cart_names
+    end
+  end
+
+  def self.find_cartridge(capability)
+    carts = self.cartridges
+    carts.each do |cart|
+      return cart if cart.all_capabilities.include?(capability)
+      return cart if cart.name == capability
+    end
+    return nil
+  end
+end

data/app/models/cloud_user.rb

@@ -0,0 +1,334 @@
+ class CloudUser < OpenShift::UserModel
+  attr_accessor :login, :uuid, :system_ssh_keys, :env_vars, :ssh_keys, :domains, :max_gears, :consumed_gears, :applications,
+                :auth_method, :save_jobs, :usage_records, :gear_usage_records, :capabilities, :parent_user_login,
+                :plan_id, :usage_account_id, :pending_plan_id, :pending_plan_uptime
+  primary_key :login
+  exclude_attributes :applications, :auth_method, :save_jobs, :usage_records
+  require_update_attributes :system_ssh_keys, :env_vars, :ssh_keys, :domains
+  private :login=, :uuid=, :save_jobs=
+
+  validates_each :login do |record, attribute, val|
+    record.errors.add(attribute, {:message => "Invalid characters found in login '#{val}' ", :exit_code => 107}) if val =~ /["\$\^<>\|%\/;:,\\\*=~]/
+  end
+
+  validates_each :ssh_keys do |record, attribute, val|
+    val.each do |key_name, key_info|
+      if !(key_name =~ /\A[A-Za-z0-9]+\z/)
+        record.errors.add attribute, {:message => "Invalid key name: #{key_name}", :exit_code => 117}
+      end
+      if !Key::VALID_SSH_KEY_TYPES.include?(key_info['type'])
+        record.errors.add attribute, {:message => "Invalid key type: #{key_info['type']}", :exit_code => 116}
+      end
+      if !(key_info['key'] =~ /\A[A-Za-z0-9\+\/=]+\z/)
+        record.errors.add attribute, {:message => "Invalid ssh key: #{key_info['key']}", :exit_code => 108}
+      end
+    end if val
+  end
+
+  def initialize(login=nil, ssh=nil, ssh_type=nil, key_name=nil, capabilities=nil,
+                 parent_login=nil)
+    super()
+    if not ssh.nil?
+      ssh_type = Key::DEFAULT_SSH_KEY_TYPE if ssh_type.to_s.strip.length == 0
+      self.ssh_keys = {} unless self.ssh_keys
+      key_name = Key::DEFAULT_SSH_KEY_NAME if key_name.to_s.strip.length == 0
+      self.ssh_keys[key_name] = { "key" => ssh, "type" => ssh_type }
+    else
+      self.ssh_keys = {} unless self.ssh_keys
+    end
+    self.login = login
+    self.domains = []
+    self.max_gears = Rails.configuration.openshift[:default_max_gears]
+    self.capabilities = capabilities || {}
+    unless self.capabilities.has_key?('gear_sizes')
+        # set the user's gear capabilities to default if not specified
+        self.capabilities['gear_sizes'] =
+          Rails.application.config.openshift[:default_gear_capabilities] ||
+          [ Rails.application.config.openshift[:default_gear_size] ]
+    end
+    self.parent_user_login = parent_login
+
+    self.consumed_gears = 0
+  end
+
+  def save
+    resultIO = ResultIO.new
+    unless persisted?
+      #new user record
+      resultIO.append(create())
+    end
+
+    if applications && !applications.empty? && save_jobs
+      gears = []
+      tag = ""
+
+      applications.each do |app|
+        app.gears.each do |gear|
+          if !app.destroyed_gears || !app.destroyed_gears.include?(gear.uuid)
+            gears << gear
+          end
+        end
+      end
+
+      handle = RemoteJob.create_parallel_job
+
+      RemoteJob.run_parallel_on_gears(gears, handle) { |exec_handle, gear|
+        if save_jobs['removes']
+          save_jobs['removes'].each do |action, values|
+            case action
+            when 'ssh_keys'
+              values.each do |value|
+                ssh_key = value[0]
+                ssh_key_comment = value[1]
+                job = gear.ssh_key_job_remove(ssh_key, ssh_key_comment)
+                RemoteJob.add_parallel_job(exec_handle, tag, gear, job)
+              end
+            when 'env_vars'
+              values.each do |value|
+                env_var_key = value[0]
+                job = gear.env_var_job_remove(env_var_key)
+                RemoteJob.add_parallel_job(exec_handle, tag, gear, job)
+              end
+            when 'broker_auth_keys'
+              values.each do |value|
+                app_uuid = value[0]
+                if app_uuid == gear.app.uuid
+                  job = gear.broker_auth_key_job_remove
+                  RemoteJob.add_parallel_job(exec_handle, tag, gear, job)
+                end
+              end
+            end
+          end
+        end
+        if save_jobs['adds']
+          save_jobs['adds'].each do |action, values|
+            case action
+            when 'ssh_keys'
+              values.each do |value|
+                ssh_key = value[0]
+                ssh_key_type = value[1]
+                ssh_key_comment = value[2]
+                job = gear.ssh_key_job_add(ssh_key, ssh_key_type, ssh_key_comment)
+                RemoteJob.add_parallel_job(exec_handle, tag, gear, job)
+              end
+            when 'env_vars'
+              values.each do |value|
+                env_var_key = value[0]
+                env_var_value = value[1]
+                job = gear.env_var_job_add(env_var_key, env_var_value)
+                RemoteJob.add_parallel_job(exec_handle, tag, gear, job)
+              end
+            when 'broker_auth_keys'
+              values.each do |value|
+                app_uuid = value[0]
+                if app_uuid == gear.app.uuid
+                  iv = value[1]
+                  token = value[2]
+                  job = gear.broker_auth_key_job_add(iv, token)
+                  RemoteJob.add_parallel_job(exec_handle, tag, gear, job)
+                end
+              end
+            end
+          end
+        end
+      }
+      RemoteJob.get_parallel_run_results(handle) { |tag, gear, output, status|
+        if status != 0
+          raise OpenShift::NodeException.new("Error updating settings on gear: #{gear} with status: #{status} and output: #{output}", 143)
+        end
+      }
+      save_jobs['removes'].clear if save_jobs['removes']
+      save_jobs['adds'].clear if save_jobs['adds']
+    end
+
+    super(@login)
+
+    resultIO
+  end
+
+  def applications
+    @applications
+  end
+
+  def domains
+    @domains
+  end
+
+  def self.find_by_uuid(obj_type_of_uuid, uuid)
+    hash = OpenShift::DataStore.instance.find_by_uuid(obj_type_of_uuid, uuid)
+    return nil unless hash
+    hash_to_obj(hash)
+  end
+
+  def self.find_subaccounts_by_parent_login(parent_login)
+    hash_list = OpenShift::DataStore.instance.find_subaccounts_by_parent_login(parent_login)
+    return nil if hash_list.nil? or hash_list.empty?
+    hash_list.map {|hash| hash_to_obj(hash) }
+  end
+
+  def self.hash_to_obj(hash)
+    apps = []
+    if hash["apps"]
+      hash["apps"].each do |app_hash|
+        app = Application.hash_to_obj(app_hash)
+        apps.push(app)
+      end
+      hash.delete("apps")
+    end
+    domains = []
+    if hash["domains"]
+      hash["domains"].each do |domain_hash|
+        domain = Domain.hash_to_obj(domain_hash)
+        domains.push(domain)
+      end
+      hash.delete("apps")
+    end
+    usage_records = []
+    if hash["usage_records"]
+      hash["usage_records"].each do |usage_hash|
+        usage_record = UsageRecord.hash_to_obj(usage_hash)
+        usage_records.push(usage_record)
+      end
+      hash.delete("usage_records")
+    end
+    user = super(hash)
+    user.applications = apps
+    apps.each do |app|
+      app.user = user
+      app.reset_state
+    end
+
+    user.domains = domains
+    domains.each do |domain|
+      domain.user = user
+    end
+
+    user.usage_records = usage_records
+    usage_records.each do |usage_record|
+      usage_record.user = user
+    end
+
+    user
+  end
+
+  def force_delete
+    self.applications.each do |app|
+      app.cleanup_and_delete()
+    end if self.applications && !self.applications.empty?
+    self.domains.each do |domain|
+      domain.delete
+    end if self.domains && !self.domains.empty?
+    user = CloudUser.find(self.login)
+    user.delete if user
+  end
+
+  def delete
+    if (self.domains && !self.domains.empty?) or (self.applications && !self.applications.empty?)
+      raise OpenShift::UserException.new("Error: User '#{@login}' has valid domain or applications.", 139)
+    end
+    super(@login)
+  end
+
+  def self.find(login)
+    super(login,login)
+  end
+
+  def self.find_all_logins(opts=nil)
+    OpenShift::DataStore.instance.find_all_logins(opts)
+  end
+
+  def add_system_ssh_key(app_name, key)
+    self.system_ssh_keys = {} unless self.system_ssh_keys
+    self.system_ssh_keys[app_name] = key
+    add_save_job('adds', 'ssh_keys', [key, nil, app_name])
+  end
+
+  def remove_system_ssh_key(app_name)
+    self.system_ssh_keys = {} unless self.system_ssh_keys
+    key = self.system_ssh_keys[app_name]
+    return unless key
+    self.system_ssh_keys.delete app_name
+    add_save_job('removes', 'ssh_keys', [key, app_name])
+  end
+
+  def add_ssh_key(key_name, key, key_type=nil)
+    self.ssh_keys = {} unless self.ssh_keys
+    key_type = Key::DEFAULT_SSH_KEY_TYPE if key_type.to_s.strip.length == 0
+    self.ssh_keys[key_name] = { "key" => key, "type" => key_type }
+    add_save_job('adds', 'ssh_keys', [key, key_type, key_name])
+  end
+
+  def remove_ssh_key(key_name)
+    self.ssh_keys = {} unless self.ssh_keys
+
+    # validations
+    raise OpenShift::UserKeyException.new("ERROR: Key name '#{key_name}' doesn't exist for user #{self.login}", 118) if not self.ssh_keys.has_key?(key_name)
+
+    add_save_job('removes', 'ssh_keys', [self.ssh_keys[key_name]["key"], key_name])
+    self.ssh_keys.delete key_name
+  end
+
+  def update_ssh_key(key, key_type=nil, key_name=nil)
+    key_name = Key::DEFAULT_SSH_KEY_NAME if key_name.to_s.strip.length == 0
+    remove_ssh_key(key_name)
+    add_ssh_key(key_name, key, key_type)
+  end
+
+  def get_ssh_key
+    raise OpenShift::UserKeyException.new("ERROR: No ssh keys found for user #{self.login}",
+                                           123) if self.ssh_keys.nil? or not self.ssh_keys.kind_of?(Hash)
+    key_name = (self.ssh_keys.key?(Key::DEFAULT_SSH_KEY_NAME)) ? Key::DEFAULT_SSH_KEY_NAME : self.ssh_keys.keys[0]
+    self.ssh_keys[key_name]
+  end
+
+  def add_env_var(key, value)
+    self.env_vars = {} unless self.env_vars
+    self.env_vars[key] = value
+    add_save_job('adds', 'env_vars', [key, value])
+  end
+
+  def remove_env_var(key)
+    self.env_vars = {} unless self.env_vars
+    self.env_vars.delete key
+    add_save_job('removes', 'env_vars', [key])
+  end
+
+  def add_save_job(section, object, value)
+    self.save_jobs = {} unless self.save_jobs
+    self.save_jobs[section] = {} unless self.save_jobs[section]
+    self.save_jobs[section][object] = [] unless self.save_jobs[section][object]
+    self.save_jobs[section][object] << value
+  end
+
+  private
+
+  def create
+    resultIO = ResultIO.new
+    notify_observers(:before_cloud_user_create)
+    begin
+      user = CloudUser.find(@login)
+      if user
+        #TODO Rework when we allow multiple domains per user
+        raise OpenShift::UserException.new("User with login '#{@login}' already exists", 102, resultIO)
+      end
+
+      begin
+        Rails.logger.debug "DEBUG: Attempting to add user '#{@login}'"
+        resultIO.debugIO << "Creating user entry login:#{@login}"
+        @uuid = OpenShift::Model.gen_uuid
+        notify_observers(:cloud_user_create_success)
+      rescue Exception => e
+        Rails.logger.debug e
+        begin
+          notify_observers(:cloud_user_create_error)
+        ensure
+          raise
+        end
+      end
+    ensure
+      notify_observers(:after_cloud_user_create)
+    end
+    resultIO
+  end
+
+end

data/app/models/component_instance.rb

@@ -0,0 +1,228 @@
+class ComponentInstance < OpenShift::Model
+  attr_accessor :state, :parent_cart_name, :parent_cart_profile, :parent_component_name, :parent_cart_group,
+                :name, :dependencies, :group_instance_name, :exec_order, :cart_data, :cart_properties, :addtl_fs_gb
+
+  def initialize (cartname=nil, profname=nil, groupname=nil, compname=nil, pathname=nil, gi=nil)
+    self.name = pathname
+    self.parent_cart_name = cartname
+    self.parent_cart_profile = profname
+    self.parent_cart_group = groupname
+    self.group_instance_name = gi.name unless gi.nil?
+    self.parent_component_name = compname
+    self.dependencies = []
+    self.exec_order = []
+    self.cart_data = []
+    self.cart_properties = {}
+    self.addtl_fs_gb = 0
+  end
+  
+  def process_cart_data(data)
+    data.chomp! if data
+    self.cart_data.push data
+  end
+
+  def process_cart_properties(properties)
+    properties.each do |key, value|
+      self.cart_properties[key] = value
+    end
+  end
+
+  def get_component_definition(app)
+    if self.parent_cart_name == app.name
+      cart = app
+    else
+      cart = CartridgeCache::find_cartridge(self.parent_cart_name)
+    end
+    raise Exception.new("Cartridge #{self.parent_cart_name} not found") if cart.nil?
+    profile = cart.profiles(self.parent_cart_profile)
+    group = profile.groups(self.parent_cart_group)
+    comp_name = group.component_refs(self.parent_component_name).component
+    comp = profile.components(comp_name)
+    return comp,profile,cart
+  end
+
+  def elaborate(app)
+    comp,profile,cart = get_component_definition(app)
+
+    self.dependencies = []
+    
+    # cart map has all the sub-cartridges that will get instantiated through this component instance
+    cart_map, cart_map_keys = get_cartridges_for_dependencies(comp, cart)
+
+    group_list = cart_map_keys.map { |key| 
+      cartprofile = cart_map[key]
+      elaborate_cartridge(cartprofile[0], cartprofile[1], app) 
+    }.flatten
+
+    self.dependencies.each do |dep|
+      cinst = app.comp_instance_map[dep]
+      new_conns = ComponentInstance.establish_connections(cinst, self, app)
+      new_conns.each { |conn|
+        if conn.from_connector.type.match(/^FILESYSTEM/) or conn.from_connector.type.match(/^AFUNIX/)
+          self.exec_order << dep if not self.exec_order.include? dep
+        end
+      }
+    end
+
+    ComponentInstance.establish_connections(self, self, app)
+
+    resolve_exec_order(app)
+
+    return group_list
+  end
+
+  def resolve_exec_order(app)
+    deps = self.dependencies.dup
+    self.dependencies.each { |dep| 
+      depinst = app.comp_instance_map[dep]
+      comp,p,c = depinst.get_component_definition(app)
+      if comp.depends_service and !comp.depends_service.empty?
+        comp.depends_service.each { |dependent_cart|
+          deps.each { |parent_dep| 
+            if parent_dep.include? dependent_cart 
+              # add parent_dep to exec_order
+              self.exec_order << parent_dep if not self.exec_order.include? parent_dep
+            end
+          }
+        }
+      end
+      self.exec_order << dep if not self.exec_order.include? dep 
+    }
+  end
+
+  def self.establish_connections(inst1, inst2, app)
+    comp1,prof1,cart1 = inst1.get_component_definition(app)
+    comp2,prof2,cart2 = inst2.get_component_definition(app)
+
+    new_connections = []
+    
+    comp1.publishes.each do |pub|
+      comp2.subscribes.each do |sub|
+        next if not pub.type==sub.type
+        ce = ConnectionEndpoint.new(inst1, inst2, pub, sub) 
+        app.conn_endpoints_list << ce
+        new_connections << ce
+      end
+    end
+    return if inst1==inst2
+    comp1.subscribes.each do |sub|
+      comp2.publishes.each do |pub|
+        next if not pub.type==sub.type
+        ce = ConnectionEndpoint.new(inst2, inst1, pub, sub) 
+        app.conn_endpoints_list << ce
+        new_connections << ce
+      end
+    end
+    new_connections
+  end
+
+  def elaborate_cartridge(cart, profile, app)
+    group_list = profile.groups.map do |g|
+       gpath = self.name + cart.get_name_prefix + g.get_name_prefix
+       gi = app.working_group_inst_hash[gpath]
+       if gi.nil?
+         gi = app.group_instance_map[gpath]
+         if gi.nil?
+           gi = GroupInstance.new(app, cart.name, profile.name, g.name, gpath) 
+         else
+           gi.merge(cart.name, profile.name, g.name, gpath)
+         end
+       else
+         gi.merge(cart.name, profile.name, g.name, gpath)
+       end
+       app.group_instance_map[gpath] = gi
+       app.working_group_inst_hash[gpath] = gi
+       sub_components = gi.elaborate(profile, g, self.name, app)
+       self.dependencies += sub_components
+       gi
+    end
+
+    # make connection_endpoints out of provided connections
+    profile.connections.each do |conn|
+      inst1 = ComponentInstance::find_component_in_cart(profile, app, conn.components[0], self.name)
+      inst2 = ComponentInstance::find_component_in_cart(profile, app, conn.components[1], self.name)
+      ComponentInstance::establish_connections(inst1, inst2, app)
+    end
+    
+    profile.group_overrides.each do |n, v|
+      from_cinst = ComponentInstance::find_component_in_cart(profile, app, n, self.name)
+      to_cinst = ComponentInstance::find_component_in_cart(profile, app, v, self.name)
+      next if from_cinst.nil? or to_cinst.nil?
+      app.group_override_map[from_cinst.group_instance_name] = to_cinst.group_instance_name
+      app.group_override_map[to_cinst.group_instance_name] = from_cinst.group_instance_name
+    end
+
+    return group_list
+  end
+
+  def self.find_component_in_cart(profile, app, comp_name, parent_path) 
+    # FIXME : comp_name could be a component_name only, feature_name, cartridge_name that 
+    #         one of the components depend upon, or a hierarchical name
+
+    comp_name_list = comp_name.split("/")
+    comp_name = comp_name_list.first
+    rest = comp_name_list[1..-1]
+
+    group_comp_refs = profile.groups.map { |g| g.component_refs }
+    comp_refs = group_comp_refs.flatten
+    comp_inst = nil
+    comp_refs.each { |comp_ref|
+      name_prefix = comp_ref.get_name_prefix(profile)
+      comp_inst = app.comp_instance_map[parent_path + name_prefix]
+      next if comp_inst.nil?
+      if name_prefix!=""
+        next if comp_ref.name!=comp_name
+        return comp_inst if rest.length==0
+        comp_name = rest.first
+        rest = rest[1..-1]
+      end
+      comp_inst.dependencies.each { |dep|
+        dep_inst = app.comp_instance_map[dep]
+        next if dep_inst.parent_cart_name != comp_name
+        return dep_inst if rest.length==0
+        c, dep_profile, ca = dep_inst.get_component_definition(app)
+        found_inst = self.find_component_in_cart(dep_profile, app, rest.join('/'), dep_inst.name)
+        return found_inst if not found_inst.nil?
+      }
+    }
+
+    return comp_inst
+  end
+
+  def set_additional_quota(app, fs_gb, inodes=nil)
+    changed_gbs = fs_gb - @addtl_fs_gb
+    gi = app.group_instance_map[self.group_instance_name]
+    gi.update_quota(changed_gbs, inodes)
+    @addtl_fs_gb = fs_gb
+  end
+
+  def self.collect_exec_order(app, cinst, return_list)
+    cinst.exec_order.each do |dep|
+      depinst = app.comp_instance_map[dep]
+      collect_exec_order(app, depinst, return_list)
+      return_list << dep if not return_list.include? dep
+    end
+  end
+
+  def get_cartridges_for_dependencies(comp, cart)
+    # resolve features into cartridges - two features may resolve
+    # into one cartridge only, e.g. depends = [db,db-failover] 
+    # will resolve into one mysql cartridge being instantiated with (master/slave) profile
+    cart_map = {}
+    cart_map_keys = []
+    depends = comp.depends + cart.requires_feature
+    
+    depends.each do |feature| 
+      cart = CartridgeCache::find_cartridge(feature)
+      raise OpenShift::UserException.new("Invalid cartridge specified: #{feature}",1) if cart.nil?
+      capability = feature
+      capability = nil if feature==cart.name
+      profile = cart.find_profile(capability)
+      key = cart.name + profile.name
+      cart_map_keys << key if not cart_map_keys.include? key
+      cart_map[key] = [cart, profile]
+    end
+    return cart_map, cart_map_keys
+  end
+
+end