openshift-origin-controller 1.3.2

data/app/models/gear.rb

@@ -0,0 +1,376 @@
+class Gear < OpenShift::Model
+  attr_accessor :uuid, :uid, :server_identity, :group_instance_name, :node_profile, :container, :app, :configured_components, :name
+  primary_key :uuid
+  exclude_attributes :container, :app
+  
+  def initialize(app, group_instance, uuid=nil, uid=nil)
+    self.app = app
+    @uuid = uuid || OpenShift::Model.gen_uuid
+    self.name = @uuid[0..9]
+    self.group_instance_name = group_instance.name
+    self.node_profile = group_instance.node_profile
+    self.configured_components = []
+    @uid = uid
+    get_proxy
+  end
+  
+  def node_profile
+    # node_profile can be nil for older data.  Should migrate everything to have a node_profile 
+    # with the next major migration.  Although technically node_profile shouldn't even be on gear.
+    if @node_profile.nil?
+      return Application::DEFAULT_NODE_PROFILE
+    else
+      return @node_profile
+    end
+  end
+  
+  def get_proxy
+    if self.container.nil? and !@server_identity.nil?
+      self.container = OpenShift::ApplicationContainerProxy.instance(@server_identity)
+    end    
+    return self.container
+  end
+  
+  def create
+    if server_identity.nil?
+      ret = nil
+      begin
+        self.app.ngears += 1
+        self.container = OpenShift::ApplicationContainerProxy.find_available(self.node_profile)
+        self.server_identity = self.container.id
+        self.uid = self.container.reserve_uid
+        self.group_instance.gears << self
+        self.app.save
+        ret = self.container.create(app,self)
+        self.app.track_usage(self, UsageRecord::EVENTS[:begin]) if ret.exitcode == 0
+      rescue Exception => e
+        Rails.logger.debug e.message
+        Rails.logger.debug e.backtrace.join("\n")
+        ret = ResultIO.new
+        ret.errorIO << e.message
+        ret.exitcode = 5
+      end
+
+      ## recovery action if creation failed above
+      if ret.exitcode != 0
+        begin
+          get_proxy.destroy(self.app, self)
+        rescue Exception => e
+        end
+        self.app.ngears -= 1
+        self.group_instance.gears.delete(self)
+        self.app.save
+        raise OpenShift::NodeException.new("Unable to create gear on node", 1, ret)
+      end
+      return ret
+    end
+  end
+
+  def destroy
+    ret = get_proxy.destroy(app, self)
+    if ret.exitcode == 0
+      self.app.destroyed_gears = [] unless self.app.destroyed_gears
+      self.app.destroyed_gears << @uuid
+      track_destroy_usage
+      self.app.ngears -= 1
+      self.group_instance.gears.delete(self)
+      app.process_cartridge_commands(ret)
+      self.app.save
+    else
+      raise OpenShift::NodeException.new("Unable to destroy gear on node", 1, ret)
+    end
+    return ret
+  end
+
+  def force_destroy
+    ret = nil
+    begin
+      begin
+        ret = get_proxy.destroy(app, self)
+      rescue Exception => e
+        Rails.logger.error("ERROR: Ignoring a failed destroy for gear with uuid: #{uuid}")
+      end
+      self.app.destroyed_gears = [] unless self.app.destroyed_gears
+      self.app.destroyed_gears << @uuid
+      track_destroy_usage
+    ensure
+      self.app.ngears -= 1
+      self.group_instance.gears.delete(self)
+      if ret
+        begin
+          app.process_cartridge_commands(ret)
+        rescue Exception => e
+          Rails.logger.error("ERROR: Ignoring a failed process_cartridge_commands for gear with uuid: #{uuid}")
+        end
+      end
+      self.app.save
+    end
+    return ret
+  end
+  
+  def configure(comp_inst, template_git_url=nil)
+    r = ResultIO.new
+    return r if self.configured_components.include?(comp_inst.name)
+    result_io, cart_data = get_proxy.configure_cartridge(app, self, comp_inst.parent_cart_name, template_git_url)
+    r.append result_io
+    comp_inst.process_cart_data(cart_data)
+    comp_inst.process_cart_properties(result_io.cart_properties)
+    self.configured_components.push(comp_inst.name)
+    r
+  end
+  
+  def deconfigure(comp_inst, force=false)
+    r = ResultIO.new
+    return r unless self.configured_components.include?(comp_inst.name) or force
+    r.append get_proxy.deconfigure_cartridge(app,self,comp_inst.parent_cart_name)
+    self.configured_components.delete(comp_inst.name)
+    r
+  end
+
+  def execute_connector(comp_inst, connector_name, input_args)
+    get_proxy.execute_connector(app, self, comp_inst.parent_cart_name, connector_name, input_args)
+  end
+  
+  def get_execute_connector_job(cart, connector_name, input_args)
+    get_proxy.get_execute_connector_job(app, self, cart, connector_name, input_args)
+  end
+
+  def start(comp_inst)
+    get_proxy.start(app, self, comp_inst.parent_cart_name)
+  end
+  
+  def stop(comp_inst)
+    get_proxy.stop(app, self, comp_inst.parent_cart_name) 
+  end
+  
+  def restart(comp_inst)
+    get_proxy.restart(app, self, comp_inst.parent_cart_name)
+  end
+  
+  def force_stop(comp_inst)
+    get_proxy.force_stop(app, self, comp_inst.parent_cart_name)
+  end
+  
+  def reload(comp_inst)
+    get_proxy.reload(app, self, comp_inst.parent_cart_name)
+  end
+  
+  def status(comp_inst)
+    get_proxy.status(app, self, comp_inst.parent_cart_name)
+  end
+
+  def status_job(comp_inst)
+    job = get_proxy.get_status_job(app, self, comp_inst.parent_cart_name)
+    job
+  end
+  
+  def show_state()
+    get_proxy.show_state(app, self)
+  end
+
+  def tidy(comp_inst)
+    get_proxy.tidy(app, self, comp_inst.parent_cart_name)
+  end
+
+  def expose_port(comp_inst)
+    get_proxy.expose_port(app, self, comp_inst.parent_cart_name)
+  end
+
+  def conceal_port(comp_inst)
+    get_proxy.conceal_port(app, self, comp_inst.parent_cart_name)
+  end
+ 
+  def show_port(comp_inst)
+    get_proxy.show_port(app, self, comp_inst.parent_cart_name)
+  end
+ 
+  def threaddump(comp_inst)
+    get_proxy.threaddump(app, self, comp_inst.parent_cart_name)
+  end
+  
+  def system_messages(comp_inst)
+    get_proxy.system_messages(app, self, comp_inst.parent_cart_name)
+  end
+  
+  def add_alias(server_alias)
+    if app.gear.uuid == self.uuid
+      get_proxy.add_alias(app, self, server_alias)
+    else
+      ResultIO.new
+    end
+  end
+  
+  def remove_alias(server_alias)
+    if app.gear.uuid == self.uuid
+      get_proxy.remove_alias(app, self, server_alias)
+    else
+      ResultIO.new
+    end
+  end
+    
+  def add_authorized_ssh_key(ssh_key, key_type=nil, comment=nil)
+    get_proxy.add_authorized_ssh_key(app, self, ssh_key, key_type, comment)
+  end
+  
+  def remove_authorized_ssh_key(ssh_key, comment=nil)
+    get_proxy.remove_authorized_ssh_key(app, self, ssh_key, comment)
+  end
+  
+  def add_env_var(key, value)
+    get_proxy.add_env_var(app, self, key, value)
+  end
+  
+  def set_quota(storage_in_gb, inodes)
+    get_proxy.set_quota(self, storage_in_gb, inodes)
+  end
+  
+  def get_quota()
+    get_proxy.get_quota(self)
+  end
+  
+  def gear_quota_job_show()
+    job = get_proxy.get_show_gear_quota_job(self)
+    job
+  end
+  
+  def gear_quota_job_update(storage_in_gb, inodes)
+    job = get_proxy.get_update_gear_quota_job(self, storage_in_gb, inodes)
+    job
+  end
+  
+  def app_state_job_show()
+    job = get_proxy.get_show_state_job(app, self)
+    job
+  end
+ 
+  def env_var_job_add(key, value)
+    job = get_proxy.get_env_var_add_job(app, self, key, value)
+    job
+  end
+  
+  def ssh_key_job_add(ssh_key, ssh_key_type, ssh_key_comment)
+    job = get_proxy.get_add_authorized_ssh_key_job(app, self, ssh_key, ssh_key_type, ssh_key_comment)
+    job
+  end
+  
+  def broker_auth_key_job_add(iv, token)
+    job = get_proxy.get_broker_auth_key_add_job(app, self, iv, token)
+    job
+  end
+  
+  def env_var_job_remove(key)
+    job = get_proxy.get_env_var_remove_job(app, self, key)
+    job
+  end
+  
+  def ssh_key_job_remove(ssh_key, ssh_key_comment)
+    job = get_proxy.get_remove_authorized_ssh_key_job(app, self, ssh_key, ssh_key_comment)
+    job
+  end
+  
+  def broker_auth_key_job_remove()
+    job = get_proxy.get_broker_auth_key_remove_job(app, self)
+    job
+  end
+  
+  def remove_env_var(key)
+    get_proxy.remove_env_var(app, self, key)
+  end
+  
+  def add_broker_auth_key(iv,token)
+    get_proxy.add_broker_auth_key(app, self, iv, token)
+  end
+  
+  def remove_broker_auth_key
+    get_proxy.remove_broker_auth_key(app, self)    
+  end
+  
+  def cartridges
+    gi = group_instance
+    carts = gi.component_instances.map{ |comp_instance_name| app.comp_instance_map[comp_instance_name].parent_cart_name }
+    carts.delete(app.name)
+    carts
+  end
+  
+  def group_instance
+    self.app.group_instance_map[self.group_instance_name]
+  end
+  
+  def group_instance_name
+    return @group_instance_name if self.app.group_instance_map[@group_instance_name]
+    self.app.group_instance_map.each { |gi_name, gi|
+      gi.gears.each { |gi_gear|
+        if gi_gear.uuid==self.uuid
+          @group_instance_name = gi_name
+          return @group_instance_name
+        end
+      }
+    }
+    return self.app.get_name_prefix
+  end
+
+  def prepare_namespace_update(dns_service, new_ns, old_ns)
+    results = []
+    gi = group_instance
+    contains_proxy = false
+    contains_framework = false
+    result_io = ResultIO.new
+    
+    gi.component_instances.each do |cname|
+      ci = self.app.comp_instance_map[cname]
+      contains_proxy = true if ci.parent_cart_name == self.app.proxy_cartridge
+      contains_framework = true if ci.parent_cart_name == self.app.framework    
+    end
+
+    if contains_proxy || !self.app.scalable
+      #proxy gear gets public dns
+      register_application(dns_service, old_ns, new_ns, self.app.name)
+    else
+      #non-proxy gear gets gear specific dns
+      register_application(dns_service, old_ns, new_ns, self.name)
+    end
+
+    if contains_framework
+      result_io.append call_update_namespace_hook(self.app.framework, new_ns, old_ns)
+    else
+      result_io.append call_update_namespace_hook("abstract", new_ns, old_ns)
+    end
+    result_io
+  end
+  
+  def self.valid_gear_size?(gear_size)
+    Rails.configuration.openshift[:gear_sizes].include?(gear_size)
+  end
+  
+  def self.gear_sizes_display_string
+    # Ex: (small(default)|jumbo|exlarge|large|medium|micro)
+    out = '('
+    Rails.configuration.openshift[:gear_sizes].each_with_index do |gear_size, index|
+      out += gear_size
+      out += '(default)' if gear_size == Rails.configuration.openshift[:default_gear_size] 
+      out += '|' unless index == (Rails.configuration.openshift[:gear_sizes].length - 1) 
+    end
+    out += ')'
+  end
+
+private
+
+  def track_destroy_usage
+    self.app.track_usage(self, UsageRecord::EVENTS[:end])
+    if self.group_instance.addtl_fs_gb && self.group_instance.addtl_fs_gb > 0
+      self.app.track_usage(self, UsageRecord::EVENTS[:end], UsageRecord::USAGE_TYPES[:addtl_fs_gb])
+    end
+  end
+
+  def call_update_namespace_hook(cart_name, new_ns, old_ns)
+    result = get_proxy.update_namespace(self.app, self, cart_name, new_ns, old_ns)
+    self.app.process_cartridge_commands(result)
+    return result
+  end
+
+  def register_application(dns_service, old_ns, new_ns, name)
+    public_hostname = get_proxy.get_public_hostname
+    dns_service.deregister_application(name, old_ns)
+    dns_service.register_application(name, new_ns, public_hostname)
+  end
+end

data/app/models/group_instance.rb

@@ -0,0 +1,306 @@
+class GroupInstance < OpenShift::Model
+  attr_accessor :uuid, :app, :gears, :node_profile, :component_instances, :supported_min, :supported_max,
+    :name, :cart_name, :profile_name, :group_name, :reused_by, :min, :max, :addtl_fs_gb
+  primary_key :uuid
+  exclude_attributes :app
+
+  include LegacyBrokerHelper
+  
+  def initialize(app, cartname=nil, profname=nil, groupname=nil, path=nil)
+    self.uuid = OpenShift::Model.gen_uuid
+    self.app = app
+    self.name = path
+    self.cart_name = cartname
+    self.profile_name = profname
+    self.component_instances = []
+    self.group_name = groupname
+    self.reused_by = []
+    self.gears = []
+    self.addtl_fs_gb = 0
+    self.node_profile = app.node_profile
+    self.supported_min = 1
+    self.supported_max = -1
+    self.min = 1
+    self.max = -1
+  end
+  
+  def node_profile
+    # node_profile can be nil for older data.  Should migrate everything to have a node_profile 
+    # with the next major migration.
+    if @node_profile.nil?
+      return Application::DEFAULT_NODE_PROFILE
+    else
+      return @node_profile
+    end
+  end
+
+  def self.get(app, id)
+    app.group_instances.each do |ginst|
+      return ginst if ginst.uuid == id
+    end if app.group_instances
+    return nil
+  end
+
+  def merge_inst(ginst)
+    reused = [self.name, self.cart_name, self.profile_name, self.group_name]
+    self.reused_by << reused
+    self.name = ginst.name
+    self.cart_name = ginst.cart_name
+    self.profile_name = ginst.profile_name
+    self.group_name = ginst.group_name
+    ginst.component_instances.each { |ci_name|
+      cinst = self.app.comp_instance_map[ci_name]
+      next if cinst.nil?
+      cur_ginst = self.app.group_instance_map[cinst.group_instance_name]
+      self.app.group_instance_map[cinst.group_instance_name] = self if ginst==cur_ginst
+    }
+    self.component_instances = (self.component_instances + ginst.component_instances).uniq unless ginst.component_instances.nil?
+    if not ginst.gears.nil? and ginst.gears.length > 0
+      self.gears = [] if self.gears.nil?
+      @gears += ginst.gears
+      if self.gears.length == 0
+        self.uuid = ginst.uuid
+      else
+        # Since two gear groups are being merged and the structure is being changed,
+        # we cannot re-use the uuid from either of the two gear groups
+        # Also, how do we merge two group instances that have gears in them
+        # without deleting the gears that exist in them
+      end
+    end
+    self.supported_min, self.supported_max = GroupInstance::merge_min_max(self.supported_min, self.supported_max, ginst.supported_min, ginst.supported_max)
+    self.min, self.max = GroupInstance::merge_min_max(self.min, self.max, ginst.min, ginst.max)
+  end
+
+  def merge(cartname, profname, groupname, path, comp_instance_list=nil)
+    reused = [self.name, self.cart_name, self.profile_name, self.group_name]
+    self.reused_by << reused
+    self.name = path
+    self.cart_name = cartname
+    self.profile_name = profname
+    self.group_name = groupname
+    self.component_instances = (self.component_instances + comp_instance_list).uniq unless comp_instance_list.nil?
+    # component_instances remains a flat collection
+  end
+  
+  def fix_gear_uuid(app, gear)
+    #FIXME: backward compat: first gears UUID = app.uuid
+    if app.scalable
+      # Override/set gear's uuid with app's uuid if its a scalable app w/ the
+      # proxy component.
+      if self.component_instances.include? "@@app/comp-proxy/cart-haproxy-1.4"
+        gear.uuid = app.uuid
+        gear.name = app.name
+      end
+    else
+      # For non scalable app's, gear's uuid is the app uuid.
+      gear.uuid = app.uuid
+      gear.name = app.name
+    end
+  end
+
+  def add_gear(app)
+    gear = Gear.new(app, self)
+    fix_gear_uuid(app, gear)
+
+    # create the gear
+    create_result = gear.create
+
+    begin
+      if app.scalable and not self.component_instances.include? "@@app/comp-proxy/cart-haproxy-1.4"
+        app.add_dns(gear.name, app.domain.namespace, gear.get_proxy.get_public_hostname)
+      end
+    rescue Exception => e
+      Rails.logger.debug e.message
+      Rails.logger.debug e.backtrace.inspect
+      # Cleanup 
+      gear.destroy
+      raise e 
+    end
+
+    if @addtl_fs_gb.kind_of?(Integer) or @addtl_fs_gb.kind_of?(Float) and @addtl_fs_gb > 0
+      min_storage = get_cached_min_storage_in_gb()
+      set_quota(@addtl_fs_gb + min_storage, nil, [gear])
+    end
+
+    app.add_node_settings([gear])
+    return [create_result, gear]
+  end
+
+  def remove_gear(gear, force=false)
+    if force
+      return gear.force_destroy
+    else
+      return gear.destroy
+    end
+  end
+
+  def update_quota(additional_storage, inodes=nil, gear_list=nil)
+    set_quota(@addtl_fs_gb+additional_storage+get_cached_min_storage_in_gb, inodes, gear_list)
+  end
+
+  def set_quota(storage_in_gb, inodes=nil, gear_list=nil)
+    reply = ResultIO.new
+    tag = ""
+    previous_fs_gb = @addtl_fs_gb
+    gear_list = @gears if gear_list.nil?
+
+    handle = RemoteJob.create_parallel_job
+    RemoteJob.run_parallel_on_gears(gear_list, handle) { |exec_handle, gear|
+      job = gear.gear_quota_job_update(storage_in_gb, inodes)
+      RemoteJob.add_parallel_job(exec_handle, tag, gear, job)
+    }
+
+    RemoteJob.get_parallel_run_results(handle) { |tag, gear_uuid, output, status|
+      if status != 0
+        raise OpenShift::NodeException.new("Error setting quota on gear: #{gear_uuid} with status: #{status} and output: #{output}", 143)
+      else
+        @gears.each { |gi_gear|
+          if gi_gear.uuid == gear_uuid
+            # :end usage event for previous quota
+            unless previous_fs_gb.nil? || previous_fs_gb == 0
+              @addtl_fs_gb = previous_fs_gb
+              app.track_usage(gi_gear, UsageRecord::EVENTS[:end], UsageRecord::USAGE_TYPES[:addtl_fs_gb])
+            end
+
+            # :begin usage event for new quota
+            @addtl_fs_gb = storage_in_gb - get_cached_min_storage_in_gb
+
+            app.track_usage(gi_gear, UsageRecord::EVENTS[:begin], UsageRecord::USAGE_TYPES[:addtl_fs_gb]) if @addtl_fs_gb > 0
+            break
+          end
+        }      
+      end
+    }
+
+    reply
+  end
+  
+  def get_quota
+    additional_storage = @addtl_fs_gb.nil? ? 0 : Integer(@addtl_fs_gb)
+    return { "additional_gear_storage" => additional_storage, "base_gear_storage" => get_cached_min_storage_in_gb }
+  end
+
+  def get_cached_min_storage_in_gb
+    return 1 if @gears.nil? or @gears.length == 0
+
+    quota_blocks_str = get_cached(node_profile + "quota_blocks", :expires_in => 1.day) {@gears[0].get_proxy.get_quota_blocks}
+    quota_blocks = Integer(quota_blocks_str)
+    # calculate the minimum storage in GB - blocks are 1KB each
+    min_storage = quota_blocks / 1024 / 1024
+    return min_storage
+  end
+
+  def fulfil_requirements(app)
+    result_io = ResultIO.new
+    return result_io if not app.scalable
+    deficit = self.min - self.gears.length
+    u = CloudUser.find(self.app.user.login)
+    if (deficit + u.consumed_gears) > u.max_gears
+      raise OpenShift::UserException.new("#{u.login} has a gear limit of #{u.max_gears} and this app requires #{deficit} more gears. Check the 'scales_from' limit of all cartridges of the app?", 104) 
+    end
+    deficit.times do
+      result, new_gear = add_gear(app)
+      result_io.append result
+    end
+    result_io
+  end
+
+  def get_unconfigured_gears(comp_inst)
+    unconfigured_gears = []
+    self.gears.each do |gear|
+      unconfigured_gears << gear if not gear.configured_components.include?(comp_inst.name)
+    end
+    unconfigured_gears
+  end
+
+  def gears=(data)
+    @gears = [] if @gears.nil?
+    data.each do |hash|
+      if hash.class == Gear
+        @gears.push hash
+      else
+        gear = Gear.new(@app,self)
+        gear.attributes=hash
+        @gears.push gear
+      end                             
+    end                               
+  end
+
+  def elaborate(profile, group, parent_comp_path, app)
+    group_inst_hash = {}
+    new_components = []
+    group.component_refs.each { |comp_ref|
+      if self.cart_name == app.name
+        cpath = parent_comp_path + comp_ref.get_name_prefix(profile)
+      else
+        cpath = parent_comp_path + "/cart-" + self.cart_name + comp_ref.get_name_prefix(profile)
+      end
+      old_ci = app.comp_instance_map[cpath]
+      ci = ComponentInstance.new(self.cart_name, self.profile_name, self.group_name, comp_ref.name, cpath, self)
+      ci.cart_data += old_ci.cart_data unless old_ci.nil?
+      ci.addtl_fs_gb = old_ci.addtl_fs_gb unless old_ci.nil?
+      ci.process_cart_properties(old_ci.cart_properties) unless old_ci.nil?
+      new_components << cpath
+      self.component_instances << cpath if not self.component_instances.include? cpath
+      app.comp_instance_map[cpath] = ci
+      app.working_comp_inst_hash[cpath] = ci
+      comp_groups = ci.elaborate(app)
+      c_comp,c_prof,c_cart = ci.get_component_definition(app)
+      c_group = c_prof.groups(ci.parent_cart_group)
+      self.supported_min, self.supported_max = GroupInstance::merge_min_max(self.supported_min, @supported_max, c_group.scaling.min, c_group.scaling.max)
+      self.min, self.max = GroupInstance::merge_min_max(self.min, @max, c_group.scaling.min, c_group.scaling.max)
+      group_inst_hash[comp_ref.name] = comp_groups
+    }
+    
+    # TODO: For FUTURE : if one wants to optimize by merging the groups
+    # then pick group_inst_hash and merge them up
+    # e.g. first component needs 4 groups, second one needs 3
+    #   then, make the first three groups of first component also contain
+    #   the second component and discard the second component's 3 groups
+    #    (to remove groups, erase them from app.comp_instance_map for sure)
+
+    # remove any entries in component_instances that are not part of 
+    # application's working component instance hash, because that indicates
+    # deleted components
+    self.component_instances.delete_if { |cpath| app.working_comp_inst_hash[cpath].nil? }
+    new_components
+  end
+
+  def supported_max
+    if app and not app.scalable
+      return @supported_min 
+    else
+      return @supported_max
+    end
+  end
+
+  def max
+    if app and not app.scalable
+      return @min 
+    else
+      return @max
+    end
+  end
+
+  def self.merge_min_max(min1, max1, min2, max2)
+    newmin = min1>min2 ? min1 : min2
+
+    if max1 < max2 
+      if max1 >= 0
+        newmax = max1
+      else
+        newmax = max2
+      end
+    elsif max2 >= 0
+      newmax = max2
+    else
+      newmax = max1
+    end
+
+    if newmin > newmax and newmax >= 0
+      newmin = newmax  
+    end
+    return newmin,newmax
+  end
+
+end