openshift-origin-controller 1.3.2

data/app/models/connection_endpoint.rb

@@ -0,0 +1,10 @@
+class ConnectionEndpoint < OpenShift::Model
+  attr_accessor :from_comp_inst, :to_comp_inst, :from_connector, :to_connector
+  
+  def initialize(from_comp, to_comp, pub, sub)
+    self.from_comp_inst = from_comp.name
+    self.to_comp_inst = to_comp.name
+    self.from_connector = pub
+    self.to_connector = sub
+  end
+end

data/app/models/district.rb

@@ -0,0 +1,210 @@
+class District < OpenShift::Model
+  
+  attr_accessor :server_identities, :active_server_identities_size, :uuid, :creation_time, :available_capacity, :available_uids, :max_uid, :max_capacity, :externally_reserved_uids_size, :node_profile, :name
+  primary_key :uuid
+
+  def initialize()
+  end
+  
+  def construct(name, node_profile=nil)
+    self.uuid = OpenShift::Model.gen_uuid
+    self.creation_time = DateTime::now().strftime
+    self.server_identities = {}
+    self.available_capacity = Rails.configuration.msg_broker[:districts][:max_capacity]
+    self.available_uids = []
+    self.available_uids.fill(0, Rails.configuration.msg_broker[:districts][:max_capacity]) {|i| i+Rails.configuration.msg_broker[:districts][:first_uid]}
+    self.max_uid = Rails.configuration.msg_broker[:districts][:max_capacity] + Rails.configuration.msg_broker[:districts][:first_uid] - 1
+    self.max_capacity = Rails.configuration.msg_broker[:districts][:max_capacity]
+    self.externally_reserved_uids_size = 0
+    self.active_server_identities_size = 0
+    self.name = name
+    self.node_profile = node_profile ? node_profile : "small"
+  end
+  
+  def self.find(uuid)
+    hash = OpenShift::DataStore.instance.find_district(uuid, {:read => :primary})
+    return nil unless hash
+    hash_to_district(hash)
+  end
+  
+  def self.find_by_name(name)
+    hash = OpenShift::DataStore.instance.find_district_by_name(name, {:read => :primary})
+    return nil unless hash
+    hash_to_district(hash)
+  end
+  
+  def self.find_all()
+    data = OpenShift::DataStore.instance.find_all_districts()
+    return [] unless data
+    districts = data.map do |hash|
+      hash_to_district(hash)
+    end
+    districts
+  end
+
+  def self.find_available(node_profile=nil)
+    hash = OpenShift::DataStore.instance.find_available_district(node_profile)
+    return nil unless hash
+    hash_to_district(hash)
+  end
+  
+  def delete()
+    if server_identities.empty?
+      OpenShift::DataStore.instance.delete_district(@uuid)
+    else
+      raise OpenShift::OOException.new("Couldn't destroy district '#{uuid}' because it still contains nodes")
+    end
+  end
+  
+  def save()
+    OpenShift::DataStore.instance.save_district(@uuid, self.attributes)
+    @previously_changed = changes
+    @changed_attributes.clear
+    @new_record = false
+    @persisted = true
+    @deleted = false
+    self
+  end
+  
+  def add_node(server_identity)
+    if server_identity
+      hash = OpenShift::DataStore.instance.find_district_with_node(server_identity)
+      unless hash
+        unless server_identities.has_key?(server_identity)
+          container = OpenShift::ApplicationContainerProxy.instance(server_identity)
+          begin
+            capacity = container.get_capacity
+            if capacity == 0
+              container_node_profile = container.get_node_profile
+              if container_node_profile == node_profile 
+                container.set_district(@uuid, true)
+                server_identities[server_identity] = {"active" => true}
+                OpenShift::DataStore.instance.add_district_node(@uuid, server_identity)
+              else
+                raise OpenShift::OOException.new("Node with server identity: #{server_identity} is of node profile '#{container_node_profile}' and needs to be '#{node_profile}' to add to district '#{name}'")  
+              end
+            else
+              raise OpenShift::OOException.new("Node with server identity: #{server_identity} already has apps on it")
+            end
+          rescue OpenShift::NodeException => e
+            raise OpenShift::OOException.new("Node with server identity: #{server_identity} could not be found")
+          end
+        else
+          raise OpenShift::OOException.new("Node with server identity: #{server_identity} already belongs to district: #{@uuid}")
+        end
+      else
+        raise OpenShift::OOException.new("Node with server identity: #{server_identity} already belongs to another district: #{hash["uuid"]}")
+      end
+    else
+      raise OpenShift::UserException.new("server_identity is required")
+    end
+  end
+  
+  def remove_node(server_identity)
+    if server_identities.has_key?(server_identity)
+      unless server_identities[server_identity]["active"]
+        container = OpenShift::ApplicationContainerProxy.instance(server_identity)
+        capacity = container.get_capacity
+        if capacity == 0
+          if OpenShift::DataStore.instance.remove_district_node(@uuid, server_identity)
+            container.set_district('NONE', false)
+            server_identities.delete(server_identity)
+          else
+            raise OpenShift::OOException.new("Node with server identity: #{server_identity} could not be removed from district: #{@uuid}")
+          end
+        else
+          raise OpenShift::OOException.new("Node with server identity: #{server_identity} could not be removed from district: #{@uuid} because it still has apps on it")
+        end
+      else
+        raise OpenShift::OOException.new("Node with server identity: #{server_identity} from district: #{@uuid} must be deactivated before it can be removed")
+      end
+    else
+      raise OpenShift::OOException.new("Node with server identity: #{server_identity} doesn't belong to district: #{@uuid}")
+    end
+  end
+  
+  def deactivate_node(server_identity)
+    if server_identities.has_key?(server_identity)
+      if server_identities[server_identity]["active"]
+        OpenShift::DataStore.instance.deactivate_district_node(@uuid, server_identity)
+        container = OpenShift::ApplicationContainerProxy.instance(server_identity)
+        container.set_district(@uuid, false)
+        server_identities[server_identity] = {"active" => false}
+      else
+        raise OpenShift::OOException.new("Node with server identity: #{server_identity} is already deactivated")
+      end
+    else
+      raise OpenShift::OOException.new("Node with server identity: #{server_identity} doesn't belong to district: #{@uuid}")
+    end
+  end
+  
+  def activate_node(server_identity)
+    if server_identities.has_key?(server_identity)
+      unless server_identities[server_identity]["active"]
+        OpenShift::DataStore.instance.activate_district_node(@uuid, server_identity)
+        container = OpenShift::ApplicationContainerProxy.instance(server_identity)
+        container.set_district(@uuid, true)
+        server_identities[server_identity] = {"active" => true}
+      else
+        raise OpenShift::OOException.new("Node with server identity: #{server_identity} is already active")
+      end
+    else
+      raise OpenShift::OOException.new("Node with server identity: #{server_identity} doesn't belong to district: #{@uuid}")
+    end
+  end
+  
+  def add_capacity(num_uids)
+    if num_uids > 0
+      additions = []
+      additions.fill(0, num_uids) {|i| i+max_uid+1}
+      OpenShift::DataStore.instance.add_district_uids(uuid, additions)
+      @available_capacity += num_uids
+      @max_uid += num_uids
+      @max_capacity += num_uids
+      @available_uids += additions
+    else
+      raise OpenShift::OOException.new("You must supply a positive number of uids to remove")
+    end
+  end
+  
+  def remove_capacity(num_uids)
+    if num_uids > 0
+      subtractions = []
+      subtractions.fill(0, num_uids) {|i| i+max_uid-num_uids+1}
+      pos = 0
+      found_first_pos = false
+      available_uids.each do |available_uid|
+        if !found_first_pos && available_uid == subtractions[pos]
+          found_first_pos = true
+        elsif found_first_pos
+          unless available_uid == subtractions[pos]
+            raise OpenShift::OOException.new("Uid: #{subtractions[pos]} not found in order in available_uids.  Can not continue!")
+          end
+        end
+        pos += 1 if found_first_pos
+        break if pos == subtractions.length
+      end
+      if !found_first_pos
+        raise OpenShift::OOException.new("Missing uid: #{subtractions[0]} in existing available_uids.  Can not continue!")
+      end
+      OpenShift::DataStore.instance.remove_district_uids(uuid, subtractions)
+      @available_capacity -= num_uids
+      @max_uid -= num_uids
+      @max_capacity -= num_uids
+      @available_uids -= subtractions
+    else
+      raise OpenShift::OOException.new("You must supply a positive number of uids to remove")
+    end
+  end
+  
+  private
+  
+  def self.hash_to_district(hash)
+    district = self.new 
+    hash.each do |k,v|
+      district.instance_variable_set("@#{k}", v)
+    end
+    district.reset_state
+    district
+  end
+end

data/app/models/domain.rb

@@ -0,0 +1,234 @@
+require 'validators/namespace_validator'
+class Domain < OpenShift::UserModel
+  include ActiveModel::Validations
+  attr_accessor :uuid, :namespace, :user
+  primary_key :uuid
+  exclude_attributes :user
+  validates :namespace, :namespace => true
+  def initialize(namespace=nil, user=nil)
+    self.user = user
+    self.namespace = namespace
+    self.uuid = OpenShift::Model.gen_uuid
+  end
+  def save
+    resultIO = ResultIO.new
+    created = false
+    if not persisted?
+      resultIO.append(create())
+      created = true
+    else
+      resultIO.append(update())
+    end
+
+    begin
+      super(self.user.login)
+    rescue
+      delete_dns if created
+      raise
+    end
+    resultIO
+  end
+ 
+  def hasAccess?(user)
+    #TODO 
+    #if user.domains.include? self.uuid
+      return true
+    #end
+    #return false
+  end
+  
+  def hasFullAccess?(user)
+    #TODO
+    #if self.user.login == user.login
+      return true
+    #end
+    #return false
+  end
+  
+  def self.find(user, id)
+    domain = super(user.login, id)
+    domain.user = user if domain
+    return nil unless domain
+    domain
+  end
+  
+  def self.find_all(user, namespace=nil)
+    domains = super(user.login) 
+    unless namespace
+      user.domains = domains
+      return domains
+    else
+      filtered_domains = nil
+      domains.each do |domain|
+        if domain.namespace == namespace
+          filtered_domains.push(domain)
+        end
+      end
+      return filtered_domains
+    end    
+  end
+  
+  def self.get(user, id)
+    user.domains.each do |domain|
+      return domain if domain.namespace == id
+    end if user.domains
+    return nil
+  end
+
+  def delete_dns
+    dns_service = OpenShift::DnsService.instance
+    begin
+      dns_service.deregister_namespace(self.namespace)
+      dns_service.publish
+    ensure
+      dns_service.close
+    end
+  end
+
+  def delete
+    Rails.logger.debug "Deleting domain #{self.namespace} uuid #{self.uuid}"
+    resultIO = ResultIO.new
+    delete_dns
+    super(user.login)
+    Rails.logger.debug "notifying the domain observer of domain delete"
+    notify_observers(:after_domain_destroy) 
+    Rails.logger.debug "done notifying the domain observer"
+    resultIO
+  end
+   
+  def self.namespace_available?(namespace)
+    Rails.logger.debug "Checking to see if namesspace #{namespace} is available"
+    dns_service = OpenShift::DnsService.instance
+    return dns_service.namespace_available?(namespace)
+  end
+
+  def self.hash_to_obj(hash)
+    domain = super(hash)
+    domain
+  end
+
+  private
+
+  def update
+    result_io = ResultIO.new
+    old_domain = Domain.find(self.user, self.uuid)
+    old_namespace = old_domain.namespace
+    Rails.logger.debug "Updating namespace for domain #{self.uuid} from #{old_namespace} to #{self.namespace}"
+    dns_service = OpenShift::DnsService.instance
+
+    begin 
+      raise OpenShift::UserException.new("A namespace with name '#{self.namespace}' already exists", 103) unless dns_service.namespace_available?(self.namespace)
+      dns_service.register_namespace(self.namespace)
+      dns_service.deregister_namespace(old_namespace)
+      cloud_user = self.user
+      prepare_failures = []
+      
+      cloud_user.applications.each do |app|
+        if app.domain.uuid == self.uuid
+          Rails.logger.debug "Updating namespace to #{self.namespace} for app: #{app.name}"
+          result = app.prepare_namespace_update(dns_service, self.namespace, old_namespace)
+          prepare_failures.push(app.name) unless result[:success]
+          result_io.append result[:result_io]
+        end
+      end if cloud_user.applications
+ 
+      complete_exception = nil
+      begin
+        cloud_user.applications.each do |app|
+          if app.domain.uuid == self.uuid
+            app.complete_namespace_update(self.namespace, old_namespace)
+          end
+        end if cloud_user.applications and prepare_failures.empty?
+      rescue Exception => e
+        complete_exception = e
+        Rails.logger.debug e.message
+        Rails.logger.debug e.backtrace
+      end
+
+      dns_exception = nil
+      begin
+        dns_service.publish if prepare_failures.empty? and !complete_exception
+      rescue Exception => e
+        dns_exception = e
+        Rails.logger.debug e.message
+        Rails.logger.debug e.backtrace
+      end
+
+      # Rollback incase of failures
+      if !prepare_failures.empty? or complete_exception or dns_exception
+        undo_prepare_failures = []
+        undo_prepare_err_msg = ""
+        cloud_user.applications.each do |app|
+          if app.domain.uuid == self.uuid
+            Rails.logger.debug "Undo namespace update to #{old_namespace} for app: #{app.name}"
+            result = app.prepare_namespace_update(dns_service, old_namespace, self.namespace)
+            undo_prepare_failures.push(app.name) unless result[:success]
+            result_io.append result[:result_io]
+          end
+        end if cloud_user.applications
+        undo_prepare_err_msg = "Undo namespace update failed: #{undo_prepare_failures.pretty_inspect.chomp}." unless undo_prepare_failures.empty?
+ 
+        undo_complete_err_msg = "" 
+        begin
+          cloud_user.applications.each do |app|
+            if app.domain.uuid == self.uuid
+              app.complete_namespace_update(old_namespace, self.namespace)
+            end
+          end if cloud_user.applications
+        rescue Exception => e
+          undo_complete_err_msg = "Undo namespace update failed: #{e.message}."
+          Rails.logger.debug e.message
+          Rails.logger.debug e.backtrace
+        end
+
+        err_msg = "Error updating namespace: "
+        err_code = 143
+        if dns_exception
+          err_msg += dns_exception.message
+          err_code = dns_exception.code if dns_exception.respond_to?('code')
+        elsif complete_exception
+          err_msg += complete_exception.message
+          err_code = complete_exception.code if complete_exception.respond_to?('code')
+        else # prepare failures
+          err_msg += prepare_failures.pretty_inspect.chomp
+        end
+        err_msg += undo_prepare_err_msg + undo_complete_err_msg
+        raise OpenShift::NodeException.new(err_msg + " If the problem persists please contact support.", err_code)
+      end
+      Rails.logger.debug "Notifying domain observer of domain update"
+      notify_observers(:after_domain_update)
+    ensure
+      dns_service.close
+    end
+    result_io
+  end
+
+  def create
+    Rails.logger.debug "Creating domain #{self.uuid} with namespace #{self.namespace} for user #{self.user.login}"
+    resultIO = ResultIO.new
+    dns_service = OpenShift::DnsService.instance
+    begin
+      raise OpenShift::UserException.new("A namespace with name '#{self.namespace}' already exists", 103) unless dns_service.namespace_available?(self.namespace)
+      begin
+        Rails.logger.debug "Attempting to add namespace '#{@namespace}'"
+        dns_service.register_namespace(@namespace)
+        dns_service.publish
+        Rails.logger.debug "notifying the domain observer of domain create"
+        notify_observers(:after_domain_create)
+        Rails.logger.debug "done notifying the domain observer"
+      rescue Exception => e
+        Rails.logger.debug e
+        begin
+          Rails.logger.debug "Attempting to remove namespace '#{@namespace}' after failure to add user '#{self.user.login}'"
+          dns_service.deregister_namespace(@namespace)
+          dns_service.publish
+        ensure
+          raise
+        end
+      end
+    ensure
+      dns_service.close
+    end
+    resultIO
+  end
+end