foreman_salt 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce1b4cb399d2e977121144ef5e214df9cfb96c14
-  data.tar.gz: 7ae9a7bfe423ed887ae6b6a4b553bebc2a493197
+  metadata.gz: 65b92f3373cea9c5f4be875edbae423c369ca7bb
+  data.tar.gz: 85a03b34a72fa72659b5ab3ebf5f7428a463c7bf
 SHA512:
-  metadata.gz: 642dccb0a0683cee2885bcf2a9446c13687fb8af7685537d1b2db45532c81c59476fb326e91c1e1144ccb0882f236ee18497b3fd64d580aaf68de4891e1070e0
-  data.tar.gz: 3cc3ab238b85f88d1c60f8bf6e8c29985de38a28ebfdadb58e010ddf25c6458c8d69b9f8c354b6aeebe8ba6690f33482f5cf04c02d264f7e913363fd5e9de40f
+  metadata.gz: bbbf937cb431c0d96205def06cc7e069953ca15eba4548dd3ae09edb7e4515fe10ddbecdf8ee4edc3a082508dd31005fc153f501901a6885928c5747cfed1319
+  data.tar.gz: 40ed6313ddeca1b424eed17583331d32cc2bc858f37e77a046e71be6530eb66dc1bfb9f57c7079ce50f3aba18cf57ad59e3d808865a3ca05e0011fbcf8a31a0a

data/Rakefile

@@ -23,8 +23,6 @@ end
 APP_RAKEFILE = File.expand_path('../test/dummy/Rakefile', __FILE__)
 load 'rails/tasks/engine.rake'
 
-
-
 Bundler::GemHelper.install_tasks
 
 require 'rake/testtask'
@@ -36,5 +34,4 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-
 task :default => :test

data/app/controllers/foreman_salt/api/v2/base_controller.rb

@@ -0,0 +1,13 @@
+module ForemanSalt
+  module Api
+    module V2
+      class BaseController < ::Api::V2::BaseController
+        resource_description do
+          resource_id 'foreman_salt'
+          api_version 'v2'
+          api_base_url '/salt/api'
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_salt/api/v2/jobs_controller.rb

@@ -3,16 +3,9 @@ require 'uri'
 module ForemanSalt
   module Api
     module V2
-      class JobsController < ::Api::V2::BaseController
-        include ::Api::Version2
+      class JobsController < ::ForemanSalt::Api::V2::BaseController
         include ::Foreman::Controller::SmartProxyAuth
-        include ForemanSalt::Concerns::SmartProxyAuthExtensions
-
-        add_puppetmaster_filters :upload
-
-        resource_description do
-          api_base_url '/salt/api'
-        end
+        add_smart_proxy_filters :upload, :features => 'Salt'
 
         def_param_group :job do
           param :job, Hash, :required => true, :action_aware => true do
@@ -22,7 +15,7 @@ module ForemanSalt
           end
         end
 
-        api :POST, '/upload/', N_('Upload a Job')
+        api :POST, '/upload', N_('Upload a Job')
         param_group :job, :as => :upload
 
         def upload
@@ -32,16 +25,16 @@ module ForemanSalt
             # Dynflowize the action if we can, otherwise we'll do it live
             if defined? ForemanTasks
               task = ForemanTasks.async_task(::Actions::ForemanSalt::ReportImport, params[:job], detected_proxy.try(:id))
-              render :json => {:task_id => task.id}
+              render :json => { :task_id => task.id }
             else
               reports = ForemanSalt::ReportImporter.import(params[:job][:result], detected_proxy.try(:id))
-              render :json => {:message => "Imported #{reports.count} new reports."}
+              render :json => { :message => "Imported #{reports.count} new reports." }
             end
           else
-            render :json => {:message => 'Unsupported function'}, :status => :unprocessable_entity
+            render :json => { :message => 'Unsupported function' }, :status => :unprocessable_entity
           end
         rescue ::Foreman::Exception => e
-          render :json => {:message => e.to_s}, :status => :unprocessable_entity
+          render :json => { :message => e.to_s }, :status => :unprocessable_entity
         end
 
         def resource_class
@@ -54,12 +47,11 @@ module ForemanSalt
           case params[:action]
             when 'upload'
               :create
-          else
-            super
+            else
+              super
           end
         end
       end
     end
   end
 end
-

data/app/controllers/foreman_salt/api/v2/salt_autosign_controller.rb

@@ -0,0 +1,64 @@
+require 'ostruct'
+
+module ForemanSalt
+  module Api
+    module V2
+      class SaltAutosignController < ::ForemanSalt::Api::V2::BaseController
+        before_filter :find_proxy, :setup_proxy
+
+        api :GET, '/salt_autosign/:smart_proxy_id', N_('List all autosign records')
+        param :smart_proxy_id, :identifier_dottable, :required => true
+        def index
+          @salt_autosigns = all_autosign
+        end
+
+        api :POST, '/salt_autosign/:smart_proxy_id', N_('Create an autosign record')
+        param :smart_proxy_id, :identifier_dottable, :required => true
+        param :record, String, :required => true, :desc => N_('Autosign record')
+        def create
+          @api.autosign_create params[:record]
+          @salt_autosign = { :record => params[:record] }
+        end
+
+        api :DELETE, '/salt_autosign/:smart_proxy_id/:record', N_('Delete an autosign record')
+        param :smart_proxy_id, :identifier_dottable, :required => true
+        param :record, String, :required => true, :desc => N_('Autosign record')
+        def destroy
+          @api.autosign_remove params[:record]
+          render :json => { root_node_name => _('Record deleted.') }
+        end
+
+        def metadata_total
+          @total ||= all_autosign.count
+        end
+
+        def metadata_subtotal
+          metadata_total
+        end
+
+        def metadata_page
+          1
+        end
+
+        def metadata_per_page
+          metadata_total
+        end
+
+        private
+
+        def all_autosign
+          @_autosigns ||= @api.autosign_list.map { |record| OpenStruct.new(:record => record) }
+        end
+
+        def find_proxy
+          @proxy = ::SmartProxy.find(params[:smart_proxy_id])
+          not_found unless @proxy
+        end
+
+        def setup_proxy
+          @api = ProxyAPI::Salt.new(:url => @proxy.url)
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_salt/api/v2/salt_environments_controller.rb

@@ -0,0 +1,46 @@
+module ForemanSalt
+  module Api
+    module V2
+      class SaltEnvironmentsController < ::ForemanSalt::Api::V2::BaseController
+        before_filter :find_resource, :except => [:index, :create]
+
+        api :GET, '/salt_environments', N_('List all Salt environments')
+        def index
+          @salt_environments = resource_scope_for_index
+        end
+
+        api :GET, '/salt_environments/:id/', N_('Show a Salt environment')
+        param :id, :identifier_dottable, :required => true
+        def show
+        end
+
+        def_param_group :environment do
+          param :environment, Hash, :required => true, :action_aware => true do
+            param :name, String, :required => true
+          end
+        end
+
+        api :POST, '/salt_environments', N_('Create a Salt environment')
+        param_group :environment, :as => :create
+        def create
+          @salt_environment = SaltEnvironment.new(params[:environment])
+          process_response @salt_environment.save
+        end
+
+        api :DELETE, '/salt_environments/:id/', N_('Destroy a Salt environment')
+        param :id, :identifier, :required => true
+        def destroy
+          process_response @salt_environment.destroy
+        end
+
+        def controller_permission
+          'salt_environments'
+        end
+
+        def resource_class
+          ForemanSalt::SaltEnvironment
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_salt/api/v2/salt_keys_controller.rb

@@ -0,0 +1,79 @@
+module ForemanSalt
+  module Api
+    module V2
+      class SaltKeysController < ::ForemanSalt::Api::V2::BaseController
+        before_filter :find_proxy
+        before_filter :find_key, :only => [:update, :destroy]
+
+        api :GET, '/salt_keys/:smart_proxy_id', N_('List all Salt keys')
+        param :smart_proxy_id, :identifier_dottable, :required => true
+        def index
+          @salt_keys = all_keys
+        end
+
+        def_param_group :key do
+          param :smart_proxy_id, :identifier_dottable, :required => true
+          param :name, String, :required => true, :desc => N_('FQDN of host that key belongs to')
+        end
+
+        api :PUT, '/salt_keys/:smart_proxy_id/:name', N_('Update a Salt Key')
+        param :name, :identifier_dottable, :required => true
+        param :smart_proxy_id, :identifier_dottable, :required => true
+        param :state, String, :required => true, :desc => N_('State can be "accepted" or "rejected"')
+        def update
+          case params[:key][:state]
+          when 'accepted'
+            @key.accept
+          when 'rejected'
+            @key.reject
+          end
+
+          @salt_key = find_key(@key.name)
+        end
+
+        api :DELETE, '/salt_keys/:smart_proxy_id/:name', N_('Delete a Salt Key')
+        param_group :key, :as => :destroy
+        def destroy
+          if @key.delete
+            message = 'Key successfully deleted.'
+          else
+            message = 'Unable to delete key.'
+          end
+          render :json => { root_node_name => message }
+        end
+
+        def metadata_total
+          @total ||= all_keys.count
+        end
+
+        def metadata_subtotal
+          metadata_total
+        end
+
+        def metadata_page
+          1
+        end
+
+        def metadata_per_page
+          metadata_total
+        end
+
+        private
+
+        def all_keys
+          @_keys ||= SmartProxies::SaltKeys.all(@proxy)
+        end
+
+        def find_proxy
+          @proxy = ::SmartProxy.find(params[:smart_proxy_id])
+          not_found unless @proxy
+        end
+
+        def find_key(name = params[:name])
+          @key = SmartProxies::SaltKeys.find(@proxy, name)
+          @key || not_found
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_salt/api/v2/salt_minions_controller.rb

@@ -0,0 +1,44 @@
+module ForemanSalt
+  module Api
+    module V2
+      class SaltMinionsController < ::ForemanSalt::Api::V2::BaseController
+        before_filter :find_resource, :except => [:index]
+
+        api :GET, '/salt_minions', N_('List all Salt Minions')
+        def index
+          @salt_minions = resource_scope_for_index
+        end
+
+        api :GET, '/salt_minions/:id', N_('Show a minion')
+        param :id, :identifier_dottable, :required => true
+        def show
+          @salt_states = @salt_minion.salt_modules
+        end
+
+        def_param_group :minion do
+          param :minion, Hash, :required => true, :action_aware => true do
+            param :salt_environment_id, :number, :desc => N_('Salt environment ID')
+            param :salt_proxy_id, :number, :desc => N_('ID of Salt Proxy')
+            param :salt_state_ids, Array, :desc => N_('Array of State ids')
+          end
+        end
+
+        api :PUT, '/salt_minions/:id/', N_('Update a minion')
+        param :id, :identifier_dottable, :required => true
+        param_group :minion
+        def update
+          params[:minion][:salt_module_ids] = params[:minion].delete(:salt_state_ids)
+          process_response @salt_minion.update_attributes(params[:minion])
+        end
+
+        def controller_permission
+          'hosts'
+        end
+
+        def resource_class
+          Host
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_salt/api/v2/salt_states_controller.rb

@@ -0,0 +1,46 @@
+module ForemanSalt
+  module Api
+    module V2
+      class SaltStatesController < ::ForemanSalt::Api::V2::BaseController
+        before_filter :find_resource, :except => [:index, :create]
+
+        api :GET, '/salt_states', N_('List all Salt states')
+        def index
+          @salt_states = resource_scope_for_index
+        end
+
+        api :GET, '/salt_states/:id/', N_('Show a state')
+        param :id, :identifier_dottable, :required => true
+        def show
+        end
+
+        def_param_group :state do
+          param :state, Hash, :required => true, :action_aware => true do
+            param :name, String, :required => true, :desc => N_('Name of the Salt state')
+          end
+        end
+
+        api :POST, '/salt_states', N_('Create a state')
+        param_group :state, :as => :create
+        def create
+          @salt_state = SaltModule.new(params[:state])
+          process_response @salt_state.save
+        end
+
+        api :DELETE, '/salt_states/:id/', N_('Destroy a state')
+        param :id, :identifier_dottable, :required => true
+        def destroy
+          process_response @salt_state.destroy
+        end
+
+        def controller_permission
+          'salt_modules'
+        end
+
+        def resource_class
+          ForemanSalt::SaltModule
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_salt/application_controller.rb

@@ -1,6 +1,5 @@
 module ForemanSalt
   class ApplicationController < ::ApplicationController
-
     def resource_class
       "ForemanSalt::#{controller_name.singularize.classify}".constantize
     end

data/app/controllers/foreman_salt/concerns/hosts_controller_extensions.rb

@@ -4,40 +4,10 @@ module ForemanSalt
       extend ActiveSupport::Concern
 
       included do
-        alias_method :find_resource_salt, :find_resource
-        before_filter :find_resource_salt, :only => [:saltrun]
-        alias_method_chain :action_permission, :salt_run
         alias_method_chain :load_vars_for_ajax, :salt_modules
         alias_method_chain :process_hostgroup, :salt_modules
       end
 
-      def saltrun
-        if @host.saltrun!
-          notice _('Successfully executed, check log files for more details')
-        else
-          error @host.errors[:base].to_sentence
-        end
-        redirect_to host_path(@host)
-      end
-
-      def salt_external_node
-        begin
-          @host = resource_base.find(params[:name])
-          enc = {}
-          env = @host.salt_environment.blank? ? 'base' : @host.salt_environment.name
-          enc['classes'] = @host.salt_modules.any? ? @host.salt_modules.map(&:name) : []
-          enc['parameters'] = @host.info['parameters']
-          enc['environment'] = env
-          respond_to do |format|
-            format.html { render :text => "<pre>#{ERB::Util.html_escape(enc.to_yaml)}</pre>" }
-            format.yml  { render :text => enc.to_yaml }
-          end
-        rescue
-          logger.warn "Failed to generate external nodes for #{@host} with #{$!}"
-          render :text => _('Unable to generate output, Check log files\n'), :status => 412 and return
-        end
-      end
-
       def process_hostgroup_with_salt_modules
         @hostgroup = Hostgroup.find(params[:host][:hostgroup_id]) if params[:host][:hostgroup_id].to_i > 0
         return head(:not_found) unless @hostgroup
@@ -49,17 +19,6 @@ module ForemanSalt
 
       private
 
-      def action_permission_with_salt_run
-        case params[:action]
-          when 'saltrun'
-            :saltrun
-          when 'salt_external_node'
-            :view
-          else
-            action_permission_without_salt_run
-        end
-      end
-
       def load_vars_for_ajax_with_salt_modules
         return unless @host
         @salt_modules           = @host.salt_modules

data/app/controllers/foreman_salt/minions_controller.rb

@@ -0,0 +1,54 @@
+module ForemanSalt
+  class MinionsController < ::ForemanSalt::ApplicationController
+    include ::Foreman::Controller::SmartProxyAuth
+
+    before_filter :find_resource, :only => [:node, :run]
+    add_smart_proxy_filters :node, :features => 'Salt'
+
+    def node
+      enc = {}
+      env = @minion.salt_environment.blank? ? 'base' : @minion.salt_environment.name
+      enc['classes'] = @minion.salt_modules.any? ? @minion.salt_modules.map(&:name) : []
+
+      pillars = @minion.info['parameters']
+      enc['parameters'] = Setting[:salt_namespace_pillars] ? { 'foreman' => pillars } : pillars
+
+      enc['environment'] = env
+      respond_to do |format|
+        format.html { render :text => "<pre>#{ERB::Util.html_escape(enc.to_yaml)}</pre>" }
+        format.yml  { render :text => enc.to_yaml }
+      end
+    rescue
+      logger.warn "Failed to generate external nodes for #{@minion} with #{$ERROR_INFO}"
+      render :text => _('Unable to generate output, Check log files\n'), :status => 412 and return
+    end
+
+    def run
+      if @minion.saltrun!
+        notice _('Successfully executed, check log files for more details')
+      else
+        error @minion.errors[:base].to_sentence
+      end
+      redirect_to host_path(@minion)
+    end
+
+    def action_permission
+      case params[:action]
+        when 'run'
+          :saltrun
+        when 'node'
+          :view
+        else
+          super
+      end
+    end
+
+    def controller_permission
+      'hosts'
+    end
+
+    def resource_class
+      Host
+    end
+  end
+end

data/app/controllers/foreman_salt/salt_autosign_controller.rb

@@ -1,6 +1,5 @@
 module ForemanSalt
-  class SaltAutosignController < ApplicationController
-
+  class SaltAutosignController < ::ForemanSalt::ApplicationController
     def index
       setup
       autosign = @api.autosign_list
@@ -15,10 +14,10 @@ module ForemanSalt
       setup
 
       if @api.autosign_create(params[:id])
-        process_success({:success_redirect => hash_for_smart_proxy_salt_autosign_index_path, :success_msg => _("Autosign created for #{params[:id]}"),
-                         :object_name => params[:id]})
+        process_success(:success_redirect => hash_for_smart_proxy_salt_autosign_index_path, :success_msg => _("Autosign created for #{params[:id]}"),
+                        :object_name => params[:id])
       else
-        process_error({:redirect => hash_for_smart_proxy_salt_autosign_index_path})
+        process_error(:redirect => hash_for_smart_proxy_salt_autosign_index_path)
       end
     end
 
@@ -26,10 +25,10 @@ module ForemanSalt
       setup
 
       if @api.autosign_remove(params[:id])
-        process_success({:success_redirect => hash_for_smart_proxy_salt_autosign_index_path, :success_msg => _("Autosign deleted for #{params[:id]}"),
-                          :object_name => params[:id]})
+        process_success(:success_redirect => hash_for_smart_proxy_salt_autosign_index_path, :success_msg => _("Autosign deleted for #{params[:id]}"),
+                        :object_name => params[:id])
       else
-        process_error({:redirect => hash_for_smart_proxy_salt_autosign_index_path})
+        process_error(:redirect => hash_for_smart_proxy_salt_autosign_index_path)
       end
     end
 
@@ -37,7 +36,7 @@ module ForemanSalt
 
     def setup
       @proxy = SmartProxy.authorized(:view_smart_proxies_salt_autosign).find(params[:smart_proxy_id])
-      @api = ProxyAPI::Salt.new({:url => @proxy.url})
+      @api = ProxyAPI::Salt.new(:url => @proxy.url)
     end
   end
 end

data/app/controllers/foreman_salt/salt_environments_controller.rb

@@ -1,5 +1,5 @@
 module ForemanSalt
-  class SaltEnvironmentsController < ApplicationController
+  class SaltEnvironmentsController < ::ForemanSalt::ApplicationController
     include Foreman::Controller::AutoCompleteSearch
 
     before_filter :find_resource, :only => [:edit, :update, :destroy]

data/app/controllers/foreman_salt/salt_keys_controller.rb

@@ -1,6 +1,5 @@
 module ForemanSalt
-  class SaltKeysController < ApplicationController
-
+  class SaltKeysController < ::ForemanSalt::ApplicationController
     def index
       @proxy = find_proxy
 
@@ -17,10 +16,10 @@ module ForemanSalt
       @proxy = find_proxy(:edit_smart_proxies_salt_keys)
       key = SmartProxies::SaltKeys.find(@proxy, params[:salt_key_id])
       if key.accept
-        process_success({:success_redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true),
-                         :success_msg => _("Key accepted for #{key}"), :object_name => key.to_s})
+        process_success(:success_redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true),
+                        :success_msg => _("Key accepted for #{key}"), :object_name => key.to_s)
       else
-        process_error({:redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true)})
+        process_error(:redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true))
       end
     end
 
@@ -28,10 +27,10 @@ module ForemanSalt
       @proxy = find_proxy(:edit_smart_proxies_salt_keys)
       key = SmartProxies::SaltKeys.find(@proxy, params[:salt_key_id])
       if key.reject
-        process_success({:success_redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true),
-                         :success_msg => _("Key rejected for #{key}"), :object_name => key.to_s})
+        process_success(:success_redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true),
+                        :success_msg => _("Key rejected for #{key}"), :object_name => key.to_s)
       else
-        process_error({:redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true)})
+        process_error(:redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true))
       end
     end
 
@@ -39,10 +38,10 @@ module ForemanSalt
       @proxy = find_proxy(:destroy_smart_proxies_salt_keys)
       key = SmartProxies::SaltKeys.find(@proxy, params[:id])
       if key.delete
-        process_success({:success_redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true),
-                         :success_msg => _("Key deleted for #{key}"), :object_name => key.to_s})
+        process_success(:success_redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true),
+                        :success_msg => _("Key deleted for #{key}"), :object_name => key.to_s)
       else
-        process_error({:redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true)})
+        process_error(:redirect => hash_for_smart_proxy_salt_keys_path(:state => params[:state], :expire_cache => true))
       end
     end
 

data/app/controllers/foreman_salt/salt_modules_controller.rb

@@ -1,5 +1,5 @@
 module ForemanSalt
-  class SaltModulesController < ApplicationController
+  class SaltModulesController < ::ForemanSalt::ApplicationController
     include Foreman::Controller::AutoCompleteSearch
 
     before_filter :find_resource, :only => [:edit, :update, :destroy]

data/app/helpers/concerns/foreman_salt/hosts_helper_extensions.rb

@@ -9,20 +9,20 @@ module ForemanSalt
 
     def show_appropriate_host_buttons_with_salt(host)
       (show_appropriate_host_buttons_without_salt(host) +
-         [(link_to_if_authorized(_('Salt ENC'), {:controller => :hosts, :action => :salt_external_node, :name => host},
-         :title => _('Salt external nodes YAML dump'), :class => 'btn btn-default') unless host.salt_master.blank?)]).flatten.compact
+         [(link_to_if_authorized(_('Salt ENC'), { :controller => :'foreman_salt/minions', :action => :node, :id => host },
+                                 :title => _('Salt external nodes YAML dump'), :class => 'btn btn-default') unless host.salt_master.blank?)]).flatten.compact
     end
 
     def host_title_actions_with_salt_run(host)
-        title_actions(
-          button_group(
-            if host.try(:salt_proxy)
-              link_to_if_authorized(_('Run Salt'), {:controller => :hosts, :action => :saltrun, :id => @host},
-                                    :title => _('Trigger a state.highstate run on a node'))
-            end
-          )
+      title_actions(
+        button_group(
+          if host.try(:salt_proxy)
+            link_to_if_authorized(_('Run Salt'), { :controller => :'foreman_salt/minions', :action => :run, :id => host },
+                                  :title => _('Trigger a state.highstate run on a node'))
+          end
         )
-        host_title_actions_without_salt_run(host)
+      )
+      host_title_actions_without_salt_run(host)
     end
   end
 end

data/app/helpers/concerns/foreman_salt/smart_proxies_helper_extensions.rb

@@ -10,11 +10,11 @@ module ForemanSalt
       salt = proxy.features.detect { |feature| feature.name == 'Salt' }
       [
         if salt
-          display_link_if_authorized(_('Salt Keys'), {:controller => 'foreman_salt/salt_keys', :action => 'index', :smart_proxy_id => proxy})
+          display_link_if_authorized(_('Salt Keys'), :controller => 'foreman_salt/salt_keys', :action => 'index', :smart_proxy_id => proxy)
         end,
 
         if salt
-          display_link_if_authorized(_('Salt Autosign'), {:controller => 'foreman_salt/salt_autosign', :action => 'index', :smart_proxy_id => proxy})
+          display_link_if_authorized(_('Salt Autosign'), :controller => 'foreman_salt/salt_autosign', :action => 'index', :smart_proxy_id => proxy)
         end
       ] + proxy_actions_without_salt_proxy(proxy, authorizer)
     end