brpm_content_framework 0.1.55

data/lib/params/params.rb

@@ -0,0 +1,174 @@
+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 :unit_test
+  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)
+    @unit_test = (params["unit_test"] == "true" || params["unit_test"] == 'true')
+    @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

data/lib/params/params_base.rb

@@ -0,0 +1,81 @@
+class ParamsBase < Hash
+  def [] key
+    BrpmAuto.substitute_tokens(super(key))
+  end
+
+  # Gets a params
+  #
+  # ==== Attributes
+  #
+  # * +key+ - key to find
+  def get(key, default_value = "")
+    self[key] || default_value
+  end
+
+  # Adds a key/value to the params
+  #
+  # ==== Attributes
+  #
+  # * +key_name+ - key name
+  # * +value+ - value to assign
+  #
+  # ==== Returns
+  #
+  # * value added
+  def add(key, value)
+    self[key] = value
+  end
+
+  # Adds a key/value to the params if not found
+  #
+  # ==== Attributes
+  #
+  # * +key_name+ - key name
+  # * +value+ - value to assign
+  #
+  # ==== Returns
+  #
+  # * value of key
+  def find_or_add(key, value)
+    ans = get(key)
+    add(key, value) if ans == ""
+    ans == "" ? value : ans
+  end
+
+  # Allows you to specify a key like a method call
+  #
+  # ==== Attributes
+  #
+  # * +key_name+ - key name note: you must use get if keyname has spaces
+  # * +*args+ - allows you to send a default value
+  #
+  # ==== Returns
+  #
+  # * value of key - including resolved properties that may be embedded
+  #
+  # ==== Examples
+  #
+  #   @p = Params.new(params)
+  #   @p.SS_application
+  #   => "Sales"
+  def method_missing(key, *args)
+    ans = get(key.to_s)
+    ans = args[0] if ans == "" && args[0]
+    ans
+  end
+
+  # Raises an error if a key is not found
+  #
+  # ==== Attributes
+  #
+  # * +key_name+ - key name
+  #
+  # ==== Returns
+  #
+  # * value of key
+  def required(key)
+    raise "ParamsError: param #{key} must be present" unless self.has_key?(key)
+    get(key)
+  end
+
+end

data/lib/params/request_params.rb

@@ -0,0 +1,38 @@
+class RequestParams < ParamsBase
+  attr_reader :file_path
+
+  def initialize(path)
+    @file_path = "#{path}/request_data.json"
+
+    self.merge!(get_request_params)
+  end
+
+  def self.new_for_request(automation_results_dir, app_name, request_id)
+    self.new("#{automation_results_dir}/request/#{app_name}/#{request_id}")
+  end
+
+  def []=(key,val)
+    super(key, val)
+
+    set_request_params
+  end
+
+  #TODO: support parallel steps modifying the same request params file
+
+  private
+
+    def set_request_params
+      File.open(@file_path, "w") do |file|
+        file.puts(self.to_json)
+      end
+    end
+
+    def get_request_params
+      if File.exist?(@file_path)
+        json = File.read(@file_path)
+        JSON.parse(json)
+      else
+        {}
+      end
+    end
+end

data/lib/rest_api.rb

@@ -0,0 +1,155 @@
+require 'rest-client'
+require 'uri'
+require 'json'
+require 'cgi'
+
+class Rest
+  class << self
+    def get(url, options = {})
+      rest_call(url, "get", options)
+    end
+
+    def post(url, data, options = {})
+      options[:data] = data
+      rest_call(url, "post", options)
+    end
+
+    def put(url, data, options = {})
+      options[:data] = data
+      rest_call(url, "put", options)
+    end
+
+    def delete(url, options = {})
+      rest_call(url, "delete", options)
+    end
+
+    # Makes an http method call and returns data in JSON
+    #
+    # ==== Attributes
+    #
+    # * +url+ - the url for the request
+    # * +method+ - the http method [get, put, post]
+    # * +options+ - a hash of options
+    #      +verbose+: gives verbose output (yes/no)
+    #      +data+: required for put and post methods a hash of post data
+    #      +username+: username for basic http authentication
+    #      +password+: password for basic http authentication
+    #      +suppress_errors+: continues after errors if true
+    #      
+    # ==== Returns
+    #
+    # * returns a hash of the http response with these keys
+    # * +status+ - success or ERROR
+    # * +message+ - if status is ERROR this will hold an error message
+    # * +code+ - the http status code 200=ok, 404=not found, 500=error, 504=not authorized
+    # * +data+ - the body of the http response
+    def rest_call(url, method, options = {})
+      methods = %w{get post put delete}
+      result = rest_params = {}
+      rest_params[:url] = URI.escape(url)
+
+      unless methods.include?(method.downcase)
+        BrpmAuto.log "No method named: #{method}"
+        result["code"] = -1
+        result["status"] = "failure"
+        result["message"] = "No method named: #{method}"
+        return result
+      end
+
+      rest_params[:method] = method.downcase
+
+      begin
+        BrpmAuto.log("REST #{method.upcase} #{BrpmAuto.privatize(url, get_token(url))}") unless options.has_key?("quiet")
+
+        if options.has_key?(:username) && options.has_key?(:password)
+          rest_params[:user] = options[:username]
+          rest_params[:password] = options[:password]
+        end
+
+        if %{put post}.include?(method.downcase)
+          options[:data] = options["data"] if options.has_key?("data")
+          rest_params[:payload] = options[:data].to_json if options.has_key?(:data)
+          if !options.has_key?(:data) || rest_params[:payload].length < 4
+            result["code"] = -1
+            result["status"] = "failure"
+            result["message"] = "No Post data"
+            return result
+          end
+          BrpmAuto.log "\tPost Data: #{rest_params[:payload].inspect}" unless options.has_key?("quiet")
+        end
+
+        rest_params.merge!({:headers => { :accept => :json, :content_type => :json }})
+        rest_params.merge!({:verify_ssl => OpenSSL::SSL::VERIFY_NONE})
+        rest_params.merge!({:cookies => options["cookies"] }) if options.has_key?("cookies")
+
+        BrpmAuto.log rest_params.inspect if options.has_key?("verbose")
+
+        response = RestClient::Request.new(rest_params).execute
+
+        BrpmAuto.log "\tParsing response to JSON format ..." if options.has_key?("verbose")
+        begin
+          parsed_response = JSON.parse(response)
+        rescue
+          parsed_response = response
+        end
+        BrpmAuto.log "Parsed response: #{parsed_response.inspect}" if options.has_key?("verbose")
+
+        if response.code < 300
+          BrpmAuto.log "\treturn code: #{response.code}"  unless options.has_key?("quiet")
+          result["status"] = "success"
+          result["code"] = response.code
+          result["response"] = parsed_response
+          result["cookies"] = response.cookies if options.has_key?("cookies")
+        else
+          result["status"] = "error"
+          result["code"] = response.code
+          result["response"] = parsed_response
+          result["error_message"] = "REST call returned HTTP code:\n#{response.code}\n#{response}"
+          BrpmAuto.log "\tREST call returned HTTP code #{response.code}"  unless options.has_key?("quiet")
+        end
+
+      rescue RestClient::Exception => e
+        BrpmAuto.log "\tREST call generated an error: #{e.message}" unless options.has_key?("quiet")
+
+        if e.response.nil?
+          result["status"] = "error"
+          result["code"] = 1000
+          result["response"] = "No response received."
+          result["error_message"] = "REST call generated a RestClient error:\n#{e.message}\n#{e.backtrace}"
+          return
+        end
+
+        BrpmAuto.log "\tParsing response to JSON format ..."  unless options.has_key?("quiet")
+        begin
+          parsed_response = JSON.parse(e.response)
+        rescue
+          parsed_response = e.response
+        end
+        BrpmAuto.log "\tParsed response: #{parsed_response.inspect}"
+
+        result["status"] = "error"
+        result["code"] = e.response.code
+        result["response"] = parsed_response
+        result["error_message"] = "REST call generated a RestClient error:\n#{e.response.code}\n#{e.response}\n#{e.message}\n#{e.backtrace}"
+
+        BrpmAuto.log "Back trace:\n#{e.backtrace}" unless already_exists_error(result) or not_found_error(result)
+      end
+      result
+    end
+
+    def already_exists_error(result)
+      result["code"] == 422 && result["response"].keys.count >= 1 && (result["response"][result["response"].keys[0]][0] == "has already been taken" || result["response"][result["response"].keys[0]][0] =~ /Version Tag is not unique/)
+    end
+
+    def not_found_error(result)
+      result["code"] == 404
+    end
+
+    private
+
+      def get_token(url)
+        params = CGI::parse(url.split("?").last)
+        params.has_key?("token") ? params["token"] : ""
+      end
+  end
+end

data/lib/semaphore.rb

@@ -0,0 +1,79 @@
+# Creates a pid-file semaphore to govern global execution
+#
+# ==== Attributes
+#
+# * +semaphore_key+ - string to name semaphore
+# ==== Returns
+#
+# true if semaphore created, false if already exists
+#
+def semaphore(semaphore_key)
+  semaphore_dir = "#{BrpmAuto.params.automation_results_dir}/semaphores"
+  semaphore_name = "#{semaphore_key}.pid"
+  FileUtils.mkdir(semaphore_dir) unless File.exist?(semaphore_dir)
+  return false if File.exist?(File.join(semaphore_dir, semaphore_name))
+  fil = File.open(File.join(semaphore_dir, semaphore_name), "w+")
+  fil.puts BrpmAuto.precision_timestamp
+  fil.flush
+  fil.close
+  return true
+end
+
+# Clears a pid-file semaphore to govern global execution
+#
+# ==== Attributes
+#
+# * +semaphore_key+ - string to name semaphore
+# ==== Returns
+#
+# true if semaphore deleted, false if it doesn't exist
+#
+def semaphore_clear(semaphore_key)
+  semaphore_dir = "#{BrpmAuto.params.automation_results_dir}/semaphores"
+  semaphore_name = "#{semaphore_key}.pid"
+  return false unless File.exist?(File.join(semaphore_dir, semaphore_name))
+  File.delete(File.join(semaphore_dir, semaphore_name))
+  return true
+end
+
+# Checks if a semaphore exists
+#
+# ==== Attributes
+#
+# * +semaphore_key+ - string to name semaphore
+# ==== Returns
+#
+# true if semaphore exists, false if it doesn't exist
+#
+def semaphore_exists(semaphore_key)
+  semaphore_dir = "#{BrpmAuto.params.automation_results_dir}/semaphores"
+  semaphore_name = "#{semaphore_key}.pid"
+  return true if File.exist?(File.join(semaphore_dir, semaphore_name))
+  return false
+end
+
+# Waits a specified period for a semaphore to clear
+# throws error after wait time if semaphore does not clear
+# ==== Attributes
+#
+# * +semaphore_key+ - string to name semaphore
+# * +wait_time+ - time in minutes before failure (default = 15mins)
+# ==== Returns
+#
+# true if semaphore is cleared
+#
+def semaphore_wait(semaphore_key, wait_time = 15)
+  interval = 20; elapsed = 0
+  semaphore_dir = "#{BrpmAuto.params.automation_results_dir}/semaphores"
+  semaphore_name = "#{semaphore_key}.pid"
+  semaphore = File.join(semaphore_dir, semaphore_name)
+  return true if !File.exist?(semaphore)
+  until !File.exist?(semaphore) || (elapsed/60 > wait_time) do
+    sleep interval
+    elapsed += interval
+  end
+  if File.exist?(semaphore)
+    raise "ERROR: Semaphore (#{semaphore}) still exists after #{wait_time} minutes"
+  end
+  return true
+end