Class: Katello::Pulp3::PulpContentUnit

Inherits:
Object
  • Object
show all
Defined in:
app/services/katello/pulp3/pulp_content_unit.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(uuid) ⇒ PulpContentUnit

Returns a new instance of PulpContentUnit.



43
44
45
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 43

def initialize(uuid)
  self.uuid = uuid
end

Instance Attribute Details

#backend_data ⇒ Object 



119
120
121
122
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 119

def backend_data
  @backend_data ||= fetch_backend_data
  @backend_data.try(:with_indifferent_access)
end

#uuid ⇒ Object

Returns the value of attribute uuid.



40
41
42
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 40

def uuid
  @uuid
end

Class Method Details

.add_timestamps(rows) ⇒ Object 



65
66
67
68
69
70
71
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 65

def self.add_timestamps(rows)
  rows.each do |row|
    row[:created_at] = DateTime.now
    row[:updated_at] = DateTime.now
  end
  rows
end

.backend_unit_identifier ⇒ Object 



32
33
34
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 32

def self.backend_unit_identifier
  nil
end

.content_api ⇒ Object

Any class that extends this class should define: Class#update_model



10
11
12
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 10

def self.content_api
  fail NotImplementedError
end

.content_api_create(opts = {}) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 14

def self.content_api_create(opts = {})
  relative_path = opts.delete(:relative_path)
  if Katello::RepositoryTypeManager.generic_content_type?(opts[:content_type])
    repository_type = Katello::Repository.find(opts[:repository_id]).repository_type
    content_type = opts[:content_type]
    self.content_api(repository_type, content_type).create(relative_path, opts)
  elsif self.content_type == 'rpm' || self.content_type == 'srpm'
    # The pulp_rpm API bindings expect relative_path to be within the options hash.
    self.content_api.create(opts)
  else
    self.content_api.create(relative_path, opts)
  end
end

.content_type ⇒ Object 



55
56
57
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 55

def self.content_type
  self::CONTENT_TYPE
end

.content_unit_list(page_opts) ⇒ Object 



115
116
117
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 115

def self.content_unit_list(page_opts)
  self.content_api.list page_opts
end

.create_content ⇒ Object 



28
29
30
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 28

def self.create_content
  fail NotImplementedError
end

.fetch_content_list(page_opts) ⇒ Object 



128
129
130
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 128

def self.fetch_content_list(page_opts)
  content_unit_list page_opts
end

.find_duplicate_unit(repository, unit_type_id, file, checksum) ⇒ Object 



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 132

def self.find_duplicate_unit(repository, unit_type_id, file, checksum)
  filter_label = :sha256
  path_label = :relative_path
  if unit_type_id == 'ostree_ref'
    filter_label = :checksum
  end
  if unit_type_id == 'rpm'
    filter_label = :pkg_id
    path_label = :location_href
  end
  content_backend_service = SmartProxy.pulp_primary.content_service(unit_type_id)
  duplicates_allowed = ::Katello::RepositoryTypeManager.find_content_type(unit_type_id).try(:duplicates_allowed)
  if repository.generic? && duplicates_allowed
    filename_key = ::Katello::RepositoryTypeManager.find_content_type(unit_type_id).filename_key
    duplicate_sha_path_content_list = content_backend_service.content_api(repository.repository_type, unit_type_id).list(
      filter_label => checksum,
      filename_key => file[:filename])
  elsif repository.generic?
    duplicate_sha_path_content_list = content_backend_service.content_api(repository.repository_type, unit_type_id).list(
      filter_label => checksum)
  elsif unit_type_id == 'deb'
    duplicate_sha_path_content_list = content_backend_service.content_api.list(filter_label => checksum)
  else
    duplicate_sha_path_content_list = content_backend_service.content_api.list(
      filter_label => checksum,
      path_label => file[:filename])
  end
  duplicate_sha_path_content_list
end

.model_class ⇒ Object 



47
48
49
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 47

def self.model_class
  Katello::RepositoryTypeManager.model_class(self)
end

.page_options(page_opts = {}) ⇒ Object 



106
107
108
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 106

def self.page_options(page_opts = {})
  page_opts
end

.pulp_data(href) ⇒ Object 



110
111
112
113
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 110

def self.pulp_data(href)
  content_unit = self.content_api.read(href)
  content_unit.as_json
end

.pulp_units_batch_all(content_unit_hrefs) ⇒ Object 



73
74
75
76
77
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 73

def self.pulp_units_batch_all(content_unit_hrefs)
  Enumerator.new do |yielder|
    yielder.yield content_unit_hrefs.collect { |href| pulp_data(href) }
  end
end

.pulp_units_batch_for_repo(repository, options = {}) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 79

def self.pulp_units_batch_for_repo(repository, options = {})
  fetch_identifiers = options.fetch(:fetch_identifiers, false)
  page_size = options.fetch(:page_size, Setting[:bulk_load_size])
  repository_version_href = repository.version_href
  page_opts = { "offset" => 0, repository_version: repository_version_href, limit: page_size }
  page_opts[:fields] = self.const_get(:PULP_INDEXED_FIELDS).join(",") if self.constants.include?(:PULP_INDEXED_FIELDS)
  page_opts[:fields] = 'pulp_href' if fetch_identifiers
  response = {}
  Enumerator.new do |yielder|
    loop do
      page_opts = page_opts.with_indifferent_access
      break unless (
        (response["count"] && page_opts["offset"] < response["count"]) ||
        page_opts["offset"] == 0)
      page_opts = page_options page_opts
      if repository.generic?
        response = fetch_content_list page_opts, repository.repository_type, options[:content_type]
      else
        response = fetch_content_list page_opts
      end
      response = response.as_json.with_indifferent_access
      yielder.yield response[:results]
      page_opts[:offset] += page_size
    end
  end
end

.pulp_units_for_ids(content_unit_hrefs) ⇒ Object 



59
60
61
62
63
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 59

def self.pulp_units_for_ids(content_unit_hrefs)
  Enumerator.new do |yielder|
    yielder.yield content_unit_hrefs.collect { |href| pulp_data(href).with_indifferent_access }
  end
end

.supports_id_fetch? ⇒ Boolean

Returns:

  • (Boolean) 


36
37
38
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 36

def self.supports_id_fetch?
  true
end

.unit_identifier ⇒ Object 



51
52
53
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 51

def self.unit_identifier
  "pulp_href"
end

Instance Method Details

#fetch_backend_data ⇒ Object 



124
125
126
 
# File 'app/services/katello/pulp3/pulp_content_unit.rb', line 124

def fetch_backend_data
  self.class.pulp_data(self.uuid)
end