foreman_discovery 1.0.0 → 1.0.2

data/test/foreman_app/app/controllers/puppetclasses_controller.rb

@@ -1,85 +0,0 @@
-require 'foreman/controller/environments'
-
-class PuppetclassesController < ApplicationController
-  include Foreman::Controller::Environments
-  include Foreman::Controller::AutoCompleteSearch
-  before_filter :find_by_name, :only => [:edit, :update, :destroy, :assign]
-  before_filter :setup_search_options, :only => :index
-
-  def index
-    begin
-      values = Puppetclass.search_for(params[:search], :order => params[:order])
-    rescue => e
-      error e.to_s
-      values = Puppetclass.search_for ""
-    end
-
-    respond_to do |format|
-      format.html do
-        @puppetclasses = values.paginate(:page => params[:page])
-        @host_counter = Host.count(:group => :puppetclass_id, :joins => :puppetclasses, :conditions => {:puppetclasses => {:id => @puppetclasses.all}})
-        @keys_counter = Puppetclass.joins(:class_params).select('distinct environment_classes.lookup_key_id').count(:group => 'name')
-      end
-      format.json { render :json => Puppetclass.classes2hash(values.all(:select => "name, id")) }
-    end
-  end
-
-  def new
-    @puppetclass = Puppetclass.new
-  end
-
-  def create
-    @puppetclass = Puppetclass.new(params[:puppetclass])
-    if @puppetclass.save
-      notice _("Successfully created puppetclass.")
-      redirect_to puppetclasses_url
-    else
-      render :action => 'new'
-    end
-  end
-
-  def edit
-  end
-
-  def update
-    if @puppetclass.update_attributes(params[:puppetclass])
-      notice _("Successfully updated puppetclass.")
-      redirect_to puppetclasses_url
-    else
-      render :action => 'edit'
-    end
-  end
-
-  def destroy
-    if @puppetclass.destroy
-      notice _("Successfully destroyed puppetclass.")
-    else
-      error @puppetclass.errors.full_messages.join("<br/>")
-    end
-    redirect_to puppetclasses_url
-  end
-
-  # form AJAX methods
-  def parameters
-    puppetclass = Puppetclass.find(params[:id])
-    render :partial => "puppetclasses/class_parameters", :locals => {:klass => puppetclass, :host => refresh_host}
-  end
-
-  private
-
-  def refresh_host
-    @host = Host::Base.find_by_id(params['host_id'])
-    if @host
-      unless @host.kind_of?(Host::Managed)
-        @host      = @host.becomes(Host::Managed)
-        @host.type = "Host::Managed"
-      end
-      @host.attributes = params['host']
-    else
-      @host ||= Host::Managed.new(params['host'])
-    end
-    return @host
-  end
-
-
-end

data/test/foreman_app/app/controllers/reports_controller.rb

@@ -1,60 +0,0 @@
-require 'foreman/controller/smart_proxy_auth'
-
-class ReportsController < ApplicationController
-  include Foreman::Controller::AutoCompleteSearch
-  include Foreman::Controller::SmartProxyAuth
-
-  add_puppetmaster_filters :create
-  before_filter :setup_search_options, :only => :index
-
-  def index
-    values = Report.my_reports.search_for(params[:search], :order => params[:order])
-    pagination_opts = { :page => params[:page], :per_page => params[:per_page] }
-    respond_to do |format|
-      format.html { @reports =      values.paginate(pagination_opts).includes(:host) }
-      format.json { render :json => values.paginate(pagination_opts).includes(:host, :logs)}
-    end
-  rescue => e
-    error e.to_s
-    @reports = Report.my_reports.search_for("").paginate :page => params[:page]
-  end
-
-  def show
-    # are we searching for the last report?
-    if params[:id] == "last"
-      conditions = { :host_id => Host.find_by_name(params[:host_id]).try(:id) } unless params[:host_id].blank?
-      params[:id] = Report.my_reports.maximum(:id, :conditions => conditions)
-    end
-
-    return not_found if params[:id].blank?
-
-    @report = Report.my_reports.find(params[:id], :include => { :logs => [:message, :source] })
-    respond_to do |format|
-      format.html { @offset = @report.reported_at - @report.created_at }
-      format.json { render :json => @report }
-    end
-  end
-
-  def create
-    Taxonomy.no_taxonomy_scope do
-      if Report.import params.delete("report") || request.body
-        render :text => _("Imported report"), :status => 200 and return
-      else
-        render :text => _("Failed to import report"), :status => 500
-      end
-    end
-  rescue => e
-    render :text => e.to_s, :status => 500
-  end
-
-  def destroy
-    @report = Report.find(params[:id])
-    if @report.destroy
-      notice _("Successfully destroyed report.")
-    else
-      error @report.errors.full_messages.join("<br/>")
-    end
-    redirect_to reports_url
-  end
-
-end

data/test/foreman_app/app/controllers/roles_controller.rb

@@ -1,78 +0,0 @@
-# redMine - project management software
-# Copyright (C) 2006  Jean-Philippe Lang
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-class RolesController < ApplicationController
-  include Foreman::Controller::AutoCompleteSearch
-  before_filter :require_admin
-
-  def index
-    values = Role.search_for(params[:search], :order => params[:order])
-    respond_to do |format|
-      format.html { @roles = values.paginate :page => params[:page] }
-      format.json { render :json => values }
-    end
-  end
-
-  def new
-    # Prefills the form with 'default user' role permissions
-    @role        = Role.new({:permissions => Role.default_user.permissions})
-  end
-
-  def create
-    @role = Role.new(params[:role])
-    if @role.save
-      process_success
-    else
-      process_error
-    end
-  end
-
-  def edit
-    @role = Role.find(params[:id])
-  end
-
-  def update
-    @role = Role.find(params[:id])
-    if @role.update_attributes(params[:role])
-      process_success
-    else
-      process_error
-    end
-  end
-
-  def destroy
-    @role = Role.find(params[:id])
-    if @role.destroy
-      process_success
-    else
-      process_error
-    end
-  end
-
-  def report
-    @roles = Role.all(:order => 'builtin, name')
-    @permissions = Foreman::AccessControl.permissions.select { |p| !p.public? }
-    if request.post?
-      @roles.each do |role|
-        role.permissions = params[:permissions][role.id.to_s]
-        role.save
-      end
-      notice _("All non public permissions successfully updated")
-      redirect_to roles_url
-    end
-  end
-end

data/test/foreman_app/app/controllers/settings_controller.rb

@@ -1,21 +0,0 @@
-class SettingsController < ApplicationController
-  include Foreman::Controller::AutoCompleteSearch
-  before_filter :require_admin
-
-  def index
-    @settings = Setting.live_descendants.search_for(params[:search])
-    respond_to do |format|
-      format.html
-      format.json { render :json => @settings.all}
-    end
-  end
-
-  def update
-    @setting = Setting.find(params[:id])
-    if @setting.update_attributes(params[:setting])
-      process_success
-    else
-      process_error
-    end
-  end
-end

data/test/foreman_app/app/controllers/smart_proxies/autosign_controller.rb

@@ -1,47 +0,0 @@
-require_dependency "proxy_api"
-
-class SmartProxies::AutosignController < ApplicationController
-  before_filter :find_proxy, :setup_proxy
-
-  def index
-    begin
-      autosign = @api.autosign
-    rescue => e
-      autosign = []
-      error e
-    end
-    respond_to do |format|
-      format.html { @autosign = autosign.paginate :page => params[:page], :per_page => 20 }
-      format.json {render :json => autosign }
-    end
-  end
-
-  def new
-  end
-
-  def create
-    if @api.set_autosign(params[:id])
-      process_success({:success_redirect => smart_proxy_autosign_index_path(@proxy), :object_name => 'puppet autosign entry'})
-    else
-      process_error({:redirect => smart_proxy_autosign_index_path(@proxy)})
-    end
-  end
-
-  def destroy
-    if @api.del_autosign(params[:id])
-      process_success({:success_redirect => smart_proxy_autosign_index_path(@proxy), :object_name => 'puppet autosign entry'})
-    else
-      process_error({:redirect => smart_proxy_autosign_index_path(@proxy)})
-    end
-  end
-
-  private
-
-  def find_proxy
-    @proxy = SmartProxy.find(params[:smart_proxy_id])
-  end
-
-  def setup_proxy
-    @api = ProxyAPI::Puppetca.new({:url => @proxy.url})
-  end
-end

data/test/foreman_app/app/controllers/smart_proxies/puppetca_controller.rb

@@ -1,59 +0,0 @@
-class SmartProxies::PuppetcaController < ApplicationController
-  before_filter :find_proxy
-
-  def index
-    # expire cache if forced
-    Rails.cache.delete("ca_#{@proxy.id}") if params[:expire_cache] == "true"
-
-    begin
-      certs = if params[:state].blank?
-                SmartProxies::PuppetCA.find_by_state(@proxy, "valid") + SmartProxies::PuppetCA.find_by_state(@proxy, "pending")
-              elsif params[:state] == "all"
-                SmartProxies::PuppetCA.all @proxy
-              else
-                SmartProxies::PuppetCA.find_by_state @proxy, params[:state]
-              end
-    rescue => e
-      certs = []
-      error e
-      redirect_to :back and return
-    end
-    respond_to do |format|
-      format.html do
-        begin
-          @certificates = certs.sort.paginate :page => params[:page], :per_page => params[:per_page] || 20
-        rescue => e
-          error e
-        end
-      end
-      format.json { render :json => certificates }
-    end
-  end
-
-  def update
-    cert = SmartProxies::PuppetCA.find(@proxy, params[:id])
-    if cert.sign
-      process_success({ :success_redirect => smart_proxy_puppetca_index_path(@proxy, :state => params[:state]), :object_name => cert.to_s })
-    else
-      process_error({ :redirect => smart_proxy_puppetca_index_path(@proxy) })
-    end
-  rescue
-    process_error({ :redirect => smart_proxy_puppetca_index_path(@proxy) })
-  end
-
-  def destroy
-    cert = SmartProxies::PuppetCA.find(@proxy, params[:id])
-    if cert.destroy
-      process_success({ :success_redirect => smart_proxy_puppetca_index_path(@proxy, :state => params[:state]), :object_name => cert.to_s })
-    else
-      process_error({ :redirect => smart_proxy_puppetca_index_path(@proxy) })
-    end
-  end
-
-  private
-
-  def find_proxy
-    @proxy = SmartProxy.find(params[:smart_proxy_id])
-  end
-
-end

data/test/foreman_app/app/controllers/smart_proxies_controller.rb

@@ -1,43 +0,0 @@
-class SmartProxiesController < ApplicationController
-  def index
-    respond_to do |format|
-      format.html {@proxies = SmartProxy.includes(:features).paginate :page => params[:page]}
-      format.json {render :json => SmartProxy.all}
-    end
-  end
-
-  def new
-    @proxy = SmartProxy.new
-  end
-
-  def create
-    @proxy = SmartProxy.new(params[:smart_proxy])
-    if @proxy.save
-      process_success :object => @proxy
-    else
-      process_error :object => @proxy
-    end
-  end
-
-  def edit
-    @proxy = SmartProxy.find(params[:id])
-  end
-
-  def update
-    @proxy = SmartProxy.find(params[:id])
-    if @proxy.update_attributes(params[:smart_proxy])
-      process_success :object => @proxy
-    else
-      process_error :object => @proxy
-    end
-  end
-
-  def destroy
-    @proxy = SmartProxy.find(params[:id])
-    if @proxy.destroy
-      process_success :object => @proxy
-    else
-      process_error :object => @proxy
-    end
-  end
-end

data/test/foreman_app/app/controllers/statistics_controller.rb

@@ -1,27 +0,0 @@
-class StatisticsController < ApplicationController
-
-  def index
-    @os_count    = Host.my_hosts.count_distribution :operatingsystem
-    @arch_count  = Host.my_hosts.count_distribution :architecture
-    @env_count   = Host.my_hosts.count_distribution :environment
-    @klass_count = Host.my_hosts.count_habtm "puppetclass"
-    @cpu_count   = FactValue.my_facts.count_each "processorcount"
-    @model_count = FactValue.my_facts.count_each "manufacturer"
-    @mem_size    = FactValue.my_facts.mem_average "memorysize"
-    @mem_free    = FactValue.my_facts.mem_average "memoryfree"
-    @swap_size   = FactValue.my_facts.mem_average "swapsize"
-    @swap_free   = FactValue.my_facts.mem_average "swapfree"
-    @mem_totsize = FactValue.my_facts.mem_sum "memorysize"
-    @mem_totfree = FactValue.my_facts.mem_sum "memoryfree"
-    respond_to do |format|
-      format.html
-      format.json do
-        render :json => { :statistics => { :os_count    => @os_count, :arch_count => @arch_count,
-                                           :env_count   => @env_count, :klass_count => @klass_count, :cpu_count => @cpu_count,
-                                           :model_count => @model_count, :mem_size => @mem_size, :mem_free => @mem_free, :swap_size => @swap_size,
-                                           :swap_free   => @swap_free, :mem_totsize => @mem_totsize, :mem_totfree => @mem_totfree } }
-      end
-    end
-  end
-
-end

data/test/foreman_app/app/controllers/subnets_controller.rb

@@ -1,88 +0,0 @@
-class SubnetsController < ApplicationController
-  include Foreman::Controller::AutoCompleteSearch
-
-  def index
-    values = Subnet.search_for(params[:search], :order => params[:order])
-    respond_to do |format|
-      format.html { @subnets = values.includes(:domains, :dhcp).paginate :page => params[:page] }
-      format.json { render :json => values }
-    end
-  end
-
-  def new
-    @subnet = Subnet.new
-  end
-
-  def create
-    @subnet = Subnet.new(params[:subnet])
-    if @subnet.save
-      process_success
-    else
-      process_error
-    end
-  end
-
-  def edit
-    @subnet = Subnet.find(params[:id])
-  end
-
-  def update
-    @subnet = Subnet.find(params[:id])
-    if @subnet.update_attributes(params[:subnet])
-      process_success
-    else
-      process_error
-    end
-  end
-
-  def destroy
-    @subnet = Subnet.find(params[:id])
-    if @subnet.destroy
-      process_success
-    else
-      process_error
-    end
-  end
-
-  # query our subnet dhcp proxy for an unused IP
-  def freeip
-    not_found and return unless (s=params[:subnet_id].to_i) > 0
-    organization = params[:organization_id].blank? ? nil : Organization.find(params[:organization_id])
-    location = params[:location_id].blank? ? nil : Location.find(params[:location_id])
-    Taxonomy.as_taxonomy organization, location do
-      not_found and return unless (subnet = Subnet.find(s))
-      if (ip = subnet.unused_ip(params[:host_mac]))
-        render :json => {:ip => ip}
-      else
-        # we don't want any failures if we failed to query our proxy
-        head :status => 200
-      end
-    end
-  rescue => e
-    logger.warn "Failed to query #{subnet} for free ip: #{e}"
-    head :status => 500
-  end
-
-  def import
-    proxy = SmartProxy.find(params[:smart_proxy_id])
-    @subnets = Subnet.import(proxy)
-    if @subnets.empty?
-      flash[:warning] = _("No new subnets found")
-      redirect_to :subnets
-    end
-  end
-
-  def create_multiple
-    if params[:subnets].empty?
-      return redirect_to subnets_path, :notice => _("No Subnets selected")
-    end
-
-    @subnets = Subnet.create(params[:subnets]).reject { |s| s.errors.empty? }
-    if @subnets.empty?
-      process_success(:object => @subnets, :success_msg => _("Imported Subnets"))
-    else
-      render :action => "import"
-    end
-  end
-
-end