brpm_content 0.1.16

data/modules/framework/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/modules/framework/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/modules/framework/lib/resource_framework.rb

@@ -0,0 +1,211 @@
+
+module ResourceFramework
+  #DEPRECATED: this functionality already exists, see modules/framework/lib/request_params.rb
+  def create_request_params_file
+    request_data_file_dir = File.dirname(@params["SS_output_dir"])
+    request_data_file = "#{request_data_file_dir}/request_data.json"
+    fil = File.open(request_data_file,"w")
+    fil.puts "{\"request_data_file\":\"Created #{Time.now.strftime("%m/%d/%Y %H:%M:%S")}\"}"
+    fil.close
+    file_part = request_data_file[request_data_file.index("/automation_results")..255]
+    data_file_url = "#{@params["SS_base_url"]}#{file_part}"
+    write_to "Request Run Data: #{data_file_url}"
+    request_data_file
+  end
+
+  #DEPRECATED: this functionality already exists, see modules/framework/lib/request_params.rb
+  def init_request_params
+    request_data_file_dir = File.dirname(@params["SS_output_dir"])
+    request_data_file = "#{request_data_file_dir}/request_data.json"
+    sleep(2) unless File.exist?(request_data_file)
+    unless File.exist?(request_data_file)
+      create_request_params_file
+    end
+    file_part = request_data_file[request_data_file.index("/automation_results")..255]
+    data_file_url = "#{@params["SS_base_url"]}#{file_part}"
+    write_to "Request Run Data: #{data_file_url}"
+    request_data_file
+  end
+
+  #DEPRECATED: this functionality already exists, see modules/framework/lib/request_params.rb
+  def get_request_params
+    # Uses a json document in automation_results to store free-form information
+    cur = init_request_params
+    #message_box("Current Request Data","sep")
+    @request_params = JSON.parse(File.open(cur).read)
+    @request_params.each{ |k,v| write_to("#{k} => #{v.is_a?(String) ? v : v.inspect}") }
+    @orig_request_params = @request_params.dup
+    @request_params
+  end
+
+  #DEPRECATED: this functionality already exists, see modules/framework/lib/request_params.rb
+  def save_request_params
+    # Uses a json document in automation_results to store free-form information
+    cur = init_request_params
+    unless @orig_request_params == @request_params
+      sleep(2) unless File.exist?(cur)
+      fil = File.open(cur,"w+")
+      fil.write @request_params.to_json
+      fil.flush
+      fil.close
+    end
+  end
+
+  #DEPRECATED: is this specific to a particular use case?
+  def default_table(other_rows = nil)
+    totalItems = 1
+    table_entries = [["#","Status","Information"]]
+    table_entries << ["1","Error", "Insufficient Data"] if other_rows.nil?
+    other_rows.each{|row| table_entries << row } unless other_rows.nil?
+    per_page=10
+    {:totalItems => totalItems, :perPage => per_page, :data => table_entries }
+  end
+
+  #DEPRECATED: what does this method do?
+  def default_list(msg)
+    result = [{msg => 0}]
+    select_hash = {}
+    result.unshift(select_hash)
+  end
+
+  #DEPRECATED: this functionality already exists, see modules/framework/lib/logger.rb
+  def log_it(it)
+    log_path = File.join(@params["SS_automation_results_dir"], "resource_logs")
+    txt = it.is_a?(String) ? it : it.inspect
+    write_to txt
+    Dir.mkdir(log_path) unless File.exist?(log_path)
+    s_handle = defined?(@script_name_handle) ? @script_name_handle : "rsc_output"
+    fil = File.open("#{log_path}/#{s_handle}_#{@params["SS_run_key"]}", "a")
+    fil.puts txt
+    fil.flush
+    fil.close
+  end
+
+  #DEPRECATED: OK - implemented it with a server.yml file instead (located in BRPM_HOME/config)
+  def load_customer_include(framework_dir)
+    customer_include_file = File.join(framework_dir, "customer_include.rb")
+    begin
+      if File.exist?(customer_include_file)
+        log_it "Loading customer include file: #{customer_include_file}"
+        eval(File.open(customer_include_file).read)
+      elsif File.exist customer_include_file = File.join(framework_dir,"customer_include_default.rb")
+        log_it "Loading default customer include file: #{customer_include_file}"
+        eval(File.open(customer_include_file).read)
+      end
+    rescue Exception => e
+      log_it "Error loading customer include: #{e.message}\n#{e.backtrace}"
+    end
+  end
+
+  #DEPRECATED: what does this method do?
+  def hashify_list(list)
+    response = {}
+    list.each do |item,val|
+      response[val] = item
+    end
+    return [response]
+  end
+
+  #DEPRECATED: already implemented differently
+  def action_library_path
+    raise "Command_Failed: no library path defined, set property: ACTION_LIBRARY_PATH" if !defined?(ACTION_LIBRARY_PATH)
+    ACTION_LIBRARY_PATH
+  end
+
+
+  #DEPRECATED: what's the difference with the method with the same name from brpm_automation?
+
+  # 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}
+    result = {"status" => "ERROR", "response" => "", "message" => ""}
+    method = method.downcase
+    verbose = get_option(options, "verbose") == "yes" || get_option(options, "verbose")
+    headers = get_option(options, "headers", {:accept => :json, :content_type => :json})
+    return result["message"] = "ERROR - #{method} not recognized" unless methods.include?(method)
+    log "Rest URL: #{url}" if verbose
+    begin
+      data = get_option(options, "data")
+      rest_params = {}
+      rest_params[:url] = url
+      rest_params[:method] = method.to_sym
+      rest_params[:verify_ssl] = OpenSSL::SSL::VERIFY_NONE if url.start_with?("https")
+      rest_params[:payload] = data.to_json unless data == ""
+      if options.has_key?("username") && options.has_key?("password")
+        rest_params[:user] = options["username"]
+        rest_params[:password] = options["password"]
+      end
+      rest_params[:headers] = headers
+      log "RestParams: #{rest_params.inspect}" if verbose
+      if %{put post}.include?(method)
+        return result["message"] = "ERROR - no data param for post" if data == ""
+        response = RestClient::Request.new(rest_params).execute
+      else
+        response = RestClient::Request.new(rest_params).execute
+      end
+    rescue Exception => e
+      result["message"] = e.message
+      raise "RestError: #{result["message"]}" unless get_option(options, "suppress_errors") == true
+      return result
+    end
+    log "Rest Response:\n#{response.inspect}" if verbose
+    if headers[:accept] == :json
+      parsed_response = JSON.parse(response) rescue nil
+    else
+      parsed_response = response
+    end
+    parsed_response = {"info" => "no data returned"} if parsed_response.nil?
+    result["code"] = response.code
+    if response.code < 300
+      result["status"] = "success"
+      result["data"] = parsed_response
+    elsif response.code == 422
+      result["message"] = "REST call returned code 422 usually a bad token"
+    else
+      result["message"] = "REST call returned HTTP code #{response.code}"
+    end
+    if result["status"] == "ERROR"
+      raise "RestError: #{result["message"]}" unless get_option(options, "suppress_errors") == true
+    end
+    result
+  end
+
+
+  #DEPRECATED: what's the difference with the method with the same name from brpm_automation?
+
+  # Provides a simple failsafe for working with hash options
+  # returns "" if the option doesn't exist or is blank
+  # ==== Attributes
+  #
+  # * +options+ - the hash
+  # * +key+ - key to find in options
+  # * +default_value+ - if entered will be returned if the option doesn't exist or is blank
+  def get_option(options, key, default_value = "")
+    result = options.has_key?(key) ? options[key] : nil
+    result = default_value if result.nil? || result == ""
+    result
+  end
+
+end
+
+extend ResourceFramework
+

data/modules/framework/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