Module: Glue::Pulp::Repos::InstanceMethods

Defined in:
app/models/katello/glue/pulp/repos.rb

Instance Method Summary collapse

Instance Method Details

#add_repo(label, name, url, repo_type, unprotected = false, gpg = nil, checksum_type = nil, download_policy = nil) ⇒ Object 



244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
 
# File 'app/models/katello/glue/pulp/repos.rb', line 244

def add_repo(label, name, url, repo_type, unprotected = false, gpg = nil, checksum_type = nil, download_policy = nil)
  unprotected = unprotected.nil? ? false : unprotected

  if download_policy.blank? && repo_type == Repository::YUM_TYPE
    download_policy = Setting[:default_download_policy]
  end

  rel_path = if repo_type == 'docker'
               Glue::Pulp::Repos.custom_docker_repo_path(self.library, self, label)
             else
               Glue::Pulp::Repos.custom_repo_path(self.library, self, label)
             end
  Repository.new(:environment => self.organization.library,
                 :product => self,
                 :pulp_id => repo_id(label),
                 :relative_path => rel_path,
                 :arch => arch,
                 :name => name,
                 :label => label,
                 :url => url,
                 :gpg_key => gpg,
                 :unprotected => unprotected,
                 :content_type => repo_type,
                 :checksum_type => checksum_type,
                 :download_policy => download_policy,
                 :content_view_version => self.organization.library.default_content_view_version)
end

#custom_repos_create_orchestration ⇒ Object 



279
280
281
 
# File 'app/models/katello/glue/pulp/repos.rb', line 279

def custom_repos_create_orchestration
  pre_queue.create(:name => "create pulp repositories for product: #{self.label}",      :priority => 1, :action => [self, :set_repos])
end

#distributions(env) ⇒ Object 



118
119
120
121
122
123
124
125
 
# File 'app/models/katello/glue/pulp/repos.rb', line 118

def distributions(env)
  to_ret = []
  self.repos(env).each do |repo|
    distros = repo.distributions
    to_ret += distros unless distros.empty?
  end
  to_ret
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


66
67
68
 
# File 'app/models/katello/glue/pulp/repos.rb', line 66

def empty?
  return self.repos(library).empty?
end

#find_packages_by_name(env, name) ⇒ Object 



98
99
100
101
102
103
104
105
106
 
# File 'app/models/katello/glue/pulp/repos.rb', line 98

def find_packages_by_name(env, name)
  packages = self.repos(env).collect do |repo|
    repo.find_packages_by_name(name).collect do |p|
      p[:repo_id] = repo.id
      p
    end
  end
  packages.flatten(1)
end

#find_packages_by_nvre(env, name, version, release, epoch) ⇒ Object 



108
109
110
111
112
113
114
115
116
 
# File 'app/models/katello/glue/pulp/repos.rb', line 108

def find_packages_by_nvre(env, name, version, release, epoch)
  packages = self.repos(env).collect do |repo|
    repo.find_packages_by_nvre(name, version, release, epoch).collect do |p|
      p[:repo_id] = repo.id
      p
    end
  end
  packages.flatten(1)
end

#get_distribution(env, id) ⇒ Object 



127
128
129
130
131
132
 
# File 'app/models/katello/glue/pulp/repos.rb', line 127

def get_distribution(env, id)
  distribution = self.repos(env).map do |repo|
    repo.distributions.find_all { |d| d.id == id }
  end
  distribution.flatten(1)
end

#last_repo_sync_task ⇒ Object 



172
173
174
 
# File 'app/models/katello/glue/pulp/repos.rb', line 172

def last_repo_sync_task
  @last_sync_task ||= last_repo_sync_tasks.first
end

#last_repo_sync_task_group ⇒ Object 



185
186
187
188
189
190
191
192
 
# File 'app/models/katello/glue/pulp/repos.rb', line 185

def last_repo_sync_task_group
  if last_repo_sync_task
    started_after = last_repo_sync_task.started_at - 30.seconds
    last_repo_sync_tasks.where("#{ForemanTasks::Task::DynflowTask.table_name}.started_at > '%s'", started_after).uniq
  else
    []
  end
end

#last_repo_sync_tasks ⇒ Object 



176
177
178
179
180
181
182
183
 
# File 'app/models/katello/glue/pulp/repos.rb', line 176

def last_repo_sync_tasks
  all_repos = repos(self.library, nil, false)
  ForemanTasks::Task::DynflowTask
    .select("#{ForemanTasks::Task::DynflowTask.table_name}.*")
    .for_action(::Actions::Katello::Repository::Sync)
    .joins(:locks).where("foreman_tasks_locks.resource_id in (?) and foreman_tasks_locks.resource_type = ?", all_repos.pluck(:id), ::Katello::Repository.name)
    .order("started_at desc")
end

#last_sync ⇒ Object 



167
168
169
170
 
# File 'app/models/katello/glue/pulp/repos.rb', line 167

def last_sync
  task = last_repo_sync_task
  task.nil? ? nil : task.started_at.to_s
end

#package_group_categories(env, search_args = {}) ⇒ Object 



90
91
92
93
94
95
96
 
# File 'app/models/katello/glue/pulp/repos.rb', line 90

def package_group_categories(env, search_args = {})
  categories = []
  self.repos(env).each do |repo|
    categories << repo.package_group_categories(search_args)
  end
  categories.flatten(1)
end

#package_groups(env, search_args = {}) ⇒ Object 



82
83
84
85
86
87
88
 
# File 'app/models/katello/glue/pulp/repos.rb', line 82

def package_groups(env, search_args = {})
  groups = []
  self.repos(env).each do |repo|
    groups << repo.package_groups(search_args)
  end
  groups.flatten(1)
end

#promote(from_env, to_env) ⇒ Object 



70
71
72
73
74
75
76
77
78
79
80
 
# File 'app/models/katello/glue/pulp/repos.rb', line 70

def promote(from_env, to_env)
  @orchestration_for = :promote

  async_tasks = promote_repos repos(from_env), from_env, to_env
  unless to_env.products.include? self
    self.environments << to_env
  end

  save!
  async_tasks
end

Returns:

  • (Boolean) 


134
135
136
 
# File 'app/models/katello/glue/pulp/repos.rb', line 134

def promoted_to?(target_env)
  target_env.products.include? self
end

#repo_id(content_name, env_label = nil, docker_repo_name = nil) ⇒ Object 



224
225
226
227
228
229
 
# File 'app/models/katello/glue/pulp/repos.rb', line 224

def repo_id(content_name, env_label = nil, docker_repo_name = nil)
  return if content_name.nil?
  return content_name if content_name.include?(self.organization.label) && content_name.include?(self.label.to_s)
  Repository.repo_id(self.label.to_s, content_name.to_s, env_label,
                     self.organization.label, nil, nil, docker_repo_name)
end

#repo_url(content_url) ⇒ Object 



231
232
233
234
235
236
237
 
# File 'app/models/katello/glue/pulp/repos.rb', line 231

def repo_url(content_url)
  if self.provider.provider_type == Provider::CUSTOM
    content_url.dup
  else
    self.provider.repository_url + content_url
  end
end

#setup_sync_schedule ⇒ Object 



272
273
274
275
276
277
 
# File 'app/models/katello/glue/pulp/repos.rb', line 272

def setup_sync_schedule
  schedule = (self.sync_plan && self.sync_plan.schedule_format) || nil
  self.repos(self.library).each do |repo|
    repo.sync_schedule(schedule)
  end
end

#sync ⇒ Object 



138
139
140
141
142
143
144
 
# File 'app/models/katello/glue/pulp/repos.rb', line 138

def sync
  Rails.logger.debug "Syncing product #{self.label}"
  repos = self.repos(library).collect do |r|
    r.sync
  end
  repos.flatten
end

#sync_finish ⇒ Object 



208
209
210
211
212
213
214
215
216
 
# File 'app/models/katello/glue/pulp/repos.rb', line 208

def sync_finish
  finish_times = []
  repos(library).each do |r|
    finish = r.sync_finish
    finish_times << finish unless finish.nil?
  end
  finish_times.sort!
  finish_times.last
end

#sync_size ⇒ Object 



218
219
220
221
222
 
# File 'app/models/katello/glue/pulp/repos.rb', line 218

def sync_size
  self.repos(library).inject(0) do |sum, v|
    sum + v.sync_status.progress.total_size
  end
end

#sync_start ⇒ Object 



198
199
200
201
202
203
204
205
206
 
# File 'app/models/katello/glue/pulp/repos.rb', line 198

def sync_start
  start_times = []
  repos(library).each do |r|
    start = r.sync_start
    start_times << start unless start.nil?
  end
  start_times.sort!
  start_times.last
end

#sync_state ⇒ Object 



194
195
196
 
# File 'app/models/katello/glue/pulp/repos.rb', line 194

def sync_state
  self.sync_status[:state]
end

#sync_status ⇒ Object

Get the most relevant status for all the repos in this Product



151
152
153
154
155
156
 
# File 'app/models/katello/glue/pulp/repos.rb', line 151

def sync_status
  all_repos = repos(self.library, nil, false)
  task = last_repo_sync_task
  last_synced_repo = task ? all_repos.find { |repo| task.locks.where(:resource_type => ::Katello::Repository.name).pluck(:resource_id).map(&:to_s).include?(repo.id.to_s) } : nil
  ::Katello::SyncStatusPresenter.new(last_synced_repo, task).sync_progress
end

#sync_summary ⇒ Object 



158
159
160
161
162
163
164
165
 
# File 'app/models/katello/glue/pulp/repos.rb', line 158

def sync_summary
  summary = {}
  last_repo_sync_task_group.each do |task|
    summary[task.result] ||= 0
    summary[task.result] += 1
  end
  summary
end

#synced? ⇒ Boolean

Returns:

  • (Boolean) 


146
147
148
 
# File 'app/models/katello/glue/pulp/repos.rb', line 146

def synced?
  !last_repo_sync_task.nil?
end

#update_repositories ⇒ Object 



239
240
241
242
 
# File 'app/models/katello/glue/pulp/repos.rb', line 239

def update_repositories
  repos = Repository.in_product(self).in_default_view
  repos.each(&:refresh_pulp_repo)
end