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

#del_owner_import ⇒ Object 



98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'app/models/katello/glue/provider.rb', line 98

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 



116
117
118
 
# File 'app/models/katello/glue/provider.rb', line 116

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

#import_product(product_json) ⇒ Object 



142
143
144
145
146
147
148
149
150
 
# File 'app/models/katello/glue/provider.rb', line 142

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 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'app/models/katello/glue/provider.rb', line 120

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 



152
153
154
155
 
# File 'app/models/katello/glue/provider.rb', line 152

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

#last_sync ⇒ Object 



48
49
50
51
52
53
54
55
56
57
 
# File 'app/models/katello/glue/provider.rb', line 48

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 



112
113
114
 
# File 'app/models/katello/glue/provider.rb', line 112

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

#owner_upstream_update(upstream, _options) ⇒ Object 



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

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

  # Default to Red Hat
  url = upstream['apiUrl'] || API_URL

  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("#{url}#{upstream['uuid']}", upstream['idCert']['cert'],
                                                upstream['idCert']['key'], ca_file, params)
end

#retrieve_owner_upstream_export(upstream, zip_file_path, export_id) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
 
# File 'app/models/katello/glue/provider.rb', line 86

def retrieve_owner_upstream_export(upstream, zip_file_path, export_id)
  validate_upstream_identity_cert!(upstream)
  url = upstream['apiUrl'] || API_URL

  data = Resources::Candlepin::UpstreamConsumer.get_export("#{url}#{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 



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

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

#rules_version ⇒ Object 



161
162
163
 
# File 'app/models/katello/glue/provider.rb', line 161

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

#start_owner_upstream_export(upstream) ⇒ Object 



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

def start_owner_upstream_export(upstream)
  validate_upstream_identity_cert!(upstream)
  url = upstream['apiUrl'] || API_URL

  response = Resources::Candlepin::UpstreamConsumer.get_export("#{url}#{upstream['uuid']}/export/async", upstream['idCert']['cert'],
    upstream['idCert']['key'], ca_file)
  JSON.parse(response)
end

#sync ⇒ Object 



36
37
38
39
40
41
42
 
# File 'app/models/katello/glue/provider.rb', line 36

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

#synced? ⇒ Boolean

Returns:

  • (Boolean) 


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

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