routable.rb 4.5 KB
Newer Older
1
# Store object full path in separate table for easy lookup and uniq validation
2
# Object must have name and path db fields and respond to parent and parent_changed? methods.
3 4 5 6
module Routable
  extend ActiveSupport::Concern

  included do
7 8
    has_one :route, as: :source, autosave: true, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
    has_many :redirect_routes, as: :source, autosave: true, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
9 10

    validates_associated :route
11
    validates :route, presence: true
12

13 14 15 16 17 18 19
    scope :with_route, -> { includes(:route) }

    before_validation do
      if full_path_changed? || full_name_changed?
        prepare_route
      end
    end
20 21 22 23 24 25 26 27 28 29
  end

  class_methods do
    # Finds a single object by full path match in routes table.
    #
    # Usage:
    #
    #     Klass.find_by_full_path('gitlab-org/gitlab-ce')
    #
    # Returns a single object, or nil.
30
    def find_by_full_path(path, follow_redirects: false)
31 32 33 34
      # On MySQL we want to ensure the ORDER BY uses a case-sensitive match so
      # any literal matches come first, for this we have to use "BINARY".
      # Without this there's still no guarantee in what order MySQL will return
      # rows.
35 36 37 38 39 40 41 42
      #
      # Why do we do this?
      #
      # Even though we have Rails validation on Route for unique paths
      # (case-insensitive), there are old projects in our DB (and possibly
      # clients' DBs) that have the same path with different cases.
      # See https://gitlab.com/gitlab-org/gitlab-ce/issues/18603. Also note that
      # our unique index is case-sensitive in Postgres.
43 44
      binary = Gitlab::Database.mysql? ? 'BINARY' : ''
      order_sql = "(CASE WHEN #{binary} routes.path = #{connection.quote(path)} THEN 0 ELSE 1 END)"
45 46
      found = where_full_path_in([path]).reorder(order_sql).take
      return found if found
47

48 49 50 51
      if follow_redirects
        if Gitlab::Database.postgresql?
          joins(:redirect_routes).find_by("LOWER(redirect_routes.path) = LOWER(?)", path)
        else
52
          joins(:redirect_routes).find_by(redirect_routes: { path: path })
53 54
        end
      end
55 56 57 58 59 60
    end

    # Builds a relation to find multiple objects by their full paths.
    #
    # Usage:
    #
61
    #     Klass.where_full_path_in(%w{gitlab-org/gitlab-ce gitlab-org/gitlab-ee})
62 63
    #
    # Returns an ActiveRecord::Relation.
64
    def where_full_path_in(paths)
65 66 67 68 69 70
      wheres = []
      cast_lower = Gitlab::Database.postgresql?

      paths.each do |path|
        path = connection.quote(path)

71 72 73 74 75 76
        where =
          if cast_lower
            "(LOWER(routes.path) = LOWER(#{path}))"
          else
            "(routes.path = #{path})"
          end
77 78 79 80 81 82 83 84 85 86 87 88

        wheres << where
      end

      if wheres.empty?
        none
      else
        joins(:route).where(wheres.join(' OR '))
      end
    end
  end

89 90 91 92 93 94 95 96 97 98
  def full_name
    if route && route.name.present?
      @full_name ||= route.name
    else
      update_route if persisted?

      build_full_name
    end
  end

99 100 101 102
  # Every time `project.namespace.becomes(Namespace)` is called for polymorphic_path,
  # a new instance is instantiated, and we end up duplicating the same query to retrieve
  # the route. Caching this per request ensures that even if we have multiple instances,
  # we will not have to duplicate work, avoiding N+1 queries in some cases.
103
  def full_path
104 105
    return uncached_full_path unless RequestStore.active?

106 107 108
    RequestStore[full_path_key] ||= uncached_full_path
  end

109 110 111 112
  def full_path_components
    full_path.split('/')
  end

113 114
  def expires_full_path_cache
    RequestStore.delete(full_path_key) if RequestStore.active?
115
    @full_path = nil
116 117
  end

118 119 120 121 122 123 124 125
  def build_full_path
    if parent && path
      parent.full_path + '/' + path
    else
      path
    end
  end

126 127 128
  private

  def uncached_full_path
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
    if route && route.path.present?
      @full_path ||= route.path
    else
      update_route if persisted?

      build_full_path
    end
  end

  def full_name_changed?
    name_changed? || parent_changed?
  end

  def full_path_changed?
    path_changed? || parent_changed?
  end

146 147 148 149
  def full_path_key
    @full_path_key ||= "routable/full_path/#{self.class.name}/#{self.id}"
  end

150 151 152 153 154 155 156 157 158
  def build_full_name
    if parent && name
      parent.human_name + ' / ' + name
    else
      name
    end
  end

  def update_route
159 160
    return if Gitlab::Database.read_only?

161 162 163 164 165
    prepare_route
    route.save
  end

  def prepare_route
166
    route || build_route(source: self)
167 168 169 170
    route.path = build_full_path
    route.name = build_full_name
    @full_path = nil
    @full_name = nil
171 172
  end
end