Module: Glue::Pulp::Consumer::InstanceMethods

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

Instance Method Summary collapse

Instance Method Details

#bind_repo_ids(repo_ids, distributor_type, bind_options) ⇒ Object 



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

def bind_repo_ids(repo_ids, distributor_type, bind_options)
  error_ids     = []

  repo_ids.each do |repo_id|
    begin
      Katello.pulp_server.extensions.consumer.bind_all(uuid, repo_id, distributor_type, bind_options)
    rescue => e
      Rails.logger.error "Failed to bind repo #{repo_id}: #{e}, #{e.backtrace.join("\n")}"
      error_ids << repo_id
    end
  end
  error_ids
end

#bindings(type_id) ⇒ Object 



22
23
24
25
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 22

def bindings(type_id)
  bindings = Katello.pulp_server.extensions.consumer.retrieve_bindings(uuid)
  bindings.select { |b| b['type_id'] == type_id }.collect { |repo| repo["repo_id"] }
end

#bound_node_repos ⇒ Object 



18
19
20
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 18

def bound_node_repos
  bindings(Runcible::Models::NodesHttpDistributor.type_id)
end

#del_pulp_consumer ⇒ Object 



88
89
90
91
92
93
94
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 88

def del_pulp_consumer
  Rails.logger.debug "Deleting consumer in pulp: #{self.name}"
  Katello.pulp_server.extensions.consumer.delete(self.uuid)
rescue => e
  Rails.logger.error "Failed to delete pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
  raise e
end

#enable_node_repos(repo_ids) ⇒ Object 



27
28
29
30
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 27

def enable_node_repos(repo_ids)
  enable_repos(Runcible::Models::NodesHttpDistributor.type_id, bound_node_repos, repo_ids,
               :notify_agent => false, :binding_config => {:strategy => 'mirror'})
end

#enable_repos(distributor_type, existing_ids, update_ids, bind_options = {}) ⇒ Object

Binds and unbinds distributors of a certain type across repos



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 37

def enable_repos(distributor_type, existing_ids, update_ids, bind_options = {})
  # calculate repoids to bind/unbind
  bound_ids     = existing_ids
  intersection  = update_ids & bound_ids
  bind_ids      = update_ids - intersection
  unbind_ids    = bound_ids - intersection

  Rails.logger.debug "Bound repo ids: #{bound_ids.inspect}"
  Rails.logger.debug "Update repo ids: #{update_ids.inspect}"
  Rails.logger.debug "Repo ids to bind: #{bind_ids.inspect}"
  Rails.logger.debug "Repo ids to unbind: #{unbind_ids.inspect}"

  error_ids = unbind_repo_ids(unbind_ids, distributor_type)
  error_ids += bind_repo_ids(bind_ids, distributor_type, bind_options)
  error_ids
end

#install_consumer_errata(errata_ids) ⇒ Object 



148
149
150
151
152
153
154
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 148

def install_consumer_errata(errata_ids)
  Rails.logger.debug "Scheduling errata install for consumer #{self.name}"
  Katello.pulp_server.extensions.consumer.install_content(self.uuid, 'erratum', errata_ids, "importkeys" => true)
rescue => e
  Rails.logger.error "Failed to schedule errata install for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
  raise e
end

#install_package(packages) ⇒ Object 



106
107
108
109
110
111
112
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 106

def install_package(packages)
  Rails.logger.debug "Scheduling package install for consumer #{self.name}"
  Katello.pulp_server.extensions.consumer.install_content(self.uuid, 'rpm', packages, "importkeys" => true)
rescue => e
  Rails.logger.error "Failed to schedule package install for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
  raise e
end

#install_package_group(groups) ⇒ Object 



132
133
134
135
136
137
138
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 132

def install_package_group(groups)
  Rails.logger.debug "Scheduling package group install for consumer #{self.name}"
  Katello.pulp_server.extensions.consumer.install_content(self.uuid, 'package_group', groups, "importkeys" => true)
rescue => e
  Rails.logger.error "Failed to schedule package group install for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
  raise e
end

#katello_agent_installed? ⇒ Boolean

Returns:

  • (Boolean) 


156
157
158
159
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 156

def katello_agent_installed?
  return false if self.is_a? Hypervisor
  simple_packages.any? { |package| package.name == "katello-agent" }
end

#pulp_bound_yum_repositories ⇒ Object 



32
33
34
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 32

def pulp_bound_yum_repositories
  bindings(Runcible::Models::YumDistributor.type_id)
end

#pulp_errata_uuids ⇒ Object 



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

def pulp_errata_uuids
  response = Katello.pulp_server.extensions.consumer.applicable_errata([self.uuid])
  return [] if response.empty?
  response[0]['applicability']['erratum'] || []
end

#unbind_repo_ids(repo_ids, distributor_type) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 54

def unbind_repo_ids(repo_ids, distributor_type)
  error_ids     = []

  repo_ids.each do |repo_id|
    begin
      Katello.pulp_server.extensions.consumer.unbind_all(uuid,  repo_id, distributor_type)
    rescue => e
      Rails.logger.error "Failed to unbind repo #{repo_id}: #{e}, #{e.backtrace.join("\n")}"
      error_ids << repo_id
    end
  end
  error_ids
end

#uninstall_package(packages) ⇒ Object 



114
115
116
117
118
119
120
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 114

def uninstall_package(packages)
  Rails.logger.debug "Scheduling package uninstall for consumer #{self.name}"
  Katello.pulp_server.extensions.consumer.uninstall_content(self.uuid, 'rpm', packages)
rescue => e
  Rails.logger.error "Failed to schedule package uninstall for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
  raise e
end

#uninstall_package_group(groups) ⇒ Object 



140
141
142
143
144
145
146
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 140

def uninstall_package_group(groups)
  Rails.logger.debug "Scheduling package group uninstall for consumer #{self.name}"
  Katello.pulp_server.extensions.consumer.uninstall_content(self.uuid, 'package_group', groups)
rescue => e
  Rails.logger.error "Failed to schedule package group uninstall for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
  raise e
end

#update_package(packages) ⇒ Object 



122
123
124
125
126
127
128
129
130
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 122

def update_package(packages)
  Rails.logger.debug "Scheduling package update for consumer #{self.name}"
  options = {"importkeys" => true}
  options[:all] = true if packages.blank?
  Katello.pulp_server.extensions.consumer.update_content(self.uuid, 'rpm', packages, options)
rescue => e
  Rails.logger.error "Failed to schedule package update for pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
  raise e
end

#update_pulp_consumer ⇒ Object 



96
97
98
99
100
101
102
103
104
 
# File 'app/models/katello/glue/pulp/consumer.rb', line 96

def update_pulp_consumer
  return true if @changed_attributes.empty?

  Rails.logger.debug "Updating consumer in pulp: #{self.name}"
  Katello.pulp_server.extensions.consumer.update(self.uuid, :display_name => self.name)
rescue => e
  Rails.logger.error "Failed to update pulp consumer #{self.name}: #{e}, #{e.backtrace.join("\n")}"
  raise e
end