.error-message{

padding-right: 10px;

}

eos

def status

end

private

param_group :search_and_pagination, ::Api::V2::BaseController

def index

end

api :GET, "/hosts/:id/", N_("Show a host")

process_response @host.destroy

end

param :id, :identifier_dottable, :required => true

description <<-eos

Return value may either be one of the following:

eos

def status

end

api :GET, "/hosts/:id/vm_compute_attributes", N_("Get vm attributes of host")

:console

when 'disassociate'

:edit

:view

else

super

# If the user has a fact_filter then we need to include :fact_values

# We do not include most associations unless we are processing a html page

def included_associations(include = [])

end

def errors_hash(errors)

format.html do

@hosts = search.includes(included_associations).paginate(:page => params[:page])

# SQL optimizations queries

# rendering index page for non index page requests (out of sync hosts etc)

@hostgroup_authorizer = Authorizer.new(User.current, :collection => @hosts.map(&:hostgroup_id).compact.uniq)

render :index if title and (@title = title)

end

def review_before_build

render :layout => false

end

def last_report_tooltip(record)

opts = { :rel => "twipsy" }

opts.merge!( "data-original-title" => _("View last report details"))

else

opts.merge!(:disabled => true, :class => "disabled", :onclick => 'return false')

end

# method that reformat the hostname column by adding the status icons

end

end

def days_ago(time)

end

def overview_fields(host)

fields = [

[_("Domain"), (link_to(host.domain, hosts_path(:search => "domain = #{host.domain}")) if host.domain)],

[_("Realm"), (link_to(host.realm, hosts_path(:search => "realm = #{host.realm}")) if host.realm)],

[_("IP Address"), host.ip],

fields

end

def possible_images(cr, arch = nil, os = nil)

return cr.images unless controller_name == "hosts"

return [] unless arch && os

included do

include ScopedSearchExtensions

has_many :search_parameters, :class_name => 'Parameter', :foreign_key => :reference_id

belongs_to :search_users, :class_name => 'User', :foreign_key => :owner_id

scoped_search :on => :managed, :complete_value => {:true => true, :false => false}

scoped_search :on => :owner_type, :complete_value => true, :only_explicit => true

scoped_search :on => :owner_id, :complete_enabled => false, :only_explicit => true

scoped_search :in => :model, :on => :name, :complete_value => true, :rename => :model

scoped_search :in => :hostgroup, :on => :name, :complete_value => true, :rename => :hostgroup

belongs_to :host, {:class_name => "Host::Managed", :foreign_key => :host_id}.merge(options)

end

end

class Host::Managed < Host::Base

include Hostext::Search

PROVISION_METHODS = %w[build image]

has_many :puppetclasses, :through => :host_classes, :dependent => :destroy

belongs_to :hostgroup

has_many :reports, :foreign_key => :host_id

has_many :host_parameters, :dependent => :destroy, :foreign_key => :reference_id, :inverse_of => :host

has_many :parameters, :dependent => :destroy, :foreign_key => :reference_id, :class_name => "HostParameter"

accepts_nested_attributes_for :host_parameters, :allow_destroy => true

belongs_to :owner, :polymorphic => true

belongs_to :compute_resource

belongs_to :image

has_one :token, :foreign_key => :host_id, :dependent => :destroy

before_destroy :remove_reports

define_model_callbacks :build, :only => :after

define_model_callbacks :provision, :only => :before

# Custom hooks will be executed after_commit

after_commit :build_hooks

before_save :clear_data_on_build

scope :with_os, -> { where('hosts.operatingsystem_id IS NOT NULL') }

scope :with_error, lambda {

}

scope :without_error, lambda {

}

scope :with_changes, lambda {

}

scope :without_changes, lambda {

}

scope :successful, -> { without_changes.without_error.without_pending_changes}

if self.compute_resource

host.compute_attributes = host.compute_resource.vm_compute_attributes_for(self.uuid)

end

host

end

compute_resource ? compute_resource.vm_compute_attributes_for(uuid) : nil

end

def smart_proxies

SmartProxy.where(:id => smart_proxy_ids)

end

unattended_render(template)

end

build_status = HostBuildStatus.new(self)

build_status.check_all_statuses

build_status

@old = super { |clone| clone.interfaces = self.interfaces.map {|i| setup_object_clone(i) } }

end

private

# validate uniqueness can't prevent saving two interfaces that has same DNS name

status

end

# converts a name into ip address using DNS.

# if we are managing DNS, we can query the correct DNS server

# otherwise, use normal systems dns settings to resolv

self.config_groups = []

end

end

end

class Report < ActiveRecord::Base

include Authorizable

validates_lengths_from_database

belongs_to_host

scoped_search :on => :reported_at, :complete_value => true, :default_order => :desc, :rename => :reported, :only_explicit => true

scoped_search :on => :status, :offset => 0, :word_size => 4*BIT_NUM, :complete_value => {:true => true, :false => false}, :rename => :eventful

# returns reports for hosts in the User's filter set

scope :my_reports, lambda {

else

raise Foreman::Exception(N_('Unsupported report status format'))

end

end

# extracts serialized metrics and keep them as a hash_with_indifferent_access

METRIC.each {|m| metrics[m] = 0 }

host.reports.recent(time).select(:status).each do |r|

metrics.each_key do |m|

end

end

list[host.name] = {:metrics => metrics, :id => host.id} if metrics.values.sum > 0

def self.report_status

"status"

end

end

:dashboard => [:OutOfSync, :errors, :active],

:unattended => [:template, :provision],

:"api/v1/hosts" => [:index, :show, :status],

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

:locations => [:mismatches],

:organizations => [:mismatches]

end

@apipie_ignored_controllers

end

end

end

end

# convert report status to bit field

# we update our host record, so we won't need to lookup the report information just to display the host list / info

host.last_report = time if host.last_report.nil? or host.last_report.utc < time

# if proxy authentication is enabled and we have no puppet proxy set, use it.

host.puppet_proxy_id ||= proxy_id

# Check for errors

inspect_report

logger.info("Imported report for #{name} in #{(Time.now - start_time).round(2)} seconds")

end

private

@raw_status = options[:bit_field] || 0

end

def calculate

@raw_status = 0

counters.each do |type, value|

raw_status

end

end

end

private

attr_reader :raw_status, :counters

extends "api/v2/hosts/base"

attributes :ip, :environment_id, :environment_name, :last_report, :mac, :realm_id, :realm_name,

:sp_mac, :sp_ip, :sp_name, :domain_id, :domain_name, :architecture_id, :architecture_name, :operatingsystem_id, :operatingsystem_name,

:subnet_id, :subnet_name, :sp_subnet_id, :ptable_id, :ptable_name, :medium_id, :medium_name, :build,

:enabled, :puppet_ca_proxy_id, :managed, :use_image, :image_file, :uuid, :compute_resource_id, :compute_resource_name,

:compute_profile_id, :compute_profile_name, :capabilities, :provision_method,

:puppet_proxy_id, :certname, :image_id, :image_name, :created_at, :updated_at,

attributes :organization_id, :organization_name if SETTINGS[:organizations_enabled]

attributes :location_id, :location_name if SETTINGS[:locations_enabled]

config.autoload_paths += %W(#{config.root}/app/models/auth_sources)

config.autoload_paths += %W(#{config.root}/app/models/compute_resources)

config.autoload_paths += %W(#{config.root}/app/models/lookup_keys)

config.autoload_paths += %W(#{config.root}/app/models/operatingsystems)

config.autoload_paths += %W(#{config.root}/app/models/parameters)

config.autoload_paths += %W(#{config.root}/app/models/trends)

end

resources :hosts, :except => [:new, :edit] do

get :status, :on => :member

get :vm_compute_attributes, :on => :member

put :puppetrun, :on => :member

put :disassociate, :on => :member

assert_response :success

end

test "should be able to create hosts even when restricted" do

disable_orchestration

assert_difference('Host.count') do

:domain => domains(:mydomain), :operatingsystem => operatingsystems(:redhat), :subnet => subnets(:one), :puppet_proxy => smart_proxies(:puppetmaster),

:architecture => architectures(:x86_64), :environment => environments(:production), :managed => true,

:owner_type => "User", :root_pass => "xybxa6JUkz63w")

# bypass host.valid?

HostBuildStatus.any_instance.stubs(:host_status).returns(true)

end

host = @host

kind = FactoryGirl.create(:template_kind)

FactoryGirl.create(:provisioning_template, :template => "provision script <%= @foreman.server.status %>",:name => "My Failed Template", :template_kind => kind, :operatingsystem_ids => [host.operatingsystem_id], :environment_ids => [host.environment_id], :hostgroup_ids => [host.hostgroup_id] )

refute_empty @build.errors[:templates]

end

assert_nil host

end