redhat_access 2.0.0

data/app/controllers/redhat_access/api/api_controller.rb

@@ -0,0 +1,24 @@
+require_dependency "redhat_access/application_controller"
+module RedhatAccess
+  module Api
+    class ApiController < ApplicationController
+      #skip_before_filter :verify_authenticity_token, :unless => :protect_api_from_forgery?
+      #before_filter :set_default_response_format, :authorize, :add_version_header, :set_gettext_locale
+      before_filter :session_expiry, :update_activity_time
+      #around_filter :set_timezone
+
+      cache_sweeper :topbar_sweeper
+
+      respond_to :json
+
+      def http_error_response(msg,status)
+        render json: { :message => msg }, :status => status
+      end
+
+      def api_request?
+        true
+      end
+
+    end
+  end
+end

data/app/controllers/redhat_access/api/attachments_controller.rb

@@ -0,0 +1,40 @@
+require_dependency "redhat_access/application_controller"
+require_dependency "redhat_access/strata/client"
+require_dependency "redhat_access/sos_reports/generator"
+
+module RedhatAccess
+  module Api
+    class AttachmentsController < RedhatAccess::Api::ApiController
+      wrap_parameters :attach_payload, format: :json
+      def index
+        render :text => "SOS Report?checked=true",
+          :layout => false
+      end
+
+      def create
+        data = params[:attach_payload]
+        begin
+          case_number = data[:caseNum]
+          sos_file = RedhatAccess::SosReports::Generator.create_report case_number
+          strata = RedhatAccess::Strata::Client.new(data[:authToken])
+          strata.api.attachment_broker.add(case_number,
+                                           false,
+                                           sos_file,
+                                           "Attachment for case #{case_number}")
+          render :nothing => true,
+            :status => 201
+        rescue => e
+          logger.error e.backtrace
+          #logger.error "Failed to import facts for Host::Discovered: #{e}"
+          render :text => "Error attaching sos file " + e.message,
+            :layout => false ,
+            :status => 500
+        end
+      end
+
+      def api_version
+        'v1'
+      end
+    end
+  end
+end

data/app/controllers/redhat_access/api/logs_controller.rb

@@ -0,0 +1,49 @@
+require_dependency "redhat_access/application_controller"
+
+module RedhatAccess
+  module Api
+    class LogsController < RedhatAccess::Api::ApiController
+      # Use temporary implementation to show proof of ooncept in beta release
+      # In GA a more robust implementation will be used
+      #@@log_files = ['/var/log/foreman/production.log','/var/log/foreman/delayed_job.log','/var/log/foreman/jobs-startup.log']
+      @@log_files = REDHAT_ACCESS_CONFIG[:diagnostic_logs]
+
+      def index
+        #
+        # This REST hack of using index for both list and specific resource get
+        # is being forced by the current UI design
+        #
+        path = params[:path]
+        if path.nil?
+          render  :plain => get_available_logs, :layout => false
+        else
+          if is_valid_file? path
+            render :file => path, :layout => false
+          else
+            render :text => ''
+          end
+        end
+      end
+
+      def get_available_logs
+        files = @@log_files.select do |file|
+          File.exist?(file) && File.readable?(file) && File.size(file) > 0
+        end
+        files.join("\n")
+      end
+
+      def is_valid_file?  file
+        @@log_files.include?(file) && File.exist?(file) && File.readable?(file) && File.size(file) > 0
+      end
+
+
+      def permission_denied
+        render :template => "katello/common/403"
+      end
+
+      def api_version
+        'v1'
+      end
+    end
+  end
+end

data/app/controllers/redhat_access/api/machine_telemetry_api_controller.rb

@@ -0,0 +1,112 @@
+require_dependency "redhat_access/application_controller"
+require 'rest_client'
+require 'redhat_access_lib'
+require 'uri'
+
+module RedhatAccess
+  module Api
+    class MachineTelemetryApiController < TelemetryApiController
+
+      skip_before_filter :authorize
+      skip_before_filter :require_login
+      skip_before_filter :session_expiry
+      skip_before_filter :verify_authenticity_token
+      skip_before_filter :check_telemetry_enabled
+      before_filter :telemetry_auth
+      before_filter :ensure_telemetry_enabled, :only => [:proxy, :proxy_upload]
+
+      def telemetry_auth
+        authenticate_client
+        unless valid_machine_user?
+          deny_access
+        end
+      end
+
+      def ensure_telemetry_enabled
+        render_telemetry_off unless telemetry_enabled_for_uuid?(User.current.login)
+      end
+
+      def get_auth_opts()
+        if valid_machine_user?
+          get_ssl_options_for_uuid(User.current.login, nil)
+        else
+          raise(RedhatAccess::Telemetry::LookUps::RecordNotFound,'Invalid User')
+        end
+      end
+
+      def api_connection_test
+        client = get_api_client
+        res = client.call_tapi('GET', '/', nil, nil, nil)
+        Rails.logger.debug(res[:data])
+        render status: res[:code], json: {}
+      end
+
+      def proxy_upload
+        original_method  = request.method
+        original_params  = add_branch_to_params(request.query_parameters)
+        original_payload = request.request_parameters[controller_name]
+        if not params[:id] and params[:test]
+          resource = "uploads/"
+          original_payload = {:test => params[:test]}
+        else
+          resource = "uploads/#{params[:id]}"
+        end
+        if params[:file]
+          original_payload = get_file_data(params)
+        end
+        client = get_api_client
+        Rails.logger.debug("Proxy upload original_payload : #{original_payload}")
+        res = client.call_tapi(original_method, URI.escape(resource), original_params, original_payload, nil, use_subsets)
+        render status: res[:code] , json: res[:data]
+      end
+
+      def get_branch_info
+        uuid = User.current.login
+        begin
+          org = get_organization(uuid)
+          major,minor,build = get_plugin_parent_version.scan(/\d+/)
+          client_id = {:remote_leaf => uuid ,
+                       :remote_branch => get_branch_id_for_uuid(uuid),
+                       :display_name => org.name,
+                       :hostname => request.host,
+                       :product => {:type => get_plugin_parent_name,
+                                    :major_version => major,
+                                    :minor_version => minor
+                                    }
+                       }
+          render :json => client_id.to_json
+        rescue RedhatAccess::Telemetry::LookUps::RecordNotFound => e
+          http_error_response(e.message, 400)
+        end
+      end
+
+
+
+      protected
+
+      def use_subsets
+        false
+      end
+
+      def valid_machine_user?
+        if User.current && User.current.is_a?(RedhatAccess::Authentication::CertUser)
+          return true unless get_content_host(User.current.login).nil?
+          return false
+        else
+          return false
+        end
+      end
+
+      def get_http_user_agent
+        base_user_agent = super
+        client_user_agent = request.env['HTTP_USER_AGENT']
+        "#{base_user_agent};#{client_user_agent}"
+      end
+
+
+      def get_branch_id
+        get_branch_id_for_uuid(User.current.login)
+      end
+    end
+  end
+end

data/app/controllers/redhat_access/api/strata_proxy_controller.rb

@@ -0,0 +1,81 @@
+require_dependency "redhat_access/application_controller"
+require 'rest_client'
+require 'redhat_access_lib'
+require 'uri'
+
+module RedhatAccess
+  module Api
+    class StrataProxyController < TelemetryApiController
+
+      def action_permission
+        case params[:action]
+        when 'call'
+          :call
+        else
+          super
+        end
+      end
+
+      def get_auth_opts()
+        #We only support pass through basic auth @see get_api_client method
+        return {}
+      end
+
+      def index
+        render :text => "Strata Telemetry API"
+      end
+
+
+      # The method that "proxies" tapi requests over to Strata
+      def call
+        original_method  = request.method
+        original_params = request.query_parameters
+        original_payload = request.request_parameters[controller_name]
+        if request.post? && request.raw_post
+             original_payload = request.raw_post.clone
+        end
+
+        if request.put?
+           original_payload = request.body.read
+        end
+        resource = params[:path] == nil ?  "/" : params[:path]
+        if params[:file]
+          original_payload = get_file_data(params)
+        end
+        client = get_api_client
+        res = client.call_strata(original_method, URI.escape(resource), original_params, original_payload, nil)
+        #401 erros means our proxy is not configured right.
+        #Change it to 502 to distinguish with local applications 401 errors
+        resp_data = res[:data]
+        if res[:code] == 401
+          res[:code] = 502
+          resp_data = {
+            :message => 'Authentication to the Strata Service failed.'
+          }
+        end
+        render status: res[:code] , json: resp_data #.gsub('https://api.access.redhat.com','https://192.168.121.13/redhat_access/strata/')
+      end
+
+      def get_api_client
+         accept_hdr = request.headers['Accept']
+         content_hdr = request.headers['Content-Type']
+         headers = { 'accept' => accept_hdr}
+         unless content_hdr.nil?
+            headers['content-type'] = content_hdr
+         end
+         headers['Authorization'] = env['HTTP_AUTHORIZATION'] if env['HTTP_AUTHORIZATION']
+         Rails.logger.debug("User agent for telemetry is #{get_http_user_agent}")
+         strata_host = 'https://api.' + REDHAT_ACCESS_CONFIG[:strata_host]
+         return RedhatAccess::Telemetry::PortalClient.new(strata_host,
+                                                          strata_host,
+                                                          nil,
+                                                          self,
+                                                          {:logger => Rails.logger,
+                                                           :http_proxy => get_portal_http_proxy,
+                                                           :user_agent => get_http_user_agent,
+                                                           :headers => headers
+                                                          })
+       end
+    end
+  end
+end

data/app/controllers/redhat_access/api/telemetry_api_controller.rb

@@ -0,0 +1,179 @@
+require_dependency "redhat_access/application_controller"
+require 'rest_client'
+require 'redhat_access_lib'
+require 'uri'
+
+module RedhatAccess
+  module Api
+    class TelemetryApiController < RedhatAccess::Api::ApiController
+      include RedhatAccess::Authentication::ClientAuthentication
+      include RedhatAccess::Telemetry::LookUps
+
+      before_filter :check_telemetry_enabled, :only => [:proxy]
+
+      UPLOAD_HOST = REDHAT_ACCESS_CONFIG[:telemetry_upload_host]
+      API_HOST = REDHAT_ACCESS_CONFIG[:telemetry_api_host]
+      UPLOAD_URL = "#{UPLOAD_HOST}/r/insights/uploads"
+      STRATA_URL = "#{API_HOST}/r/insights"
+
+
+      def action_permission
+        case params[:action]
+        when 'proxy'
+          :proxy
+        when 'connection_status'
+          :connection_status
+        else
+          super
+        end
+      end
+
+      def check_telemetry_enabled
+        render_telemetry_off unless telemetry_enabled?(Organization.current)
+      end
+
+      def render_telemetry_off
+        http_error_response("Telemetry is not enabled for your organization",403)
+      end
+
+      def get_creds
+        # enable this once cert auth is fixed:
+        # return User
+        #return TelemetryProxyCredentials.limit(1)[0]
+      end
+
+      def get_auth_opts()
+        return get_ssl_options_for_org(Organization.current ,nil)
+      end
+
+      def index
+        render :text => "Telemetry API"
+      end
+
+
+      # # Returns an array of the machine IDs that this user has access to
+      def get_machines
+        #TODO err out if org is not selected
+        machines = get_content_hosts(Organization.current)
+        if machines.empty?
+          machines = ['NULL_SET']
+        end
+        Rails.logger.debug("Machines : #{machines}")
+        machines
+      end
+
+      def connection_status
+        client = get_api_client
+        res = client.call_tapi('GET', 'me', nil, nil, nil)
+        Rails.logger.debug(res[:data])
+        case res[:code]
+        when 200
+          resp = JSON.parse(res[:data])
+          data = {
+            :connectionStatus => 'Connected',
+            :account => resp["account_number"],
+            :company => resp["company"],
+            :orgId  => resp["ord_id"]
+          }
+          render status: res[:code] , json: data
+        when 401
+          data = {
+            :connectionStatus => 'Authentication Failure',
+            :account => 'Unknown',
+            :company => 'Unknown',
+          }
+          render status: 200 , json: data
+        else
+          data = {
+            :connectionStatus => 'Connection Failed',
+            :account => 'Unknown',
+            :company => 'Unknown',
+          }
+          render status: 200 , json: data
+        end
+      end
+
+      # The method that "proxies" tapi requests over to Strata
+      def proxy
+        original_method  = request.method
+        original_params = request.query_parameters
+        if request.user_agent and not request.user_agent.include?('redhat_access_cfme')
+           original_params  = add_branch_to_params(request.query_parameters)
+        end
+        original_payload = request.request_parameters[controller_name]
+        if request.post? && request.raw_post
+             original_payload = request.raw_post.clone
+        end
+        resource         = params[:path] == nil ?  "/" : params[:path]
+        if params[:file]
+          original_payload = get_file_data(params)
+        end
+        client = get_api_client
+        res = client.call_tapi(original_method, URI.escape(resource), original_params, original_payload, nil, use_subsets)
+        #401 erros means our proxy is not configured right.
+        #Change it to 502 to distinguish with local applications 401 errors
+        resp_data = res[:data]
+        if res[:code] == 401
+          res[:code] = 502
+          resp_data = {
+            :message => 'Authentication to the Insights Service failed.',
+            :headers => {}
+          }
+        end
+        if original_params && original_params["accept"] && original_params["accept"] = "csv"
+          send_data resp_data, type: 'text/csv; charset=utf-8', :filename => "insights_report.csv"
+        else
+          if  resp_data.headers && resp_data.headers[:x_resource_count]
+               response.headers['X-Resource-Count'] = resp_data.headers[:x_resource_count]
+          end
+          render status: res[:code] , json: resp_data
+        end
+      end
+
+      protected
+
+      def use_subsets
+        true
+      end
+
+      def get_file_data params
+        return {
+          :file => params[:file],
+          :filename => params[:file].original_filename
+        }
+      end
+
+      def add_branch_to_params(params)
+        if params.nil?
+          params = {}
+        end
+        params[:branch_id] = get_branch_id
+        Rails.logger.debug{"Request parameters for telemetry request #{params}"}
+        params
+      end
+
+      def get_http_user_agent
+        "#{get_plugin_parent_name}/#{get_plugin_parent_version};#{get_rha_plugin_name}/#{get_rha_plugin_version}"
+      end
+
+      def get_branch_id
+        get_branch_id_for_org(Organization.current)
+      end
+
+      def get_api_client
+        Rails.logger.debug("User agent for telemetry is #{get_http_user_agent}")
+        return RedhatAccess::Telemetry::PortalClient.new(UPLOAD_URL,STRATA_URL,
+                                                         get_creds,
+                                                         self,
+                                                         {:logger => Rails.logger,
+                                                          :http_proxy => get_portal_http_proxy,
+                                                          :user_agent => get_http_user_agent})
+      end
+
+      def api_version
+        'v1'
+      end
+
+    end
+  end
+end

data/app/controllers/redhat_access/application_controller.rb

@@ -0,0 +1,2 @@
+class RedhatAccess::ApplicationController < ApplicationController
+end

data/app/controllers/redhat_access/cases_controller.rb

@@ -0,0 +1,14 @@
+require_dependency "redhat_access/application_controller"
+
+module RedhatAccess
+  class CasesController < ApplicationController
+    def create
+      redirect_to '/redhat_access/#/case/new'
+    end
+
+    def index
+      redirect_to '/redhat_access/#/case/list'
+    end
+
+  end
+end

data/app/controllers/redhat_access/configuration_controller.rb

@@ -0,0 +1,21 @@
+require_dependency "redhat_access/application_controller"
+require_dependency "redhat_access/version"
+
+module RedhatAccess
+  class ConfigurationController < ApplicationController
+    def index
+      strata_host = REDHAT_ACCESS_CONFIG[:strata_host]
+      if strata_host.nil?
+        strata_host = 'access.redhat.com'
+      end
+      client_id = "foreman_plugin_#{REDHAT_ACCESS_CONFIG[:deployment]}_#{RedhatAccess::VERSION}"
+      render :json => { :strataHostName => strata_host,:strataClientId => client_id }.to_json,
+        :layout => false
+    end
+
+    def api_request?
+      true
+    end
+
+  end
+end

data/app/controllers/redhat_access/log_viewer_controller.rb

@@ -0,0 +1,9 @@
+require_dependency "redhat_access/application_controller"
+
+module RedhatAccess
+  class LogViewerController < ApplicationController
+    def index
+      redirect_to '/redhat_access/#/logviewer'
+    end
+  end
+end

data/app/controllers/redhat_access/redhat_access_controller.rb

@@ -0,0 +1,8 @@
+require_dependency "redhat_access/application_controller"
+
+module RedhatAccess
+  class RedhatAccessController < RedhatAccess::ApplicationController
+    def index
+    end
+  end
+end

data/app/controllers/redhat_access/search_controller.rb

@@ -0,0 +1,9 @@
+require_dependency "redhat_access/application_controller"
+
+module RedhatAccess
+  class SearchController < ApplicationController
+    def index
+      redirect_to '/redhat_access/#/search'
+    end
+  end
+end

data/app/controllers/redhat_access/strata_credentials_controller.rb

@@ -0,0 +1,48 @@
+require_dependency "redhat_access/application_controller"
+
+module RedhatAccess
+  class StrataCredentialsController < ApplicationController
+
+    def index
+      if TelemetryProxyCredentials.count == 0
+        render json: { :status => 'not_found' }, status: 404
+        return
+      end
+
+      creds = TelemetryProxyCredentials.limit(1)[0]
+      render json: { :status => 'success', :username => creds.username }
+    end
+
+    def destroy
+      TelemetryProxyCredentials.delete_all
+      render json: { :status => 'success' }
+    end
+
+    def create
+      if TelemetryProxyCredentials.count != 0
+        TelemetryProxyCredentials.delete_all
+      end
+
+      creds = TelemetryProxyCredentials.new
+
+      data = params[:strata_credential]
+      username = data[:username]
+      password = data[:password]
+
+      if not username.present? && username.length > 1
+        render json: { :status => 'error', :message => 'username missing or too short' }, status: 400
+        return
+      end
+
+      if not password.present? && password.length > 4
+        render json: { :status => 'error', :message => 'password missing or too short' }, status: 400
+        return
+      end
+
+      creds.attributes = { username: username, password: password }
+      creds.save
+
+      render json: { :status => 'success', :message => 'credentials saved' }
+    end
+  end
+end

data/app/controllers/redhat_access/telemetry_configurations_controller.rb

@@ -0,0 +1,38 @@
+require_dependency "redhat_access/application_controller"
+
+module RedhatAccess
+  class TelemetryConfigurationsController < ApplicationController
+    include RedhatAccess::Telemetry::LookUps
+    def show
+       #TODO require current ORG
+      conf = get_telemetry_config(Organization.current)
+      render json:  conf.to_json(:except => [ :id, :created_at, :portal_password ,:updated_at])
+    end
+
+    def update
+      #TODO require current ORG
+      conf = get_telemetry_config(Organization.current)
+      if conf
+        begin
+          if conf.update_attributes(telemetry_configuration_params)
+          render json: {:message => "config updated"}
+        else
+          render json: {:error=>"Invalid parameters"}.to_json, status: 400
+        end
+          rescue=>e
+          Rails.logger.info(e)
+          render json: {:error=>"Error processing update"}.to_json, status: 500
+        end
+      else
+        render json: {:error=>"Configurationnotfound"}.to_json, status: 404
+      end
+    end
+
+    private
+
+    def telemetry_configuration_params
+      params.require(:telemetry_configuration).permit(:enable_telemetry, :portal_password, :portal_user, :organization_id, :email)
+    end
+
+  end
+end

data/app/controllers/redhat_access/telemetry_controller.rb

@@ -0,0 +1,6 @@
+require_dependency "redhat_access/application_controller"
+
+module RedhatAccess
+  class TelemetryController < ApplicationController
+  end
+end

data/app/helpers/redhat_access/analytics_dashboard_helper.rb

@@ -0,0 +1,13 @@
+module RedhatAccess
+  module AnalyticsDashboardHelper
+    include RedhatAccess::Telemetry::LookUps
+
+    def help_path?
+    	request.path == '/redhat_access/insights/help'
+    end
+
+    def manage_path?
+      request.path == '/redhat_access/insights/manage'
+    end
+  end
+end

data/app/helpers/redhat_access/application_helper.rb

@@ -0,0 +1,4 @@
+module RedhatAccess
+  module ApplicationHelper
+  end
+end

data/app/helpers/redhat_access/attachments_helper.rb

@@ -0,0 +1,4 @@
+module RedhatAccess
+  module AttachmentsHelper
+  end
+end

data/app/helpers/redhat_access/cases_helper.rb

@@ -0,0 +1,4 @@
+module RedhatAccess
+  module CasesHelper
+  end
+end