# Offense count: 37

# Cop supports --auto-correct.

Style/MultilineIfModifier:

Enabled: false

@operatingsystem.provisioning_templates.map(&:template_kind_id).uniq.each do |kind|

if @operatingsystem.os_default_templates.where(:template_kind_id => kind).blank?

@operatingsystem.os_default_templates.build(:template_kind_id => kind)

end if SETTINGS[:unattended]

style = case audit.action

when 'create'

'label-success'

when 'update'

'label-info'

when 'destroy'

'label-danger'

else

''

end if main_object? audit

options.merge!(

:address => console[:address],

:secure_port => console[:secure_port],

:subject => console[:subject],

:title => _("%s - Press Shift-F12 to release the cursor.") % console[:name]

) if supports_spice_xpi?

render "home/vertical_menu", :menu_items => items, :menu_title => _(menu.caption), :menu_icon => menu.icon,

:menu_name => menu.name, :mobile_class => mobile ? 'visible-xs-block' : '' if items.any?

link_to_function(icon_text('random'), 'randomizeName()', :class => 'btn btn-default',

:title => _('Generate new random name. Visit Settings to disable this feature.')) if NameGenerator.random_based?

if params["puppetclass_id"]

select_f f, :puppetclass_id, [Puppetclass.find(params["puppetclass_id"])], :id, :to_label, {}, {:label => _("Puppet class"), :disabled => true}

elsif f.object.puppet? && f.object.param_class

text_f(f, :puppetclass_id, :label => _('Puppet Class'), :value => f.object.param_class, :disabled => true)

else # new smart-var with no particular context

# Give a select for choosing the parent puppetclass

puppetclasses = accessible_resource(f.object, :puppetclass)

select_f(f, :puppetclass_id, puppetclasses, :id, :to_label, { :include_blank => true }, {:label => _("Puppet class")})

end unless @puppetclass # nested smart-vars form in a tab of puppetclass/_form: no edition allowed, and the puppetclass is already visible as a context

return readonly_field(setting, :value,

{:title => _("This setting is defined in the configuration file '%{filename}' and is read-only.") % {:filename => setting.class.config_file}, :helper => :show_value}) if setting.readonly?

return edit_select(setting, :value,

{:title => setting.full_name_with_default, :select_values => self.send("#{setting.name}_collection") }) if self.respond_to? "#{setting.name}_collection"

{

:location => { :onchange => 'tfm.users.taxonomyAdded(this, "location")'},

:organization => { :onchange => 'tfm.users.taxonomyAdded(this, "organization")'}

} unless user.admin?

h.merge!(:openstack_domain_name => domain,

:openstack_project_name => tenant) if tenant

raise Foreman::AssociationNotFound

.new(_("Could not find %{association} with name: %{name}") % { name: name_value, association: association }) unless assoc_id

queue.create(:name => _("Render user data template for %s") % self, :priority => 1,

:action => [self, :setUserData]) if find_image.try(:user_data)

queue.create(:name => _("Acquire IP addresses for %s") % self, :priority => 3,

:action => [self, :setComputeIP]) if compute_provides?(:ip) || compute_provides?(:ip6)

queue.create(:name => _("Set IP addresses for %s") % self, :priority => 5,

:action => [self, :setComputeIPAM]) if compute_provides?(:mac) && (mac_based_ipam?(:subnet) || mac_based_ipam?(:subnet6))

queue.create(:name => _("Power up compute instance %s") % self, :priority => 1000,

:action => [self, :setComputePowerUp]) if compute_attributes && compute_attributes[:start] == '1'

queue.create(:name => _("Create %{type} for %{host}") % {:host => self, :type => dns_class(record_type).human}, :priority => 10,

:action => [self, :set_dns_record, record_type]) if dns_feasible?(record_type)

queue.create(:name => _("Remove %{type} for %{host}") % {:host => old, :type => dns_class(record_type).human }, :priority => 9,

:action => [old, :del_dns_record, record_type]) if old.dns_feasible?(record_type)

queue.create(:name => _("Remove %{type} for %{host}") % {:host => self, :type => dns_class(record_type).human}, :priority => 1,

:action => [self, :del_dns_record, record_type]) if dns_feasible?(record_type)

queue.create(:name => _("Remove conflicting %{type} for %{host}") % {:host => self, :type => dns_class(record_type).human}, :priority => 0,

:action => [self, :del_conflicting_dns_record, record_type]) if dns_feasible?(record_type) && dns_record(record_type) && dns_record(record_type).conflicting?

errors.add(

:permissions,

_('must be of same resource type (%s) - Role (%s)') %

[

types.join(','),

self.role.name

]

) if types.size > 1

raise Foreman::Exception.new(

_("No BMC NIC available for host %s") % self) unless bmc_available?

%w{ptable medium architecture}.each do |e|

value = self.send(e.to_sym)

next if value.blank?

unless os.send(e.pluralize.to_sym).include?(value)

errors.add("#{e}_id".to_sym, _("%{value} does not belong to %{os} operating system") % { :value => value, :os => os })

status = false

end if SETTINGS[:unattended] && managed? && os && pxe_build?

puppetclasses.select("puppetclasses.id,puppetclasses.name").distinct.each do |e|

unless environment.puppetclasses.map(&:id).include?(e.id)

errors.add(:puppetclasses, _("%{e} does not belong to the %{environment} environment") % { :e => e, :environment => environment })

status = false

end if environment

ancestors.reverse_each do |hg|

if (v = LookupValue.find_by(:lookup_key_id => key.id, :id => hg.lookup_values))

return v.value, hg.to_label

end if key.path_elements.flatten.include?("hostgroup") && Setting["host_group_matchers_inheritance"]

Hostgroup.sort_by_ancestry(ancestors).reverse_each do |a|

return a.root_pass if a.root_pass.present?

end if ancestry.present?

case key_type.to_sym

when :json, :array

val = JSON.dump(val)

when :yaml, :hash

val = YAML.dump val

val.sub!(/\A---\s*$\n/, '')

end if key_type.present?

hostgroup_matches.each do |hostgroup_match|

match[match.index { |m| m =~ /hostgroup\s*=/ }] = hostgroup_match

matches << match.join(LookupKey::KEY_DELM)

end if add_hostgroup_matches?(rule)

begin

return "json" if JSON.load value

rescue

return "yaml" if YAML.load value

end if detect_json_or_yaml

config.after_initialize do

Bullet.enable = true

Bullet.bullet_logger = true

Bullet.console = true

Bullet.rails_logger = true

Bullet.add_footer = true

Bullet.counter_cache_enable = false

Bullet.add_whitelist :type => :n_plus_one_query, :class_name => "Puppetclass", :association => :environments

Bullet.add_whitelist :type => :n_plus_one_query, :class_name => "Puppetclass", :association => :class_params

end if defined?(Bullet)

Find.find(path) do |e|

t = File.mtime(e)

max = t if t > max

end if File.exist?(path)

ActiveRecord::Base.transaction do

FactValue.update_all(

["fact_name_id=?", fact_name_id],

["fact_name_id in (?)", duplicates]

)

UserFact.update_all(

["fact_name_id=?", fact_name_id],

["fact_name_id in (?)", duplicates]

)

FactName.where(["id in (?)", duplicates]).delete_all

end if duplicates.any?

raise ::Foreman::Exception.new(N_("Unable to create mail notification: %s"),

format_errors(created_notification)) if created_notification.nil? || created_notification.errors.any?

ActiveSupport::Notifications.subscribe(/process_action.action_controller/) do |*args|

event = ActiveSupport::Notifications::Event.new(*args)

controller = event.payload[:controller].underscore

action = event.payload[:action].underscore

status = event.payload[:status]

increment_counter(:http_requests, 1, :controller => controller, :action => action, :status => status)

observe_histogram(:http_request_total_duration, event.duration || 0, :controller => controller, :action => action)

observe_histogram(:http_request_db_duration, event.payload[:db_runtime] || 0, :controller => controller, :action => action)

observe_histogram(:http_request_view_duration, event.payload[:view_runtime] || 0, :controller => controller, :action => action)

# measure GC stats for each request

before = Thread.current[:foreman_telemetry_gcstats]

after = GC.stat

GC_METRICS.each do |ruby_key, metric_name|

if after.include?(ruby_key)

count = after[ruby_key] - before[ruby_key]

increment_counter(metric_name, count, :controller => controller, :action => action) if count > 0

end if before

end if enabled?

ActiveSupport::Notifications.subscribe(/instantiation.active_record/) do |*args|

event = ActiveSupport::Notifications::Event.new(*args)

class_name = event.payload[:class_name]

record_count = event.payload[:record_count]

increment_counter(:activerecord_instances, record_count, :class => class_name) if record_count > 0

end if enabled?

puts "Run this task with a file argument with the location of your db dump,

'rake db:import_dump file=DBDUMPLOCATION" and return unless ENV['file']

assert model.errors[field].find { |e| e.match(match) }.present?,

"#{field} error matching #{match} not found: #{model.errors[field].inspect}" if match

expected_hash = {@host.name=>{"kernelversion"=>"2.6.9"}}

expected_hash = {@host.name =>{"kernelversion"=>"2.6.9"}, "kernelversion"=>"2.6.9"}

expected_hash = {@host.name =>{"kernelversion"=>"2.6.9"}, "kernelversion"=>"2.6.9"}

expected_hash = {@host.name=>{"kernelversion"=>"2.6.9"}}