brpm_content 0.1.16

data/modules/framework/brpm_script_executor.rb

@@ -0,0 +1,146 @@
+require_relative "brpm_auto"
+
+class BrpmScriptExecutor
+  class << self
+    def execute_automation_script(modul, name, params)
+      begin
+        BrpmAuto.setup(params)
+
+        BrpmAuto.log ""
+        BrpmAuto.log ">>>>>>>>>>>>>> START automation #{name}"
+        start_time = Time.now
+
+        BrpmAuto.log "Loading the module and its dependencies..."
+        module_path = BrpmAuto.require_module(modul)
+        BrpmAuto.log "Finished loading the module."
+
+        automation_script_path = "#{module_path}/automations/#{name}.rb"
+
+        BrpmAuto.log "Loading the automation script #{automation_script_path}..."
+        load automation_script_path
+
+      rescue Exception => e
+        BrpmAuto.log_error "#{e}"
+        BrpmAuto.log e.backtrace.join("\n\t")
+
+        raise e
+      ensure
+        stop_time = Time.now
+        duration = 0
+        duration = stop_time - start_time unless start_time.nil?
+
+        BrpmAuto.log ">>>>>>>>>>>>>> STOP automation #{name} - total duration: #{Time.at(duration).utc.strftime("%H:%M:%S")}"
+        BrpmAuto.log ""
+
+        #load "#{File.dirname(__FILE__)}/write_to.rb" if BrpmAuto.params.run_from_brpm
+      end
+    end
+
+    def execute_resource_automation_script(modul, name, params, parent_id, offset, max_records)
+      begin
+        BrpmAuto.setup(params)
+
+        BrpmAuto.log ""
+        BrpmAuto.log ">>>>>>>>>>>>>> START resource automation #{name}"
+        start_time = Time.now
+
+        BrpmAuto.log "Loading the module and its dependencies..."
+        module_path = BrpmAuto.require_module(modul)
+        BrpmAuto.log "Finished loading the module."
+
+        automation_script_path = "#{module_path}/resource_automations/#{name}.rb"
+
+        BrpmAuto.log "Loading the resource automation script #{automation_script_path}..."
+        result = load automation_script_path
+
+        BrpmAuto.log "Calling execute_resource_automation_script(params, parent_id, offset, max_records)..."
+        execute_script(params, parent_id, offset, max_records)
+
+      rescue Exception => e
+        BrpmAuto.log_error "#{e}"
+        BrpmAuto.log e.backtrace.join("\n\t")
+
+        raise e
+      ensure
+        stop_time = Time.now
+        duration = stop_time - start_time
+
+        BrpmAuto.log ">>>>>>>>>>>>>> STOP resource automation #{name} - total duration: #{Time.at(duration).utc.strftime("%H:%M:%S")}"
+        BrpmAuto.log ""
+
+        #load "#{File.dirname(__FILE__)}/write_to.rb" if BrpmAuto.params.run_from_brpm
+      end
+    end
+
+    def execute_automation_script_from_gem(modul, name, params)
+      begin
+        BrpmAuto.setup(params)
+
+        BrpmAuto.log ""
+        BrpmAuto.log ">>>>>>>>>>>>>> START automation #{name}"
+        start_time = Time.now
+
+        BrpmAuto.log "Loading the module and its dependencies..."
+        module_path = BrpmAuto.require_module_from_gem(modul)
+        BrpmAuto.log "Finished loading the module."
+
+        automation_script_path = "#{module_path}/automations/#{name}.rb"
+
+        BrpmAuto.log "Loading the automation script #{automation_script_path}..."
+        load automation_script_path
+
+      rescue Exception => e
+        BrpmAuto.log_error "#{e}"
+        BrpmAuto.log e.backtrace.join("\n\t")
+
+        raise e
+      ensure
+        stop_time = Time.now
+        duration = 0
+        duration = stop_time - start_time unless start_time.nil?
+
+        BrpmAuto.log ">>>>>>>>>>>>>> STOP automation #{name} - total duration: #{Time.at(duration).utc.strftime("%H:%M:%S")}"
+        BrpmAuto.log ""
+
+        #load "#{File.dirname(__FILE__)}/write_to.rb" if BrpmAuto.params.run_from_brpm
+      end
+    end
+
+    def execute_resource_automation_script_from_gem(modul, name, params, parent_id, offset, max_records)
+      begin
+        BrpmAuto.setup(params)
+
+        BrpmAuto.log ""
+        BrpmAuto.log ">>>>>>>>>>>>>> START resource automation #{name}"
+        start_time = Time.now
+
+        BrpmAuto.log "Loading the module and its dependencies..."
+        module_path = BrpmAuto.require_module_from_gem(modul)
+        BrpmAuto.log "Finished loading the module."
+
+        automation_script_path = "#{module_path}/resource_automations/#{name}.rb"
+
+        BrpmAuto.log "Loading the resource automation script #{automation_script_path}..."
+        result = load automation_script_path
+
+        BrpmAuto.log "Calling execute_resource_automation_script(params, parent_id, offset, max_records)..."
+        execute_script(params, parent_id, offset, max_records)
+
+      rescue Exception => e
+        BrpmAuto.log_error "#{e}"
+        BrpmAuto.log e.backtrace.join("\n\t")
+
+        raise e
+      ensure
+        stop_time = Time.now
+        duration = stop_time - start_time
+
+        BrpmAuto.log ">>>>>>>>>>>>>> STOP resource automation #{name} - total duration: #{Time.at(duration).utc.strftime("%H:%M:%S")}"
+        BrpmAuto.log ""
+
+        #load "#{File.dirname(__FILE__)}/write_to.rb" if BrpmAuto.params.run_from_brpm
+      end
+    end
+  end
+end
+

data/modules/framework/config.yml

@@ -0,0 +1,7 @@
+version: 0.1.16
+
+author: Niek Bartholomeus
+email: niek.bartholomeus@gmail.com
+homepage: https://github.com/BMC-RLM/brpm_content
+summary: BRPM Content Framework
+description: The BRPM Content Framework is a lightweight framework that allows to run automation logic on top of BRPM in a modular, re-usable, testable and developer-friendly way

data/modules/framework/config/customer_include.rb

@@ -0,0 +1,26 @@
+# This file should be located in BRPM_HOME/config
+# See the README for more information on how to use this file
+
+def get_customer_include_params
+  params = {}
+  # Hostname so nsh paths can be constructed from local paths
+  params["BAA_RPM_HOSTNAME"] = "localhost"
+  # set your own automation token
+  params["Token"] = "???"
+  # Hostname so nsh paths can be constructed from local paths
+  params["BAA_RPM_HOSTNAME"] = "localhost"
+  # Change this to set BAA base path
+  params["BAA_BASE_PATH"] = "/opt/bmc/bladelogic"
+  # This is the root path for use in BAA/BSA
+  params["BAA_BASE_GROUP"] = "BRPM"
+  # The location and name of the standard NSH script for script execution
+  params["BAA_FRAMEWORK_NSH_SCRIPT"] = "/BRPM/NSHScripts/FrameworkScriptExecute"
+  # Place your own global constants
+  params["DATA_CENTER_NAMES"] = ["HOU", "LEX", "PUNE"]
+
+  params
+end
+
+def my_custom_method(a, b)
+  a + b
+end

data/modules/framework/config/server.yml

@@ -0,0 +1,3 @@
+# This file should be located in BRPM_HOME/config
+# See the README for more information on how to use this file
+my_parameter: "abc"

data/modules/framework/customer_include_default.rb

@@ -0,0 +1,25 @@
+# = BRPM Automation Framework
+# == Customer Include Automation
+#    BMC Software - BJB 9/16/2014
+# ===== Use this routine to override and provide global methods for all your automation
+
+# set your own automation token
+Token = "a56d64cbcffcce91d306670489fa4cf51b53316c" #"<YOUR_AUTOMATION_TOKEN>" #decrypt_string_with_prefix(@params["SS_api_token"])
+# Hostname so nsh paths can be constructed from local paths
+BAA_RPM_HOSTNAME = "localhost"
+# Change this to set BAA base path 
+BAA_BASE_PATH = "/opt/bmc/bladelogic"
+# This is the root path for use in BAA/BSA
+BAA_BASE_GROUP = "BRPM"
+# The location and name of the standard NSH script for script execution
+BAA_FRAMEWORK_NSH_SCRIPT = "/BRPM/NSHScripts/FrameworkScriptExecute"
+# This path will get any files staged by the framework
+RPM_STAGING_PATH = "/opt/bmc/staging"
+# This defines a path for a library of automations (from Git or Svn for instance)
+ACTION_LIBRARY_PATH = "/opt/bmc/RLM/persist/script_library"
+# Custom Lib/Module directory (to add customer content to framework)
+CUSTOMER_LIB_DIR = "/opt/bmc/RLM/persist/brpm_lib"
+# Place your own global constants
+DATA_CENTER_NAMES = ["HOU", "LEX", "PUNE"]
+
+

data/modules/framework/lib/logging/brpm_logger.rb

@@ -0,0 +1,39 @@
+require_relative "logger_base"
+
+class BrpmLogger < LoggerBase
+  attr_reader :request_log_file_path
+  attr_reader :step_run_log_file_path
+
+  def initialize
+    @step_number = BrpmAuto.params.step_number
+    @step_name = BrpmAuto.params.step_name
+
+    @request_log_file_path = "#{BrpmAuto.params.automation_results_dir}/#{BrpmAuto.params.request_id}.log"
+
+    # @step_run_log_file_path = "#{BrpmAuto.params.automation_results_dir}/#{BrpmAuto.params.request_id}_#{BrpmAuto.params.step_id}_#{BrpmAuto.params.run_key}.log"
+    @step_run_log_file_path = BrpmAuto.params.output_file
+
+    print "Logging to #{@step_run_log_file_path} and #{@request_log_file_path}\n" unless BrpmAuto.params.also_log_to_console
+  end
+
+  def log(message)
+    message = message.to_s # in case booleans or whatever are passed
+    timestamp = "#{Time.now.strftime("%Y-%m-%d %H:%M:%S")}"
+    log_message = ""
+
+    prefix = "#{timestamp}|#{'%2.2s' % @step_number}|#{'%-20.20s' % @step_name}|"
+    message.gsub!("\n", "\n" + (" " * prefix.length))
+
+    log_message = "#{prefix}#{message}\n"
+
+    File.open(@request_log_file_path, "a") do |log_file|
+      log_file.print(log_message)
+    end
+
+    File.open(@step_run_log_file_path, "a") do |log_file|
+      log_file.print(log_message)
+    end
+
+    print(log_message) if BrpmAuto.params.also_log_to_console
+  end
+end

data/modules/framework/lib/logging/logger_base.rb

@@ -0,0 +1,36 @@
+class LoggerBase
+  # Provides a pretty box for titles
+  #
+  # ==== Attributes
+  #
+  # * +msg+ - the text to output
+  # * +mtype+ - box type to display sep: a separator line, title a box around the message
+  def message_box(msg, mtype = "sep")
+    return "" if msg.nil? || msg.length < 1
+    tot = 72
+    msg = msg[0..64] if msg.length > 65
+
+    ilen = tot - msg.length
+
+    if mtype == "sep"
+      start = "##{"-" * (ilen/2).to_i} #{msg} "
+      res = "#{start}#{"-" * (tot- start.length + 1)}#"
+    else
+      res = "##{"-" * tot}#\n"
+      start = "##{" " * (ilen/2).to_i} #{msg} "
+      res += "#{start}#{" " * (tot- start.length + 1)}#\n"
+      res += "##{"-" * tot}#\n"
+    end
+
+    log(res)
+  end
+
+  def log_error(message)
+    log ""
+    log "******** ERROR ********"
+    log "An error has occurred"
+    log "#{message}"
+    log "***********************"
+    log ""
+  end
+end

data/modules/framework/lib/logging/simple_logger.rb

@@ -0,0 +1,27 @@
+require_relative "logger_base"
+
+class SimpleLogger < LoggerBase
+  def initialize(log_file, also_log_to_console = false)
+    @log_file = log_file
+    @also_log_to_console = also_log_to_console
+
+    print "Logging to #{@log_file}\n" unless also_log_to_console
+  end
+
+  def log(message)
+    message = message.to_s # in case booleans or whatever are passed
+    timestamp = "#{Time.now.strftime("%Y-%m-%d %H:%M:%S")}"
+    log_message = ""
+
+    prefix = "#{timestamp}|"
+    message.gsub!("\n", "\n" + (" " * prefix.length))
+
+    log_message = "#{prefix}#{message}\n"
+
+    File.open(@log_file, "a") do |log_file|
+      log_file.print(log_message)
+    end
+
+    print(log_message) if @also_log_to_console
+  end
+end

data/modules/framework/lib/params/all_params.rb

@@ -0,0 +1,80 @@
+class AllParams < ParamsBase
+  def initialize(params, request_params)
+    @params = params
+    @request_params = request_params
+
+    # this class acts as a virtual hash on top of two real hashes for all write-related methods (which need to be overriden)
+    # the values from both hashes are also synchronized in this class to avoid having to override all read-related methods
+    self.merge!(@params)
+    self.merge!(@request_params)
+  end
+
+  alias :super_add :[]=
+
+  def []=(key,val)
+    raise RuntimeError.new("This is a virtual hash based on two physical hashes, use the add method instead.")
+  end
+
+  #TODO: refactor out the where functionality
+  # Test if a param is present
+  #
+  # ==== Attributes
+  #
+  # * +key_name+ - key to look for
+  # * +where+ - if true returns the hash where the key was found
+  #
+  # ==== Returns
+  #
+  # * the param hash name if where=true, otherwise true/false
+  def present?(key_name, where = false)
+    ans = nil
+    ans = "params" if @params.has_key?(key_name)
+    ans = "json" if @request_params.has_key?(key_name)
+    where ? ans : !ans.nil?
+  end
+
+  def present_json?(key_name)
+    @request_params.has_key?(key_name)
+  end
+
+  def present_local?(key_name)
+    @params.has_key?(key_name)
+  end
+
+  # Adds a key/value to the params
+  #
+  # ==== Attributes
+  #
+  # * +key_name+ - key name
+  # * +value+ - value to assign
+  # * +store+ - place to add params or json (default = params)
+  #
+  # ==== Returns
+  #
+  # * value added
+  def add(key, value, store = "params")
+    if store == "params"
+      @params[key] = value
+    elsif store == "json"
+      @request_params[key] = value
+    end
+    super_add(key, value)
+  end
+
+  # Adds a key/value to the params if not found
+  #
+  # ==== Attributes
+  #
+  # * +key_name+ - key name
+  # * +value+ - value to assign
+  # * +store+ - place to add params or json (default = params)
+  #
+  # ==== Returns
+  #
+  # * value of key
+  def find_or_add(key_name, value, store = "params")
+    ans = get(key_name)
+    add(key_name, value, store) if ans == ""
+    ans == "" ? value : ans
+  end
+end

data/modules/framework/lib/params/integration_settings.rb

@@ -0,0 +1,27 @@
+class IntegrationSettings
+  attr_reader :project_server
+  attr_reader :project_server_id
+  attr_reader :dns
+  attr_reader :username
+  attr_reader :password
+  attr_reader :details
+
+  def initialize(dns, username, password, details = nil, project_server = nil, project_server_id = nil)
+    @dns = dns
+    @username = username
+    @password = password
+    @details = details
+    @project_server = project_server
+    @project_server_id = project_server_id
+  end
+
+  def to_params
+    params = {}
+    params["SS_integration_dns"] = @dns
+    params["SS_integration_username"] = @username
+    params["SS_integration_password"] = @password
+    params["SS_integration_details"] = @details
+
+    params
+  end
+end

data/modules/framework/lib/params/params.rb

@@ -0,0 +1,172 @@
+class Params < ParamsBase
+  attr_reader :application
+  attr_reader :component
+  attr_reader :component_version
+
+  attr_reader :request_id
+  attr_reader :request_name
+  attr_reader :request_number
+  attr_reader :request_environment
+  attr_reader :request_scheduled_at
+  attr_reader :request_started_at
+  attr_reader :request_status
+
+  attr_reader :request_plan
+  attr_reader :request_plan_id
+  attr_reader :request_plan_member_id
+  attr_reader :request_plan_stage
+
+  attr_reader :request_run_id
+  attr_reader :request_run_name
+
+  attr_reader :step_id
+  attr_reader :step_number
+  attr_reader :step_name
+  attr_reader :step_description
+  attr_reader :step_estimate
+
+  attr_reader :step_version
+  attr_reader :step_version_artifact_url
+
+  attr_reader :servers
+
+  attr_reader :ticket_ids
+  attr_reader :tickets_foreign_ids
+
+  attr_reader :run_key
+
+  attr_reader :home_dir
+  attr_reader :automation_results_dir
+  attr_reader :output_dir
+  attr_reader :output_file
+  attr_reader :config_dir
+
+  attr_reader :log_file
+
+  attr_reader :brpm_url
+  attr_reader :brpm_api_token
+
+  attr_reader :run_from_brpm
+  attr_reader :also_log_to_console
+
+  attr_reader :private_params
+
+  def initialize(params)
+    self.merge!(params)
+
+    @application = params["application"]
+    @component = params["component"]
+    @component_version = params["component_version"]
+
+    @request_id = params["request_id"]
+    @request_name = params["request_name"]
+    @request_number = params["request_number"]
+    @request_environment = params["request_environment"]
+    @request_scheduled_at = params["request_scheduled_at"]
+    @request_started_at = params["request_started_at"]
+    @request_status = params["request_status"]
+
+    @request_plan = params["request_plan"]
+    @request_plan_id = params["request_plan_id"]
+    @request_plan_member_id = params["request_plan_member_id"]
+    @request_plan_stage = params["request_plan_stage"]
+
+    @request_run_id = params["request_run_id"]
+    @request_run_name = params["request_run_name"]
+
+    @step_id = params["step_id"]
+    @step_number = params["step_number"]
+    @step_name = params["step_name"]
+    @step_description = params["step_description"]
+    @step_estimate = params["step_estimate"]
+
+    @step_version = params["step_version"]
+    @step_version_artifact_url = params["step_version_artifact_url"]
+
+    @servers = get_server_list
+
+    @ticket_ids = params["ticket_ids"]
+    @tickets_foreign_ids = params["tickets_foreign_ids"]
+
+    @run_key = params["SS_run_key"] || params["run_key"]
+
+    if params["SS_automation_results_dir"]
+      @home_dir = params["SS_automation_results_dir"].sub("automation_results", "")
+    else
+      @home_dir = params["home_dir"] || Dir.pwd
+    end
+    @automation_results_dir = params["SS_automation_results_dir"]
+    @output_dir = params["SS_output_dir"] || params["output_dir"] || Dir.pwd
+    @output_file = params["SS_output_file"]
+    @config_dir = "#{@home_dir}/config"
+
+    @log_file = params["log_file"] || "#{@output_dir}/brpm_auto.log"
+
+    @brpm_url = params["SS_base_url"] || params["brpm_url"]
+    @brpm_api_token = params["SS_api_token"] || params["brpm_api_token"]
+
+    @run_from_brpm = (@run_key != nil)
+    @also_log_to_console = (params["also_log_to_console"] == "true" || params["also_log_to_console"] == 'true')
+
+    @private_params = {}
+    if self.run_from_brpm
+      params.each do |k,v|
+        if k.end_with?("_encrypt") || k.end_with?("_enc")
+          if k.end_with?("_encrypt")
+            key_decrypted = k.gsub("_encrypt","")
+          elsif k.end_with?("_enc")
+            key_decrypted = k.gsub("_enc","")
+          end
+          value_decrypted = decrypt_string_with_prefix(v)
+          @private_params[key_decrypted] = value_decrypted
+        end
+      end
+    end
+    self.merge!(@private_params)
+  end
+
+  # Servers in params need to be filtered by OS
+  def get_servers_by_os_platform(os_platform, alt_servers = nil)
+    servers = alt_servers || @servers
+    result = servers.select{|k,v| v["os_platform"].downcase =~ /#{os_platform}/ }
+  end
+
+  # Fetches the property value for a server
+  #
+  # ==== Returns
+  #
+  # * property value
+  def get_server_property(server, property)
+    ans = ""
+    ans = @servers[server][property] if @servers.has_key?(server) && @servers[server].has_key?(property)
+    ans
+  end
+
+  # Returns the request id for use in rest calls
+  #
+  def rest_request_id
+    (self["request_id"].to_i - 1000).to_s
+  end
+
+  private
+
+    def get_server_list()
+      rxp = /server\d+_/
+      slist = {}
+      lastcur = -1
+      curname = ""
+
+      self.sort.reject{ |k| k[0].scan(rxp).empty? }.each_with_index do |server, idx|
+        cur = (server[0].scan(rxp)[0].gsub("server","").to_i * 0.001).round * 1000
+        if cur == lastcur
+          prop = server[0].gsub(rxp, "")
+          slist[curname][prop] = server[1]
+        else # new server
+          lastcur = cur
+          curname = server[1].chomp("0")
+          slist[curname] = {}
+        end
+      end
+      return slist
+    end
+end