params[:search]="last_report > \"#{Setting[:puppet_interval] + 5} minutes ago\" and (status.failed > 0 or status.failed_restarts > 0)"

params[:search]="last_report > \"#{Setting[:puppet_interval] + 5} minutes ago\" and (status.applied > 0 or status.restarted > 0)"

params[:search]="last_report < \"#{Setting[:puppet_interval]} minutes ago\" and status.enabled = true"

index "Hosts which didn't run puppet in the last #{Setting[:puppet_interval]} minutes"

class SettingsController < ApplicationController

include Foreman::Controller::AutoCompleteSearch

def index

values = Setting.search_for(params[:search], :order => params[:order])

respond_to do |format|

format.html do

@settings = values.paginate(:page => params[:page])

end

format.json { render :json => values.all}

end

end

def edit

@setting = Setting.find(params[:id])

end

def update

@setting = Setting.find(params[:id])

if @setting.update_attributes(params[:setting])

process_success

else

process_error

end

end

end

interval = Setting[:puppet_interval] / 10

start =Time.now.utc - Setting[:puppet_interval].minutes

(1..(Setting[:puppet_interval] / interval)).each do

text: 'Run Distribution in the last #{Setting[:puppet_interval]} minutes'

module SettingsHelper

def value f

case f.object.settings_type

when "boolean"

f.select :value, options_for_select(["true", "false"]), :value => f.object.value.to_s

else

f.text_field :value, :value => f.object.value

end

end

end

Puppet[:config] = SETTINGS[:puppetconfdir]

env[:production] = conf[:main][:modulepath] || conf[:puppetmasterd][:modulepath] || Setting[:modulepath]

named_scope :recent, lambda { |*args| {:conditions => ["last_report > ?", (args.first || (Setting[:puppet_interval] + 5).minutes.ago)]} }

named_scope :out_of_sync, lambda { |*args| {:conditions => ["last_report < ? and enabled != ?", (args.first || (Setting[:puppet_interval] + 5).minutes.ago), false]} }

last_report.nil? or last_report < Time.now - (Setting[:puppet_interval] + 3).minutes and enabled?

if Setting[:ignore_puppet_facts_for_provisioning]

unless Setting[:ignore_puppet_facts_for_provisioning]

env=fv(:environment) || Setting[:default_puppet_environment]

read_attribute(:puppetmaster_name) || Setting[:puppet_server]

write_attribute(:puppetmaster_name, pm == (Setting[:puppet_server]) ? nil : pm)

read_attribute(:root_pass) || Setting[:root_pass]

if (body[:url] = Setting[:foreman_url]).empty?

email = options[:email] || Setting[:administrator]

email = Setting[:administrator] if email.empty?

doc_root = Pathname.new(Setting[:document_root])

host.populateFieldsFromFacts if Setting[:using_storeconfigs]

HostMailer.deliver_error_state(self) if Setting[:failed_report_email_notification]

class Setting < ActiveRecord::Base

attr_accessible :name, :value, :description, :category, :settings_type, :default

TYPES= %w{ integer boolean hash array }

FROZEN_ATTRS = %w{ name default description category settings_type }

validates_presence_of :name, :description

validates_uniqueness_of :name

validates_numericality_of :value, :if => Proc.new {|s| s.settings_type == "integer"}

validates_inclusion_of :value, :in => [true,false], :if => Proc.new {|s| s.settings_type == "boolean"}

validates_inclusion_of :settings_type, :in => TYPES, :allow_nil => true, :allow_blank => true

serialize :value

serialize :default

before_validation :fix_booleans, :strip_unneeded_value

before_save :save_as_settings_type

validate :validate_attributes

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

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

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

def self.[](name)

if record = first(:conditions => {:name => name.to_s})

record.value

end

end

def self.[]=(name, value)

record = find_or_create_by_name name.to_s

record.value = value

record.save

end

def self.method_missing(method, *args)

super(method, *args)

rescue NoMethodError

method_name = method.to_s

#setter method

if method_name =~ /=$/

self[method_name.chomp("=")] = args.first

#getter

else

self[method_name]

end

end

def value

v = (super.blank? ? default : super)

case settings_type

when "integer"

v = v.to_i

when "boolean"

v = ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(v)

end

v

end

private

def save_as_settings_type

t = default.class.to_s.downcase

if TYPES.include?(t)

self.settings_type = t

else

self.settings_type = "integer" if default.is_a?(Integer)

self.settings_type = "boolean" if default.is_a?(TrueClass) or default.is_a?(FalseClass)

end

end

def fix_booleans

if settings_type = "boolean"

self.value = true if value == "true"

self.value = false if value == "false"

end

end

def strip_unneeded_value

self.value = nil if value == default

end

def self.create_default_settings

domain = Facter.domain

[

set('administrator', "The Default administrator email address", "root@#{domain}"),

set('foreman_url', "The URL where your foreman instance is running on", "http://foreman.#{domain}"),

].each { |s| create s.update(:category => "General")}

[

set('root_pass', "Default ecrypted root password on provisioned hosts default is 123123", "xybxa6JUkz63w"),

set('safemode_render', "Enable safe mode config templates rendinging(recommended)", true),

set('ssl_certificate', "SSL Certificate path that foreman would use to communicate with its proxies", Puppet.settings[:hostcert]),

set('ssl_ca_file', "SSL CA file that foreman would use to communicate with its proxies", Puppet.settings[:localcacert]),

set('ssl_priv_key', "SSL Private Key file that foreman would use to communicate with its proxies", Puppet.settings[:hostprivkey]),

set('ignore_puppet_facts_for_provisioning', "Does not update ipaddress and MAC values from puppet facts", false)

].each { |s| create s.update(:category => "Provisioning")}

[

set('puppet_interval', "Puppet interval in minutes", 30 ),

set('default_puppet_environment',"The Puppet environment foreman would default to in case it can't auto detect it", "production"),

set('modulepath',"The Puppet default module path in case that Foreman can't auto detect it", "/etc/puppet/modules"),

set('document_root', "Document root where puppetdoc files should be created", "#{RAILS_ROOT}/public/puppet/rdoc"),

set('puppetrun', "Enables Puppetrun Support", false),

set('puppet_server', "Default Puppet Server hostname", "puppet"),

set('failed_report_email_notification', "Enable Email Alerts per each failed puppet report", false),

set('using_storeconfigs', "Foreman is sharing its database with Puppet Store configs", (!Puppet.settings.instance_variable_get(:@values)[:master][:dbadapter].empty? rescue false))

].compact.each { |s| create s.update(:category => "Puppet")}

end

def self.set name, description, default, value = nil

value ||= SETTINGS[name.to_sym]

{:name => name, :value => value, :description => description, :default => default}

end

def validate_attributes

return true if new_record?

changed_attributes.keys.each do |c|

if FROZEN_ATTRS.include?(c.to_s)

errors.add(c, "is not allowed to change")

return false

end

end

true

end

end

email = Setting[:administrator]

<td>Good Host Reports in the last <%= Setting[:puppet_interval] %> minutes</td>

['Foreman Settings', settings_url],

<%= link_to_if_authorized "Run puppet", hash_for_puppetrun_host_path(:id => @host).merge(:auth_action => :edit, :enable_link => Setting[:puppetrun]),

<% title "Edit Setting" %>

<% form_for @setting do |f| %>

<div class="span-24 last">

<%= f.error_messages %>

<span class="span-8">

<%= f.object %>

</span>

<span class="span-8">

<%= f.label :value %>

<%= value(f) %>

</span>

<span class="span-8 last">

<%= f.object.description %>

</span>

</div>

<div class="span-24 last"><%= f.submit %></div>

<% end %>

<% title "Foreman Settings" %>

<table class="list">

<tr>

<th><%= sort :name %></th>

<th>Value</th>

<th>Description</th>

<th><%= sort :category %></th>

<th></th>

</tr>

<% for setting in @settings %>

<tr class="<%= cycle("even", "odd") -%>">

<td><%=h setting.name %></td>

<td><%=h setting.value %></td>

<td><%=h setting.description %></td>

<td><%=h setting.category %></td>

<td><%= link_to "Edit", edit_setting_path(setting) %></td>

</tr>

<% end %>

</table>

<%= page_entries_info @settings %>

<%= will_paginate @settings %>

map.resources :settings, :only => [:index, :edit, :update]

class CreateSettings < ActiveRecord::Migration

def self.up

create_table :settings do |t|

t.string :name

t.text :value

t.text :description

t.string :category

t.string :settings_type

t.text :default, :null => false

t.timestamps

end

add_index :settings, :name, :unique => true

Setting.create_default_settings

end

def self.down

drop_table :settings

end

end

if Setting[:safemode_render]

:yumrepo => @yumrepo, :dynamic => @dynamic, :epel => @epel, :kernel => @kernel, :initrd => @initrd,

cert = Setting[:ssl_certificate]

ca_cert = Setting[:ssl_ca_file]

hostprivkey = Setting[:ssl_private_key]

attributes1:

name: administrator

category: General

default: root@some.host.fqdn

description: The Default administrator email address

attributes2:

name: foreman_url

category: General

default: http://foreman.some.host.fqdn

attributes3:

name: root_pass

category: Provisioning

default: xybxa6JUkz63w

description: Default root password on provisioned hosts default is 123123

attributes4:

name: safemode_render

category: Provisioning

default: t

description: Enable safe mode config templates rendinging(recommended)

attributes5:

name: ssl_certificate

category: Provisioning

default: /var/lib/puppet/ssl/certs/some.host.fqdn

description: SSL Certificate path that foreman would use to communicate with its proxies

attributes6:

name: ssl_ca_file

category: Provisioning

default: /var/lib/puppet/ssl/certs/ca.pem

description: SSL CA file that foreman would use to communicate with its proxies

attributes7:

name: ssl_priv_key

category: Provisioning

default: /var/lib/puppet/ssl/private_keys/super.some.host.fqdn.pem

description: SSL Private Key file that foreman would use to communicate with its proxies

attributes8:

name: puppet_interval

settings_type: integer

category: Puppet

default: "30"

description: Puppet interval in minutes

attributes9:

name: default_puppet_environment

category: Puppet

default: production

description: "The Puppet environment foreman would default to in case it can't auto detect it"

attributes10:

name: modulepath

category: Puppet

default: /etc/puppet/modules

description: "The Puppet default module path in case that Foreman can't auto detect it"

attributes11:

name: document_root

category: Puppet

default: /home/olevy/git/foreman/public/puppet/rdoc

description: Document root where puppetdoc files should be created

attributes12:

name: puppet_server

category: Puppet

default: puppet

description: Default Puppet Server hostname

attributes13:

name: failed_report_email_notification

category: Puppet

default: false

description: Enable Email Alerts per each failed puppet report

require 'test_helper'

class SettingsControllerTest < ActionController::TestCase

def test_index

get :index

assert_template 'index'

end

def test_edit

get :edit, :id => Setting.first

assert_template 'edit'

end

def test_update_invalid

Setting.any_instance.stubs(:valid?).returns(false)

put :update, :id => Setting.first

assert_template 'edit'

end

def test_update_valid

Setting.any_instance.stubs(:valid?).returns(true)

put :update, :id => Setting.first

assert_redirected_to settings_url

end

end

Setting[:foreman_url] = "http://localhost:3000/hosts/:id"

Setting[:administrator] = "admin@vurbia.com"

Setting[:administrator] = "admin@example.com"

Setting[:failed_report_email_notification] = true

Setting[:failed_report_email_notification] = false

require 'test_helper'

class SettingTest < ActiveSupport::TestCase

def test_settings_should_save_complex_types

assert (Setting.create(:name => "foo", :value => [1,2,3,'b'], :default => ['b',"b"], :description => "test foo" ))

s = Setting.find_by_name "foo"

assert_equal [1,2,3,'b'], s.value

assert_equal ['b',"b"], s.default

assert_equal "array", s.settings_type

end

def test_should_not_find_a_value_if_doesnt_exists

assert_nil Setting["no_such_thing"]

end

def test_should_provide_default_if_no_value_defined

assert Setting.create(:name => "foo", :default => 5, :description => "test foo")

assert_equal 5, Setting["foo"]

end

def test_should_find_setting_via_method_missing_too

assert Setting.create(:name => "bar", :value => "baz", :default => "x", :description => "test bar")

assert_equal Setting["bar"], Setting.bar

assert_equal "baz", Setting.bar

end

def test_settings_with_the_same_value_as_default_should_save_the_value

assert Setting.create(:name => "foo", :value => "bar", :default => "bar", :description => "x")

s = Setting.find_by_name "foo"

assert_nil s.read_attribute(:value)

assert_equal "bar", Setting.foo

end

def test_should_save_settings_type

assert Setting.create(:name => "foo", :default => 5, :description => "test foo")

assert_equal "integer", Setting.find_by_name("foo").try(:settings_type)

end

def test_should_not_allowed_to_change_frozen_attributes

assert Setting.create(:name => "foo", :default => 5, :description => "test foo")

s = Setting.find_by_name "foo"

s.name = "boo"

assert !s.save

assert_equal s.errors[:name], "is not allowed to change"

end

def test_name_could_be_a_symbol_or_a_string

assert Setting.create(:name => "foo", :default => 5, :description => "test foo")

assert_equal Setting["foo"], Setting[:foo]

Setting[:foo] = 3

assert_equal 3,Setting["foo"]

end

def test_boolean_values_should_have_setting_type_for_false

assert Setting.create(:name => "oo", :default => false, :description => "test foo")

assert_equal "boolean", Setting.find_by_name("oo").settings_type

assert_equal false, Setting["oo"]

end

def test_boolean_values_should_have_setting_type_for_true

assert Setting.create(:name => "oo", :default => true, :description => "test foo")

assert_equal "boolean", Setting.find_by_name("oo").settings_type

assert_equal true, Setting["oo"]

end

end