Module: Katello::Glue::Provider::InstanceMethods

Defined in:
app/models/katello/glue/provider.rb

Constant Summary collapse

API_URL = 
'https://subscription.rhsm.redhat.com/subscription/consumers/'.freeze

Instance Method Summary collapse

Instance Method Details

#api_url(upstream = {}) ⇒ Object 



35
36
37
38
 
# File 'app/models/katello/glue/provider.rb', line 35

def api_url(upstream = {})
  # Default to Red Hat
  ENV['REDHAT_RHSM_API_URL'] || upstream['apiUrl'] || API_URL
end

#del_owner_import ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'app/models/katello/glue/provider.rb', line 104

def del_owner_import
  # This method will delete a manifest that has been imported.  Since it is not possible
  # to delete the changes associated with a specific manifest, we only support deleting
  # the import, if there has only been 1 manifest import completed.  It should be noted
  # that this will destroy all subscriptions associated with the import.
  imports = self.owner_imports
  if imports.length == 1
    Rails.logger.debug "Deleting import for provider: #{name}"
    Resources::Candlepin::Owner.destroy_imports self.organization.label
  else
    Rails.logger.debug "Unable to delete import for provider: #{name}. Reason: a successful import was previously completed."
  end
end

#import_logger ⇒ Object 



122
123
124
 
# File 'app/models/katello/glue/provider.rb', line 122

def import_logger
  ::Foreman::Logging.logger('katello/manifest_import_logger')
end

#import_product(product_json) ⇒ Object 



148
149
150
151
152
153
154
155
156
 
# File 'app/models/katello/glue/provider.rb', line 148

def import_product(product_json)
  product = organization.products.find_by(:cp_id => product_json['id'])
  if product&.redhat?
    product.update!(:name => product_json['name']) unless product.name == product_json['name']
  elsif product.nil?
    product = Glue::Candlepin::Product.import_redhat_product_from_cp(product_json, organization)
  end
  product
end

#import_products_from_cp ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'app/models/katello/glue/provider.rb', line 126

def import_products_from_cp
  cp_products = ::Katello::Resources::Candlepin::Product.all(organization.label, [:id, :name, :multiplier, :productContent])
  cp_products = cp_products.select { |prod| Glue::Candlepin::Product.engineering_product_id?(prod['id']) }

  prod_content_importer = Katello::ProductContentImporter.new(cp_products)

  Katello::Logging.time("Imported #{cp_products.size} products") do
    cp_products.each do |product_json|
      next if ::Katello::Glue::Provider.orphaned_custom_product?(product_json['id'], organization)
      product = import_product(product_json)
      prod_content_importer.add_product_content(product, product_json['productContent']) if product.redhat?
    end
  end

  Katello::Logging.time("Imported product content") do
    prod_content_importer.import
  end

  self.index_subscriptions
  prod_content_importer
end

#index_subscriptions ⇒ Object 



158
159
160
161
 
# File 'app/models/katello/glue/provider.rb', line 158

def index_subscriptions
  Katello::Subscription.import_all(organization)
  Katello::Pool.import_all(organization, false)
end

#last_sync ⇒ Object 



52
53
54
55
56
57
58
59
60
61
 
# File 'app/models/katello/glue/provider.rb', line 52

def last_sync
  sync_times = []
  self.products.each do |prod|
    break unless prod.respond_to?(:last_sync)
    sync = prod.last_sync
    sync_times << sync unless sync.nil?
  end
  sync_times.sort!
  sync_times.last
end

#owner_imports ⇒ Object 



118
119
120
 
# File 'app/models/katello/glue/provider.rb', line 118

def owner_imports
  Resources::Candlepin::Owner.imports self.organization.label
end

#owner_upstream_regenerate_identity_cert(upstream) ⇒ Object 



77
78
79
80
81
82
83
 
# File 'app/models/katello/glue/provider.rb', line 77

def owner_upstream_regenerate_identity_cert(upstream)
  validate_upstream_identity_cert!(upstream)
  Rails.logger.debug "Sending request to regenerate identity certificate for upstream consumer: #{upstream['uuid']}"
  response = Resources::Candlepin::UpstreamConsumer.regenerate_upstream_identity("#{api_url(upstream)}#{upstream['uuid']}", upstream['idCert']['cert'],
    upstream['idCert']['key'], ca_file)
  JSON.parse(response)
end

#owner_upstream_update(upstream, _options) ⇒ Object 



63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'app/models/katello/glue/provider.rb', line 63

def owner_upstream_update(upstream, _options)
  if !upstream['idCert'] || !upstream['idCert']['cert'] || !upstream['idCert']['key']
    Rails.logger.error "Upstream identity certificate not available"
    fail _("Upstream identity certificate not available")
  end
  params = {}
  params[:capabilities] = Resources::Candlepin::CandlepinPing.ping['managerCapabilities'].inject([]) do |result, element|
    result << {'name' => element}
  end
  params[:facts] = {:distributor_version => DISTRIBUTOR_VERSION }
  Resources::Candlepin::UpstreamConsumer.update("#{api_url(upstream)}#{upstream['uuid']}", upstream['idCert']['cert'],
                                                upstream['idCert']['key'], ca_file, params)
end

#retrieve_owner_upstream_export(upstream, zip_file_path, export_id) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
 
# File 'app/models/katello/glue/provider.rb', line 92

def retrieve_owner_upstream_export(upstream, zip_file_path, export_id)
  validate_upstream_identity_cert!(upstream)
  data = Resources::Candlepin::UpstreamConsumer.retrieve_upstream_export(
    "#{api_url(upstream)}#{upstream['uuid']}/export/#{export_id}",
    upstream['idCert']['cert'],
    upstream['idCert']['key'], ca_file
  )
  File.write(zip_file_path, data, mode: 'wb')

  true
end

#rules_source ⇒ Object 



163
164
165
 
# File 'app/models/katello/glue/provider.rb', line 163

def rules_source
  redhat_provider? ? candlepin_ping['rulesSource'] : ''
end

#rules_version ⇒ Object 



167
168
169
 
# File 'app/models/katello/glue/provider.rb', line 167

def rules_version
  redhat_provider? ? candlepin_ping['rulesVersion'] : ''
end

#start_owner_upstream_export(upstream) ⇒ Object 



85
86
87
88
89
90
 
# File 'app/models/katello/glue/provider.rb', line 85

def start_owner_upstream_export(upstream)
  validate_upstream_identity_cert!(upstream)
  response = Resources::Candlepin::UpstreamConsumer.start_upstream_export("#{api_url(upstream)}#{upstream['uuid']}/export/async", upstream['idCert']['cert'],
    upstream['idCert']['key'], ca_file)
  JSON.parse(response)
end

#sync ⇒ Object 



40
41
42
43
44
45
46
 
# File 'app/models/katello/glue/provider.rb', line 40

def sync
  Rails.logger.debug "Syncing provider #{name}"
  syncs = self.products.collect do |p|
    p.sync
  end
  syncs.flatten
end

#synced? ⇒ Boolean

Returns:

  • (Boolean) 


48
49
50
 
# File 'app/models/katello/glue/provider.rb', line 48

def synced?
  self.products.any? { |p| p.synced? }
end