Class: Katello::DockerMetaTag

Inherits:
Model
  • Object
show all
Includes:
ScopedSearchExtensions
Defined in:
app/models/katello/docker_meta_tag.rb

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Model

#destroy!

Class Method Details

.cleanup_tags ⇒ Object 



136
137
138
139
140
 
# File 'app/models/katello/docker_meta_tag.rb', line 136

def self.cleanup_tags
  #Cleanup RepositoryMetaTag for nil schema meta tags
  RepositoryDockerMetaTag.where(docker_meta_tag: where(schema1: nil, schema2: nil)).delete_all
  self.where.not(id: RepositoryDockerMetaTag.select(:docker_meta_tag_id)).or(where(schema1: nil, schema2: nil)).delete_all
end

.delegate_to_tags(*names) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
 
# File 'app/models/katello/docker_meta_tag.rb', line 80

def self.delegate_to_tags(*names)
  names.each do |name|
    define_method(name) do
      if schema2
        schema2.send(name)
      else
        schema1.send(name)
      end
    end
  end
end

.find_by_digest(_key, operator, value) ⇒ Object 



51
52
53
54
55
56
57
58
59
 
# File 'app/models/katello/docker_meta_tag.rb', line 51

def self.find_by_digest(_key, operator, value)
  if operator == '='
    conditions = meta_tags_by_digest_query(operator, value, DockerManifest) + " OR " + meta_tags_by_digest_query(operator, value, DockerManifestList)
  else
    #failure condition. No such value so must return 0
    conditions = "1=0"
  end
  { :conditions => conditions }
end

.find_by_schema_version(_key, operator, value) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'app/models/katello/docker_meta_tag.rb', line 61

def self.find_by_schema_version(_key, operator, value)
  conditions = ""
  if operator == '='
    if ["1", "2"].include?(value)
      column = if value == "1"
                 "schema1_id"
               else
                 "schema2_id"
               end
      docker_meta_tag_arel_table = ::Katello::DockerMetaTag.arel_table
      conditions = docker_meta_tag_arel_table[column].not_eq(nil).to_sql
    else
      #failure condition. No such value so must return 0
      conditions = "1=0"
    end
  end
  { :conditions => conditions }
end

.get_tag_table_values(repo) ⇒ Object 



175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'app/models/katello/docker_meta_tag.rb', line 175

def self.get_tag_table_values(repo)
  # queries DockerTags for a repo and retuns a [schema1, schema2 , name] tuple combination
  tags = ::Katello::DockerTag.where(:id => RepositoryDockerTag.
                                    where(:repository_id => repo.id).
                                    select(:docker_tag_id))
  dups = tags.group_by(&:name)

  dups.map do |name, values|
    if values.first.docker_manifest.schema_version == 1
      schema1, schema2 = values
    else
      schema2, schema1 = values
    end
    [schema1.try(:id), schema2.try(:id), name]
  end
end

.import_meta_tags(repositories) ⇒ Object 



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'app/models/katello/docker_meta_tag.rb', line 142

def self.import_meta_tags(repositories)
  repositories.each do |repo|
    tag_table_values = get_tag_table_values(repo)
    meta_tag_table_values = DockerMetaTag.where(:id => repository_association_class.where(:repository_id => repo.id).select(:docker_meta_tag_id)).
                              select(:schema1_id, :schema2_id, :name).map do |meta_tag|
      [meta_tag.schema1_id, meta_tag.schema2_id, meta_tag.name]
    end

    # Delete [meta_tag_table_values - tag_table_values], insert [tag_table_values - meta_tag_table_values]

    docker_meta_tag_arel_table = ::Katello::DockerMetaTag.arel_table
    params_to_query_for_delete = (meta_tag_table_values - tag_table_values).map do |schema1, schema2, name|
      conditional = docker_meta_tag_arel_table[:schema1_id].eq(schema1).and(
                    docker_meta_tag_arel_table[:schema2_id].eq(schema2)).and(
                    docker_meta_tag_arel_table[:name].eq(name)).to_sql

      "(#{conditional})"
    end

    unless params_to_query_for_delete.empty?
      RepositoryDockerMetaTag.where(:repository_id => repo.id).where(:docker_meta_tag => DockerMetaTag.where(params_to_query_for_delete.join(" OR "))).delete_all
    end

    metatags = []
    (tag_table_values - meta_tag_table_values).each do |schema1, schema2, name|
      metatags << DockerMetaTag.where(:schema1_id => schema1,
                          :schema2_id => schema2,
                          :name => name).first_or_create
    end
    repo.docker_meta_tags += metatags
  end
end

.in_repositories(repos, grouped = false) ⇒ Object 



100
101
102
103
104
105
106
 
# File 'app/models/katello/docker_meta_tag.rb', line 100

def self.in_repositories(repos, grouped = false)
  if grouped
    search_in_tags(DockerTag.in_repositories(repos), grouped)
  else
    search_in_tags(DockerTag.in_repositories(repos)).where(:id => repository_association_class.where(:repository_id => repos).select(:docker_meta_tag_id))
  end
end

.meta_tags_by_digest_query(operator, digest, manifest_klass) ⇒ Object 



44
45
46
47
48
49
 
# File 'app/models/katello/docker_meta_tag.rb', line 44

def self.meta_tags_by_digest_query(operator, digest, manifest_klass)
  search = "digest #{operator} ?"
  query = DockerMetaTag.search_in_tags(DockerTag.where(:docker_taggable_type => manifest_klass.name,
                                                       :docker_taggable_id => manifest_klass.where(search, digest))).select(:id).to_sql
  "#{DockerMetaTag.table_name}.id in (#{query})"
end

.repository_association_class ⇒ Object 



26
27
28
 
# File 'app/models/katello/docker_meta_tag.rb', line 26

def self.repository_association_class
  RepositoryDockerMetaTag
end

.search_by_repo_name(_key, operator, value) ⇒ Object 



38
39
40
41
42
 
# File 'app/models/katello/docker_meta_tag.rb', line 38

def self.search_by_repo_name(_key, operator, value)
  conditions = sanitize_sql_for_conditions(["#{Katello::RootRepository.table_name}.name #{operator} ?", value_to_sql(operator, value)])
  query = self.joins(:repositories => :root).where(conditions).select('id')
  {:conditions => "#{self.table_name}.id IN (#{query.to_sql})"}
end

.search_in_tags(tags, grouped = false) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
 
# File 'app/models/katello/docker_meta_tag.rb', line 108

def self.search_in_tags(tags, grouped = false)
  sql = tags.select("#{::Katello::DockerTag.table_name}.id").to_sql

  if grouped
    grouped_fields = "#{table_name}.name, katello_repositories.root_id"
    ids = distinct.select("ON (#{grouped_fields}) #{table_name}.id").joins(:repositories)
    self.where(:id => ids).where("#{self.table_name}.schema1_id in (#{sql}) or #{self.table_name}.schema2_id in (#{sql})")
  else
    self.where("#{self.table_name}.schema1_id in (#{sql}) or #{self.table_name}.schema2_id in (#{sql})")
  end
end

.with_identifiers(ids) ⇒ Object 



132
133
134
 
# File 'app/models/katello/docker_meta_tag.rb', line 132

def self.with_identifiers(ids)
  self.where(:id => ids)
end

.with_pulp_id(ids) ⇒ Object 



128
129
130
 
# File 'app/models/katello/docker_meta_tag.rb', line 128

def self.with_pulp_id(ids)
  self.with_identifiers(ids)
end

Instance Method Details



95
96
97
98
 
# File 'app/models/katello/docker_meta_tag.rb', line 95

def related_tags
  self.class.where(:id => ::Katello::RepositoryDockerMetaTag.where(:repository_id => repositories.first.group).
                   select(:docker_meta_tag_id), :name => name)
end

#repository ⇒ Object 



30
31
32
 
# File 'app/models/katello/docker_meta_tag.rb', line 30

def repository
  repositories.first
end

#schema1_manifest ⇒ Object 



120
121
122
 
# File 'app/models/katello/docker_meta_tag.rb', line 120

def schema1_manifest
  schema1.try(:docker_taggable)
end

#schema2_manifest ⇒ Object 



124
125
126
 
# File 'app/models/katello/docker_meta_tag.rb', line 124

def schema2_manifest
  schema2.try(:docker_taggable)
end

#upstream_name ⇒ Object 



34
35
36
 
# File 'app/models/katello/docker_meta_tag.rb', line 34

def upstream_name
  repository.docker_upstream_name
end