brpm_content 0.1.16

data/modules/framework/bin/event_handler

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'torquebox'
+require 'torquebox-messaging'
+require 'xmlsimple'
+require "brpm_script_executor"
+
+BrpmAuto.initialize_logger(ENV["EVENT_HANDLER_LOG_FILE"])
+
+host = ENV["EVENT_HANDLER_BRPM_HOST"]
+port = ENV["EVENT_HANDLER_MESSAGING_PORT"]
+username = ENV["EVENT_HANDLER_MESSAGING_USERNAME"]
+password = ENV["EVENT_HANDLER_MESSAGING_PASSWORD"]
+process_event_script = ENV["EVENT_HANDLER_PROCESS_EVENT_SCRIPT"]
+
+require process_event_script
+
+class MessagingProcessor < TorqueBox::Messaging::MessageProcessor
+
+  MESSAGING_PATH = '/topics/messaging/brpm_event_queue'
+
+  def initialize(host, port, username, password)
+    BrpmAuto.log "Initializing the message processor..."
+    @destination = TorqueBox::Messaging::Topic.new(
+        MESSAGING_PATH,
+        :host => host,
+        :port => port,
+        :username => username,
+        :password => password
+    )
+  end
+
+  def run
+    begin
+      xml = "<root>#{@destination.receive}</root>"
+
+      BrpmAuto.log "Processing new event..."
+      BrpmAuto.log xml if ENV["EVENT_HANDLER_LOG_EVENT"]=="1"
+
+      event = XmlSimple.xml_in(xml)
+
+      process_event(event)
+
+    rescue Exception => e
+      BrpmAuto.log_error(e)
+      BrpmAuto.log e.backtrace.join("\n\t")
+    end
+  end
+end
+
+begin
+  consumer = MessagingProcessor.new(host, port, username, password)
+  BrpmAuto.log "Starting to listen for events ..."
+  loop do
+    consumer.run
+  end
+
+rescue Exception => e
+  BrpmAuto.log_error(e)
+  BrpmAuto.log e.backtrace.join("\n\t")
+
+  raise e
+end

data/modules/framework/bin/webhook_receiver

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'json'
+require 'rest-client'
+require 'webrick'
+require "brpm_script_executor"
+
+BrpmAuto.initialize_logger(ENV["WEBHOOK_RECEIVER_LOG_FILE"])
+
+port = ENV["WEBHOOK_RECEIVER_PORT"]
+mount_point = "/#{ENV["WEBHOOK_RECEIVER_MOUNT_POINT"]}"
+process_event_script = ENV["WEBHOOK_RECEIVER_PROCESS_EVENT_SCRIPT"]
+
+require process_event_script
+
+class EventProcessor < WEBrick::HTTPServlet::AbstractServlet
+  def do_POST(request, response)
+    begin
+      event = JSON.parse(request.body)
+
+      BrpmAuto.log "Processing new event..."
+      process_event(event)
+
+      response.status = 200
+      response['Content-Type'] = "text/plain"
+      response.body = "OK"
+    rescue Exception => e
+      BrpmAuto.log_error(e)
+      BrpmAuto.log e.backtrace.join("\n\t")
+    end
+  end
+end
+
+begin
+  server = WEBrick::HTTPServer.new(:Port => port)
+  server.mount mount_point, EventProcessor
+
+  trap("INT") {
+    server.shutdown
+  }
+
+  BrpmAuto.log "Starting the server..."
+  server.start
+rescue Exception => e
+  BrpmAuto.log_error(e)
+  BrpmAuto.log e.backtrace.join("\n\t")
+
+  raise e
+end

data/modules/framework/brpm_auto.rb

@@ -0,0 +1,307 @@
+require "bundler"
+require "yaml"
+
+class BrpmAuto
+  private_class_method :new
+
+  class << self
+    attr_reader :config
+    attr_reader :version
+    attr_reader :logger
+    attr_reader :params
+    attr_reader :request_params
+    attr_reader :all_params
+    attr_reader :integration_settings
+
+    attr_reader :framework_root_path
+
+    attr_reader :gems_root_path
+    attr_reader :gemfile_lock
+
+    attr_reader :modules_root_path
+    attr_reader :external_modules_root_path
+
+    def init
+      @config = get_config
+      @version = @config["version"]
+
+      @framework_root_path = File.expand_path("#{File.dirname(__FILE__)}")
+
+      @gems_root_path = get_gems_root_path
+
+      @modules_root_path = File.expand_path("#{@framework_root_path}/..")
+      @external_modules_root_path = File.expand_path("#{@modules_root_path}/../../modules")
+
+      require_relative "lib/logging/brpm_logger"
+
+      require_libs_no_file_logging "#{@modules_root_path}/framework"
+
+      self.extend Utilities
+    end
+
+    def setup(params = {})
+      @params = Params.new(params)
+
+      load_server_params
+      load_customer_include_file
+
+      if @params.run_from_brpm
+        @logger = BrpmLogger.new
+        @request_params = RequestParams.new_for_request(@params.automation_results_dir, @params.application, @params.request_id)
+      else
+        initialize_logger(@params.log_file, @params.also_log_to_console)
+        initialize_request_params(@params.output_dir)
+      end
+
+      @all_params = AllParams.new(@params, @request_params)
+
+      if @params["SS_integration_dns"]
+        @integration_settings = IntegrationSettings.new(
+            @params["SS_integration_dns"],
+            @params["SS_integration_username"],
+            @params["SS_integration_password"],
+            @params["SS_integration_details"],
+            @params["SS_project_server"],
+            @params["SS_project_server_id"]
+        )
+      elsif defined?(SS_integration_dns)
+        @integration_settings = IntegrationSettings.new(
+            SS_integration_dns,
+            SS_integration_username,
+            SS_integration_password,
+            SS_integration_details,
+            SS_project_server,
+            SS_project_server_id
+        )
+      end
+    end
+
+    def require_module(module_name)
+      BrpmAuto.log "Loading module #{module_name}..."
+
+      internal_module_path = "#{@modules_root_path}/#{module_name}"
+      external_module_path = "#{@external_modules_root_path}/#{module_name}"
+
+      if File.exists?(internal_module_path)
+        module_path = internal_module_path
+        BrpmAuto.log "Found the module in framework module path #{module_path}."
+      elsif File.exists?(external_module_path)
+        module_path = external_module_path
+        BrpmAuto.log "Found the module in external module path #{module_path}."
+      else
+        raise "Module #{module_name} is not installed.\nSearched in:\n - internal path: #{internal_module_path}\n - external path: #{external_module_path}"
+      end
+
+      module_config_file_path = "#{module_path}/config.yml"
+      if File.exist?(module_config_file_path)
+        module_config = YAML.load_file(module_config_file_path)
+        if module_config["dependencies"]
+          BrpmAuto.log "Loading the dependent modules..."
+          module_config["dependencies"].each do |dependency|
+            require_module(dependency)
+          end
+        end
+      else
+        BrpmAuto.log "No config file found."
+      end
+
+      BrpmAuto.log "Loading the libraries of module #{module_name}..."
+      require_libs(module_path)
+
+      module_path
+    end
+
+    def require_module_from_gem(module_name, module_version = nil)
+      module_version ||= get_latest_installed_version(module_name)
+
+      module_gem_path = get_module_gem_path(module_name, module_version)
+
+      if File.exists?(module_gem_path)
+        BrpmAuto.log "Found the module in gem path #{module_gem_path}."
+      else
+        raise "Module #{module_name} version #{module_version} is not installed. Expected it on path #{module_gem_path}."
+      end
+
+      gemfile_lock_path = "#{module_gem_path}/Gemfile.lock"
+      if File.exists?(gemfile_lock_path)
+        BrpmAuto.log "Found a Gemfile.lock: #{gemfile_lock_path}. Parsing the version numbers for later usage..."
+        @gemfile_lock = Bundler::LockfileParser.new(Bundler.read_file(gemfile_lock_path))
+      end
+
+      require_module_internal(module_name, module_version)
+    end
+
+    def require_libs_no_file_logging(module_path)
+      require_libs(module_path, false)
+    end
+
+    def require_libs(module_path, log = true)
+      lib_path = "#{module_path}/lib/**/*.rb"
+      require_files(Dir[lib_path], log)
+    end
+
+    def require_files(files, log = true)
+      failed_files = []
+      error_messages = []
+      files.each do |file|
+        if File.file?(file)
+          log ? (BrpmAuto.log "Loading #{file}...") : (print "Loading #{file}...\n")
+
+          begin
+            require file
+          rescue NameError => ne # when we require a set of files with inter-dependencies, the order is important, therefore we will retry the failed files later
+            failed_files << file
+            error_messages << ne
+          end
+        end
+      end
+      if failed_files.count > 0
+        if failed_files.count == files.count
+          raise NameError, "Following files failed loading: #{failed_files.join(", ")}\nError messages: #{error_messages.join(", ")}"
+        else
+          require_files(failed_files, log)
+        end
+      end
+    end
+
+    def load_server_params
+      server_config_file_path = "#{self.params.config_dir}/server.yml"
+      if File.exists?(server_config_file_path)
+        server_config = YAML.load_file(server_config_file_path)
+        server_config.each do |key, value|
+          @params[key] = value unless @params.has_key?(key)
+        end
+      end
+    end
+
+    def load_customer_include_file
+      customer_include_file_path = "#{self.params.config_dir}/customer_include.rb"
+      if File.exists?(customer_include_file_path)
+        load customer_include_file_path # use load instead of require to avoid having to restart BRPM after modifying the customer include file in a resource automation scenario
+        if defined?(get_customer_include_params)
+          customer_include_params = get_customer_include_params
+          customer_include_params.each do |key, value|
+            @params[key] = value
+          end
+        end
+      end
+    end
+
+    def initialize_logger(log_file, also_log_to_console = false)
+      @logger = SimpleLogger.new(log_file, also_log_to_console)
+    end
+
+    def log(message)
+      @logger.log(message)
+    end
+
+    def log_error(message)
+      @logger.log_error(message)
+    end
+
+    def message_box(message, m_type = "sep")
+      @logger.message_box(message, m_type)
+    end
+
+    def initialize_request_params(path)
+      @request_params = RequestParams.new(path)
+    end
+
+    def get_request_params_for_request(automation_results_dir, application, request_id)
+      RequestParams.new_for_request(automation_results_dir, application, request_id)
+    end
+
+    def initialize_integration_settings(dns, username, password, details)
+      @integration_settings = IntegrationSettings.new(dns, username, password, details)
+    end
+
+    private
+
+    def require_module_internal(module_name, module_version)
+      module_path = get_module_gem_path(module_name, module_version)
+
+      module_config_file_path = "#{module_path}/config.yml"
+      if File.exist?(module_config_file_path)
+        module_config = YAML.load_file(module_config_file_path)
+        if module_config["dependencies"]
+          BrpmAuto.log "Loading the dependent modules..."
+          module_config["dependencies"].each do |dependency|
+            if dependency.is_a?(Hash)
+              dep_module_name = dependency.keys[0]
+              if @gemfile_lock
+                dep_module_version = get_version_from_gemfile_lock(dep_module_name)
+              else
+                dep_module_version = dependency.values[0]["version"]
+              end
+            else
+              dep_module_name = dependency
+
+              if ["brpm", "bladelogic", "jira"].include?(dep_module_name)
+                require_module(dep_module_name)
+                next
+              end
+
+              if @gemfile_lock
+                dep_module_version = get_version_from_gemfile_lock(dep_module_name)
+              else
+                dep_module_version = get_latest_installed_version(dep_module_name)
+              end
+            end
+
+            BrpmAuto.log "Loading module #{dep_module_name} version #{dep_module_version}..."
+            require_module_internal(dep_module_name, dep_module_version)
+          end
+        end
+      else
+        BrpmAuto.log "No config file found."
+      end
+
+      BrpmAuto.log "Loading the libraries of module #{module_name}..."
+      require_libs(module_path)
+
+      module_path
+    end
+
+    def get_config
+      YAML.load_file(File.expand_path("#{File.dirname(__FILE__)}/config.yml"))
+    end
+
+    def get_gems_root_path
+      if ENV["BRPM_CONTENT_HOME"]
+        ENV["BRPM_CONTENT_HOME"] # gemset location is overridden
+      elsif ENV["BRPM_HOME"]
+        "#{ENV["BRPM_HOME"]}/modules" # default gemset location when BRPM is installed
+      elsif ENV["GEM_HOME"]
+        ENV["GEM_HOME"] # default gemset location when BRPM is not installed
+      else
+        raise "Unable to find out the gems root path."
+      end
+    end
+
+    def get_module_gem_path(module_name, module_version)
+      "#{@gems_root_path}/gems/#{module_name}-#{module_version}"
+    end
+
+    def get_latest_installed_version(module_name)
+      latest_version_path = get_module_gem_path(module_name, "latest")
+      return "latest" if File.exists?(latest_version_path)
+
+      all_version_search = get_module_gem_path(module_name, "*")
+      version_paths = Dir.glob(all_version_search)
+
+      raise "Could not find any installed version of module #{module_name}. Expected them in #{get_module_gem_path(module_name, "*")}" if version_paths.empty?
+
+      versions = version_paths.map { |path| File.basename(path).sub("#{module_name}-", "") }
+
+      versions.sort{ |a, b| Gem::Version.new(a) <=> Gem::Version.new(b) }.last
+    end
+
+    def get_version_from_gemfile_lock(module_name)
+      spec = @gemfile_lock.specs.find { |spec| spec.name == module_name }
+      spec.version
+    end
+  end
+
+  self.init
+end
+

data/modules/framework/brpm_framework.rb

@@ -0,0 +1,88 @@
+# = BRPM Automation Framework
+#    BMC Software - BJB 8/22/2014, BJB 9/17/14
+# ==== A collection of classes to simplify building BRPM automation
+# === Instructions
+# In your BRPM automation include a block like this to pull in the library
+# <tt> params["direct_execute"] = true #Set for local execution
+# <tt> require @params["SS_automation_results_dir"].gsub("automation_results","persist/automation_lib/brpm_framework.rb")
+require 'popen4'
+require 'timeout'
+require 'rest-client'
+
+SleepDelay = [5,10,25,60] # Pattern for sleep pause in polling 
+RLM_BASE_PROPERTIES = ["SS_application", "SS_environment", "SS_component", "SS_component_version", "request_id", "step_name"]
+KEYWORD_SWITCHES = ["RPM_PARAMS_FILTER","RPM_SRUN_WRAPPER","RPM_INCLUDE"] unless defined?(KEYWORD_SWITCHES)
+FRAMEWORK_DIR = File.dirname(File.expand_path(__FILE__)) unless defined?(FRAMEWORK_DIR)
+
+def rpm_load_module(*module_names)
+  result = ""
+  module_names.each do |mod_name|
+    user_load_path = defined?(CUSTOMER_LIB_DIR) ? "#{CUSTOMER_LIB_DIR}/lib/#{mod_name}" : nil
+    load_path = "#{FRAMEWORK_DIR}/lib/#{mod_name}"
+    transport_load_path = "#{FRAMEWORK_DIR}/transport/#{mod_name}"
+    if File.exist?("#{load_path}.rb")
+      require load_path
+      result += "success - #{load_path}\n"
+    elsif File.exist?("#{transport_load_path}.rb")
+      require transport_load_path
+      result += "success - #{load_path}\n"
+    elsif !user_load_path.nil? && File.exist?("#{user_load_path}.rb")
+      require user_load_path
+      result += "success - #{load_path}\n"
+    else
+      result += "ERROR - file not found #{load_path}\n"
+    end
+  end
+  result
+end
+
+def update_output
+  load "#{FRAMEWORK_DIR}/write_to.rb" if BrpmAuto.params.run_from_brpm
+end
+
+# == Initialization on Include
+# Objects are set for most of the classes on requiring the file
+# these will be available in the BRPM automation
+#  Customers should modify the BAA_BASE_PATH constant
+# == Note the customer_include.rb reference.  To add your own routines and override methods use this file.
+customer_include_file = File.join(FRAMEWORK_DIR.gsub("/brpm_content/modules/framework", ""), "/customer_include.rb")
+customer_include_file = File.join(CUSTOMER_LIB_DIR,"customer_include.rb") if defined?(CUSTOMER_LIB_DIR)
+customer_include_file = File.join(FRAMEWORK_DIR,"customer_include_default.rb") if !File.exist?(customer_include_file)
+
+conts = File.open(customer_include_file).read
+eval conts # Use eval for resource automation to be dynamic
+
+if @params.nil? || @params["SS_script_target"] == "resource_automation"
+  puts "Loading customer include file: #{customer_include_file}"
+  conts = File.open(File.join(File.dirname(FRAMEWORK_DIR),"brpm", "lib","resource_framework.rb")).read
+  eval conts
+else
+  require "#{FRAMEWORK_DIR}/brpm_auto"
+  @rpm = BrpmAuto
+  @rpm.setup(@params)
+  @rpm.log "Loading customer include file: #{customer_include_file}"
+  if @params["SS_script_type"] != 'test' && @params["SS_script_target"] != "resource_automation" && !@params.has_key?("SS_no_framework") 
+    automation_settings = @params["SS_script_support_path"].gsub("lib/script_support","config/automation_settings.rb")
+    require "#{automation_settings}" if File.exist?(automation_settings)    
+  end  
+  @request_params = {} if not defined?(@request_params)
+  SS_output_file = @params["SS_output_file"]
+  BrpmAuto.require_module("brpm")
+  @p = BrpmAuto.all_params
+  @request_params = BrpmAuto.request_params
+  ARG_PREFIX = "ARG_" unless defined?(ARG_PREFIX)
+  @rest = BrpmRest.new(@p.SS_base_url)
+  if @p.get("SS_skip_transport") == ""
+    #Load the transport for the step, transport follows environment property SS_transport
+    transport = @p.get("ss_transport")
+    if transport == ""
+      transport = @p.get("SS_transport", "nsh") 
+      @p.assign_local_param("ss_transport", transport)
+      @p.find_or_add("SS_transport", transport)
+      @p.save_local_params
+    end
+    @rpm.log "Loading transport modules for: #{transport}"
+    res = rpm_load_module("transport_#{transport}", "dispatch_#{transport}")
+    @rpm.log res if res.include?("ERROR")
+  end
+end