Layout/MultilineOperationIndentation:

Enabled: false

# Offense count: 95

# Cop supports --auto-correct.

# Configuration parameters: EnforcedStyle.

# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.

# URISchemes: http, https

Metrics/LineLength:

# Offense count: 522

# Configuration parameters: CountComments.

end

def add_version_header

end

# this method is used with nested resources, where obj_id is passed into the parameters hash.

api :GET, "/hostgroups/:hostgroup_id/puppetclass_ids/", N_("List all Puppet class IDs for host group")

def index

end

api :POST, "/hostgroups/:hostgroup_id/puppetclass_ids", N_("Add a Puppet class to host group")

def find_parameter

# nested_obj is required, so no need to check here

@parameter = @parameters.from_param(params[:id])

@parameter ||= @parameters.friendly.find(params[:id])

return @parameter if @parameter.present?

end

def errors_hash(errors)

end

def taxonomy_scope

# This can happen in development when removing a plugin

rescue_from ActiveRecord::SubclassNotFound do |e|

type = (e.to_s =~ /failed to locate the subclass: '((\w|::)+)'/) ? Regexp.last_match(1) : 'STI-Type'

end

def index

def create

params[:vm].permit!

if (vm = @compute_resource.create_vm params[:vm])

process_success :success_redirect => compute_resource_vms_path(@compute_resource)

else

process_error :redirect => new_compute_resource_vm_path(@compute_resource), :object => @compute_resource

id = params.key?('smart_class_parameter_id') ? params['smart_class_parameter_id'] : params['id']

@smart_class_parameter = PuppetclassLookupKey.authorized(:view_external_parameters).smart_class_parameters.find_by_id(id.to_i) if id.to_i > 0

@smart_class_parameter ||= begin

env_cond = { 'environment_classes.environment_id' => @environment.id } if @environment

PuppetclassLookupKey.authorized(:view_external_parameters).smart_class_parameters.where(puppet_cond).where(env_cond).where(:key => id).first

end

{:completed => CGI.escapeHTML(completed), :part => CGI.escapeHTML(part), :label => item, :category => category}

end

rescue ScopedSearch::QueryNotSupported => e

end

render :json => @items

end

extend ActiveSupport::Concern

def count_login_failure

end

def get_login_failures

module Foreman::Controller::Puppet::HostsControllerExtensions

extend ActiveSupport::Concern

MULTIPLE_EDIT_ACTIONS = %w(select_multiple_environment update_multiple_environment

select_multiple_puppet_proxy update_multiple_puppet_proxy

def update_multiple_environment

# simple validations

error _('No environment selected!')

redirect_to(select_multiple_environment_hosts_path)

return

def environment_from_param

# simple validations

error _('No environment selected!')

redirect_to(select_multiple_environment_hosts_path)

return

def update_multiple_taxonomies(type)

# simple validations

error "No #{type.to_s.classify} selected!"

redirect_to(hosts_path)

return

@fact = FactName.find(params[:id])

begin

data = {:name => CGI.escapeHTML(@fact.name),

rescue

data = @fact

end

def index

@filters = resource_base.includes(:role, :permissions).search_for(params[:search], :order => params[:order])

@roles_authorizer = Authorizer.new(User.current, :collection => @filters.map(&:role_id))

end

include Foreman::Controller::CsvResponder

include Foreman::Controller::ConsoleCommon

MULTIPLE_ACTIONS = %w(multiple_parameters update_multiple_parameters select_multiple_hostgroup

update_multiple_hostgroup

multiple_destroy submit_multiple_destroy multiple_build

end

def compute_resource_selected

Taxonomy.as_taxonomy @organization, @location do

compute_profile_id = params[:host][:compute_profile_id] || Hostgroup.find_by_id(params[:host][:hostgroup_id]).try(:inherited_compute_profile_id)

compute_resource = ComputeResource.authorized(:view_compute_resources).find_by_id(id)

def update_multiple_hostgroup

# simple validations

error _('No host group selected!')

redirect_to(select_multiple_hostgroup_hosts_path)

return

hg = Hostgroup.find_by_id(id)

# update the hosts

@hosts.each do |host|

host.save(:validate => false)

end

def update_multiple_owner

# simple validations

error _('No owner selected!')

redirect_to(select_multiple_owner_hosts_path)

return

end

def validate_power_action

!PowerManager::REAL_ACTIONS.include?(action)

error _('No or invalid power state selected!')

redirect_to(select_multiple_power_state_hosts_path)

# This can happen in development when removing a plugin

rescue_from ActiveRecord::SubclassNotFound do |e|

type = (e.to_s =~ /\'(Setting::.*)\'\./) ? Regexp.last_match(1) : 'STI-Type'

end

def index

# query our subnet dhcp proxy for an unused IP

def freeip

invalid_request

return

end

def remove_link_to_function(text, options)

options.delete_if { |key, value| !options[key].to_s } # otherwise error during template render

title = (_("Click to remove %s") % options[:"data-class-name"])

end

def link_to_add_puppetclass(klass, type)

end

def flot_pie_chart(name, title, data, options = {})

data.map{|element| element[:label] = truncate(element[:label], :length => 16)}

content_tag(:div, nil,

{ :id => name,

:class => 'statistics-pie',

end

def flot_chart(name, xaxis_label, yaxis_label, data, options = {})

content_tag(:div, nil,

{ :id => name,

:class => 'statistics-chart',

:'legend-options' => options.delete(:legend),

:'xaxis-label' => xaxis_label,

:'yaxis-label' => yaxis_label,

}

}.merge(options))

end

def flot_bar_chart(name, xaxis_label, yaxis_label, data, options = {})

ticks = nil

if data.is_a?(Array)

data = data.map do |kv|

[i, kv[1]]

end

elsif data.is_a?(Hash)

data = data.map do |k, v|

[i, v]

end

end

button_classes = %w(btn btn-default btn-action)

button_classes << 'btn-primary' if options[:primary]

# single button

if args.length == 1

content_tag(:span, args[0], :class => button_classes).html_safe

button = link_to(title.html_safe, '#',

:class => button_classes,

:'data-toggle' => 'dropdown')

args.map { |option| content_tag(:li, option) }.join(" ").html_safe

end

button + dropdown_list

return if args.blank?

# single button

# multiple buttons

primary = args.delete_at(0).html_safe

content_tag(:div, :class => "btn-group") do

args.map{|option| content_tag(:li, option)}.join(" ").html_safe

end

end

end

elsif !main_object? audit

["#{audit_action_name(audit).humanize} #{id_to_label audit.audited_changes.keys[0], audit.audited_changes.values[0]}

else

[]

end

module AutosignHelper

def autosign_form

end

end

def power_action_html(vm)

if vm.ready?

{

:class => "btn btn-danger"

}

else

{ :class => "btn btn-info" }

else

{

:class => "btn btn-danger"

}

end

link_to_if_authorized(_("Console"), hash_for_console_host_path().merge(:auth_object => host, :permission => 'console_hosts'),

{ :class => "btn btn-info" })

else

end

end

def subnet_vpc_hash(subnets)

subnet_vpc_hash = {}

subnet_vpc_hash

end

:permission => 'edit_compute_resources'),

:title => _("Associate VM to a Foreman host"),

:method => :put,

)

end

_('Manage'), {},

link_to_function(_('Save positions'), "save_position('#{save_positions_widgets_path}')"),

link_to(_('Reset to default'), reset_default_widgets_path, :method => :put),

widgets_to_add

end

),

end

def widget_data(widget)

:sizex => widget.sizex, :sizey => widget.sizey } }

end

start = Time.zone.now - interval_setting.minutes

(0..9).each do |i|

t = start + (interval.minutes * i)

end

data

end

def searchable_links(name, search, counter)

search += " and #{@data.filter}" if @data.filter.present?

content_tag :li do

content_tag(:h4, @data.report[counter])

end

end

hidden_fields = ''

html_options["data-useds"] ||= "[]"

JSON.parse(html_options["data-useds"]).each do |disabled_value|

end

unauthorized.each do |unauthorized_value|

end

hidden_fields + f.collection_select(attr_ids, authorized.sort_by { |a| a.to_s },

:id, options.delete(:object_label_method) || :to_label, options.merge(:selected => selected_ids),

def radio_button_f(f, attr, options = {})

text = options.delete(:text)

value = options.delete(:value)

f.radio_button(attr, value, options) + " #{text} "

end

end

if options[:file_name]

html = content_tag(:b) {options.delete(:file_name)}

html += content_tag(:hr)

end

field(f, attr, options) do

end

end

def form_for(record_or_name_or_array, *args, &proc)

if args.last.is_a?(Hash)

else

end

super record_or_name_or_array, *args, &proc

end

error = options.delete(:error) || f.object.errors[attr] if f && f.object.respond_to?(:errors)

help_inline = help_inline(options.delete(:help_inline), error)

help_inline += options[:help_inline_permanent] unless options[:help_inline_permanent].nil?

wrapper_class = options.delete(:wrapper_class) || "form-group"

label = options[:no_label] ? "" : add_label(options, f, attr)

end

def user_header

end

end

def resources_chart(timerange = 1.day.ago)

applied, failed, restarted, failed_restarts, skipped = [], [], [], [], []

@host.reports.recent(timerange).each do |r|

end

end

def runtime_chart(timerange = 1.day.ago)

config, runtime = [], []

@host.reports.recent(timerange).each do |r|

end

end

def reports_show

form_tag @host, :id => 'days_filter', :method => :get, :class => "form form-inline" do

content_tag(:span, (_("Found %{count} reports from the last %{days} days") %

:count => @host.reports.recent(@range.days.ago).count }).html_safe)

end

end

link_to_if_authorized(_("Run puppet"), hash_for_puppetrun_host_path(:id => host).merge(:auth_object => host, :permission => 'puppetrun_hosts'),

:disabled => !Setting[:puppetrun],

:class => 'btn btn-default',

end

),

button_group(

return '' if nic.new_record?

if nic.link

else

end

status.html_safe

end

end

def button_group(*elements)

end

def search_bar(*elements)

def icon_text(i, text = "", opts = {})

opts[:kind] ||= "glyphicon"

end

def alert(opts = {})

opts[:header] ||= _("Warning!")

opts[:text] ||= _("Alert")

content_tag :div, :class => html_class, :id => opts[:id] do

result = "".html_safe

result += alert_close if opts[:close]

module LookupKeysHelper

def remove_child_link(name, f, opts = {})

opts[:class] = [opts[:class], "remove_nested_fields"].compact.join(" ")

end

def delete_child_link(name, f, opts = {})

def param_type_selector(f, options = {})

selectable_f f, :key_type, options_for_select(LookupKey::KEY_TYPES.map { |e| [_(e), e] }, f.object.key_type), {},

:label_help => _("<dl>" +

"<dt>String</dt> <dd>Everything is taken as a string.</dd>" +

"<dt>Boolean</dt> <dd>Common representation of boolean values are accepted.</dd>" +

def validator_type_selector(f)

selectable_f f, :validator_type, options_for_select(LookupKey::VALIDATOR_TYPES.map { |e| [_(e), e] }, f.object.validator_type), {:include_blank => _("None")},

:onchange => 'validatorTypeSelected(this)',

:label_help => _("<dl>" +

"<dt>List</dt> <dd>A list of the allowed values, specified in the Validator rule field.</dd>" +

link_to_function(icon_text('pencil-square-o', '', :kind => 'fa'), "override_class_param(this)",

:title => _("Override this value"),

:'data-tag' => 'override',

link_to_function(icon_text('times', '', :kind => 'fa'), "override_class_param(this)",

:title => _("Remove this override"),

:'data-tag' => 'remove',

end

def hidden_toggle(hidden, hide_icon = 'eye-slash', unhide_icon = 'eye', strikethrough = false)

return unless can_edit_params?

if strikethrough && !hidden

else

link_to_function(icon_text(unhide_icon, '', :kind => 'fa'), "input_group_hidden(this)",

:title => _("Unhide this value"),

link_to_function(icon_text(hide_icon, "", :class => ('btn-strike' if strikethrough).to_s, :kind => 'fa'), "input_group_hidden(this)",

:title => _("Hide this value"),

end

end

record.family

end

end

def os_name(record, opts = {})

:text => ('<p>' + _("When editing a template, you must assign a list \

of operating systems which this template can be used with. Optionally, you can \

restrict a template to a list of host groups and/or environments.") + '</p>' +

will select the best match from the available templates of that type, in the \

following order:") + '</p>' + '<ul>' +

'<li>' + _("Host group and Environment") + '</li>' +

'revoked' => 'fa fa-ban' }

def state_filter

STATES.map{|s| _(s)} +

[[_('all'), '']]),

:class => "datatable-filter", :id => "puppetca-filter"

def import_proxy_links(hash, import_env_text = false, classes = nil)

import_from_text = import_env_text ? _("Import environments from %s") : _("Import classes from %s")

SmartProxy.with_features("Puppet").map do |proxy|

end.flatten

end

def report_event_column(event, style = "")

style = "label-default" if event == 0

end

def reports_since(builder)

form_tag config_report_path(@config_report), :id => 'level_filter', :method => :get, :class => "form form-horizontal" do

content_tag(:span, _("Show log messages:") + ' ') +

select(nil, 'level', [[_('All messages'), 'info'], [_('Notices, warnings and errors'), 'notice'], [_('Warnings and errors'), 'warning'], [_('Errors only'), 'error']],

end

end

end

def wizard_header(current, *args)

content = nil

args.each do |arg|

(step == 1) ? content = step_content : content += step_content

step += 1

end

def taxonomy_selects(f, selected_ids, taxonomy, label, options = {}, options_html = {})

options[:disabled] = Array.wrap(options[:disabled])

multiple_selects f, label.downcase.singularize + '_ids', taxonomy.authorized("assign_#{label.downcase}", taxonomy), selected_ids, options, options_html

end

def trendable_types

options = {_('Environment') => 'Environment', _('Operating system') => 'Operatingsystem',

existing = ForemanTrend.types.pluck(:trendable_type)

options.delete_if{ |k, v| existing.include?(v) }

end

def trend_days_filter

content_tag(:span, (_("Trend of the last %s days.") %

select(nil, 'range', 1..Setting[:max_trend], {:selected => range},

end

end

interval_start = ((counter.interval_start || from) > from) ? counter.interval_start : from

next_timestamp = counter.try(:interval_end) || Time.now.utc

# transform the timestamp values to flot format - from seconds in Ruby to milliseconds in flot

end

end.compact

end

include Foreman::Renderer

def ks_console

end

def grub_pass

helper :audits, :layout

def summary(options = {})

time = options[:time] ? %(time >= "#{options[:time]}") : 'time > yesterday'

@query = options[:query].present? ? "#{options[:query]} and #{time}" : time.to_s

@count = Audit.authorized_as(user, :view_audit_logs, Audit).search_for(@query).count

# sends out a summary email of hosts and their metrics (e.g. how many changes failures etc).

def summary(options = {})

hosts = Host::Managed.authorized_as(user, :view_hosts, Host)

time = options[:time] || 1.day.ago

host_data = ConfigReport.summarise(time, hosts.all).sort

private

def load_metrics(host_data)

host_data.flatten.delete_if { |x| true unless x.is_a?(Hash) }.each do |data_hash|

total_metrics["failed"] += data_hash[:metrics]["failed"]

def method_missing(method, *args, &block)

method = method.to_s

return super if method == 'vm_attrs'

if vm_attrs.has_key?(method)

def console(uuid)

vm = find_vm_by_uuid(uuid)

end

def destroy_vm(uuid)

end

args[:disks] = []

args[:volumes].each_with_index do |vol_args, i|

end

end

# Listen address cannot be updated while the guest is running

# When we update the display password, we pass the existing listen address

vm.update_display(:password => password, :listen => vm.display[:listen], :type => vm.display[:type])

rescue ::Libvirt::Error => e

if e.message =~ /cannot change listen address/

logger.warn e

vm_attrs[:memory] = nil

logger.debug("Compute attributes for VM '#{uuid}' diddn't contain :memory_size")

else

end

vm_attrs

end

begin

vols = []

(volumes = args[:volumes]).each do |vol|

vol.capacity = "#{vol.capacity}G" unless vol.capacity.to_s.end_with?('G')

vol.allocation = "#{vol.allocation}G" unless vol.allocation.to_s.end_with?('G')

vol.save

rating = 0.0

if os[:name].include?(os_name)

rating += 100

rating += 10 if os[:name].include?("#{os_name}_#{host.operatingsystem.major}")

rating += 10 if arch_name && os[:name].include?(arch_name)

end

{

:search => params['search']['value'] || '',

:max => max,

:without_details => true

}

end

end

def os_name_mapping(host)

end

def arch_name_mapping(host)

super && flavors

rescue Excon::Errors::Unauthorized => e

errors[:base] << e.response.body

errors[:base] << e.message

end

def volumes_attributes=(attrs); end

def poweroff

end

def reset

# We encode the hw_model into the image file name as not all Sparc flashes can contain all possible hw_models. The user can always

# edit it if required or use symlinks if they prefer.

hw_model = model.try :hardware_model if defined?(model_id)

"#{operatingsystem.file_prefix}.#{architecture}#{hw_model.empty? ? '' : '.' + hw_model.downcase}.#{operatingsystem.image_extension}"

else

""

end

def jumpstart?

end

end

end

scoped_search :relation => :last_report_object, :on => :origin

scoped_search_status "applied", :relation => :configuration_status_object, :on => :status, :rename => :'status.applied'

scoped_search_status "restarted", :relation => :configuration_status_object, :on => :status, :rename => :'status.restarted'

scoped_search_status "failed", :relation => :configuration_status_object, :on => :status, :rename => :'status.failed'

scoped_search :relation => :interfaces, :on => :mac, :complete_value => true, :rename => :has_mac, :only_explicit => true

scoped_search :relation => :puppetclasses, :on => :name, :complete_value => true, :rename => :class, :only_explicit => true, :operators => ['= ', '~ '], :ext_method => :search_by_puppetclass

if SETTINGS[:locations_enabled]

scoped_search :relation => :location, :on => :title, :rename => :location, :complete_value => true, :only_explicit => true

class ConfigReport < Report

METRIC = %w[applied restarted failed failed_restarts skipped pending]

BIT_NUM = 6

scoped_search_status 'applied', :on => :status, :rename => :applied

scoped_search_status 'restarted', :on => :status, :rename => :restarted

validates :fullname, :uniqueness => true, :allow_blank => true, :allow_nil => true

scoped_search :on => [:name, :fullname], :complete_value => true

# with proc support, default_scope can no longer be chained

# include all default scoping here

has_one :parent_fact_name, :through => :fact_name, :source => :parent

scoped_search :on => :value, :default_order => true, :ext_method => :search_value_cast_facts

scoped_search :on => :updated_at, :rename => :reported_at, :only_explicit => true, :complete_value => true

scoped_search :on => :host_id, :only_explicit => true, :complete_value => false

else

k

end

end

output

end

# this method accepts a puppets external node yaml output and generate a node in our setup

# it is assumed that you already have the node (e.g. imported by one of the rack tasks)

def importNode(nodeinfo)

# puppet classes

classes = nodeinfo["classes"]

classes = classes.keys if classes.is_a?(Hash)

def self.count_habtm(association)

counter = Host::Managed.joins(association.tableize.to_sym).group("#{association.tableize.to_sym}.id").reorder('').count

# Puppetclass.find(counter.keys.compact)...

end

def self.provision_methods

}

scoped_search :on => :name, :complete_value => :true

scoped_search :relation => :hosts, :on => :name, :complete_value => :true, :rename => "host", :only_explicit => true

scoped_search :relation => :puppetclasses, :on => :name, :complete_value => true, :rename => :class, :only_explicit => true, :operators => ['= ', '~ ']

scoped_search :relation => :environment, :on => :name, :complete_value => :true, :rename => :environment, :only_explicit => true

KEY_DELM = ","

EQ_DELM = "="

validates_lengths_from_database

has_many :hostgroups, :dependent => :nullify

# We need to include $ in this as $arch, $release, can be in this string

validates :name, :uniqueness => true, :presence => true

validates :path, :uniqueness => true, :presence => true,

:url_schema => ['http', 'https', 'ftp', 'nfs']

attr_exportable :mode, :bond_options

validates :mode, :presence => true, :inclusion => { :in => MODES }

def add_slave(identifier)

scoped_search :relation => :architectures, :on => :name, :complete_value => :true, :rename => "architecture", :only_explicit => true

scoped_search :relation => :media, :on => :name, :complete_value => :true, :rename => "medium", :only_explicit => true

scoped_search :relation => :provisioning_templates, :on => :name, :complete_value => :true, :rename => "template", :only_explicit => true

FAMILIES = { 'Debian' => %r{Debian|Ubuntu}i,

'Redhat' => %r{RedHat|Centos|Fedora|Scientific|SLC|OracleLinux}i,

end

def boot_filename(host = nil)

end

def kernel(arch)

end

def boot_filename(host = nil)

end

def kernel(arch)

# returns module name (excluding of the class name)

# if class separator does not exists (the "::" chars), then returns the whole class name

def module_name

end

# returns class name (excluding of the module name)

def klass

end

def all_hostgroups(with_descendants = true, unsorted = false)

include EncryptValue

self.inheritance_column = 'category'

FROZEN_ATTRS = %w{name category full_name}

NONZERO_ATTRS = %w{puppet_interval idle_timeout entries_per_page max_trend outofsync_interval}

BLANK_ATTRS = %w{ host_owner trusted_hosts login_delegation_logout_url authorize_login_delegation_auth_source_user_autocreate root_pass default_location default_organization websockets_ssl_key websockets_ssl_cert oauth_consumer_key oauth_consumer_secret login_text

:vlanid, :mtu, :ipam, :boot_mode, :type], :complete_value => true

scoped_search :relation => :domains, :on => :name, :rename => :domain, :complete_value => true

delegate :supports_ipam_mode?, :supported_ipam_modes, :show_mask?, to: 'self.class'

errors.add(:to, _("must be specified if from is defined")) if to.blank?

end

return if errors.key?(:from) || errors.key?(:to)

errors.add(:from, _("can't be bigger than to range")) if from.present? && t.present? && f > t

end

end

def expire_topbar_cache

end

def parent_params(include_source = false)

end

def find_all_user_roles_for(usergroup)

end

def find_all_usergroups

end

permission_set.security_block :host_editing do |map|

:"api/v2/host_classes" => [:index, :create, :destroy]

}

map.permission :view_params, { :host_editing => [:view_params],

end

permission_set.security_block :facts do |map|

:fact_values => [:index, :show, :auto_complete_search],

:"api/v2/fact_values" => [:index, :show]

}

end

permission_set.security_block :statistics do |map|

:"api/v2/statistics" => [:index]

}

end

def requires_foreman(matcher)

current = SETTINGS[:version].notag

unless Gem::Dependency.new('', matcher).match?('', current)

end

true

end

# matcher format is gem dependency format

def requires_foreman_plugin(plugin_name, matcher)

plugin = Plugin.find(plugin_name)

unless Gem::Dependency.new('', matcher).match?('', plugin.version)

end

true

end

end

def url

end

def url_hash

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

hostgroup_matches.each do |hostgroup_match|

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

end if add_hostgroup_matches?(rule)

end

if host.hostgroup

path = host.hostgroup.to_label

while path.include?("/")

matches << "hostgroup#{LookupKey::EQ_DELM}#{path}"

end

end

computed_lookup_value = nil

lookup_values.each do |lookup_value|

element, element_name = get_element_and_element_name(lookup_value)

computed_lookup_value = compute_lookup_value(lookup_value, element, element_name)

computed_lookup_value[:managed] = lookup_value.omit if lookup_value.lookup_key.puppet?