brpm_content_framework 0.1.55

data/tests/params_spec.rb

@@ -0,0 +1,172 @@
+require_relative "spec_helper"
+
+describe 'Params' do
+  before(:each) do
+    cleanup_request_params
+  end
+
+  it 'should get a param' do
+    input_params = get_default_params
+    input_params["key1"] = "value1"
+
+    BrpmAuto.setup(input_params)
+    params = BrpmAuto.params
+
+    expect(params).to have_key("key1")
+    expect(params["key1"]).to eql("value1")
+  end
+
+  it 'should resolve a tokenized param' do
+    input_params = get_default_params
+    input_params["key1"] = "value1"
+    input_params["tokenized_key"] = "The value is rpm{key1}!"
+
+    BrpmAuto.setup(input_params)
+    params = BrpmAuto.params
+
+    expect(params).to have_key("tokenized_key")
+    expect(params["tokenized_key"]).to eql("The value is value1!")
+  end
+
+  it 'should get a param via its dedicated method' do
+    input_params = get_default_params
+    input_params["request_id"] = "123456"
+
+    BrpmAuto.setup(input_params)
+    params = BrpmAuto.params
+
+    expect(params.request_id).to eql("123456")
+  end
+
+  it 'should get the servers' do
+    input_params = get_default_params
+
+    input_params["server1000_name"] = "server1"
+    input_params["server1001_dns"] = "server1.com"
+    input_params["server1002_ip_address"] = "192.168.1.1"
+    input_params["server1003_os_platform"] = "linux"
+
+    input_params["server2000_name"] = "server2"
+    input_params["server2001_dns"] = "server2.com"
+    input_params["server2002_ip_address"] = "192.168.1.2"
+    input_params["server2003_os_platform"] = "linux"
+
+    BrpmAuto.setup(input_params)
+    params = BrpmAuto.params
+
+    expect(params.servers.count).to eql(2)
+
+    expect(params.servers).to have_key("server1")
+
+    expect(params.servers["server1"]).to have_key("dns")
+    expect(params.servers["server1"]["dns"]).to eql("server1.com")
+    expect(params.servers["server1"]).to have_key("ip_address")
+    expect(params.servers["server1"]["ip_address"]).to eql("192.168.1.1")
+    expect(params.servers["server1"]).to have_key("os_platform")
+    expect(params.servers["server1"]["os_platform"]).to eql("linux")
+
+    expect(params.servers).to have_key("server2")
+  end
+
+  it 'should get the servers by os platform' do
+    input_params = get_default_params
+
+    input_params["server1000_name"] = "server1"
+    input_params["server1003_os_platform"] = "linux"
+
+    input_params["server2000_name"] = "server2"
+    input_params["server2003_os_platform"] = "linux"
+
+    input_params["server3000_name"] = "server3"
+    input_params["server3003_os_platform"] = "windows"
+
+    BrpmAuto.setup(input_params)
+    params = BrpmAuto.params
+
+    linux_servers = params.get_servers_by_os_platform("linux")
+    expect(linux_servers.count).to eql(2)
+
+    windows_servers = params.get_servers_by_os_platform("windows")
+    expect(windows_servers.count).to eql(1)
+
+    windows_servers = params.get_servers_by_os_platform("xxx")
+    expect(windows_servers.count).to eql(0)
+  end
+
+  it 'should get a server property' do
+    input_params = get_default_params
+
+    input_params["server1000_name"] = "server1"
+    input_params["server1003_property1"] = "value1"
+
+    BrpmAuto.setup(input_params)
+    params = BrpmAuto.params
+
+    expect(params.get_server_property("server1", "property1")).to eql("value1")
+  end
+
+  it 'should get an encrypted param' do
+    input_params = get_default_params
+
+    #trick it into thinking that it is run from BRPM
+    input_params["run_key"] = "123"
+    input_params["automation_results_dir"] = input_params["output_dir"]
+    input_params["request_id"] = "123"
+    input_params["step_id"] = "123"
+
+    input_params["key1_encrypt"] = "brpm_encrypted"
+    input_params["key2_enc"] = "brpm_encrypted"
+
+    BrpmAuto.setup(input_params)
+    params = BrpmAuto.params
+
+    expect(params["key1"]).to eql("brpm")
+    expect(params["key2"]).to eql("brpm")
+  end
+
+  it 'should get a param by the get method' do
+    input_params = get_default_params
+    input_params["key1"] = "value1"
+
+    BrpmAuto.setup(input_params)
+    params = BrpmAuto.params
+
+    expect(params.get("key1")).to eql("value1")
+  end
+
+  it 'should add a param by the add method' do
+    BrpmAuto.setup(get_default_params)
+    params = BrpmAuto.params
+
+    params.add("key1", "value1")
+
+    expect(params["key1"]).to eql("value1")
+  end
+
+  it 'should find or add a param' do
+    input_params = get_default_params
+    input_params["key1"] = "value1"
+
+    BrpmAuto.setup(input_params)
+    params = BrpmAuto.params
+
+    expect(params.find_or_add("key1", "value1-bis")).to eql("value1")
+    expect(params.count).to eql(input_params.count)
+
+    expect(params.find_or_add("key2", "value2")).to eql("value2")
+    expect(params.count).to eql(input_params.count + 1)
+    expect(params["key2"]).to eql("value2")
+  end
+
+  it 'should calculate the REST request id' do
+    input_params = get_default_params
+    input_params["request_id"] = "1234"
+
+    BrpmAuto.setup(input_params)
+    params = BrpmAuto.params
+
+    expect(params.rest_request_id).to eql("234")
+  end
+end
+
+

data/tests/request_params_spec.rb

@@ -0,0 +1,86 @@
+require_relative "spec_helper"
+
+describe 'Request params' do
+  before(:each) do
+    cleanup_request_params
+  end
+
+  it 'should get a param' do
+    input_request_params = {}
+    input_request_params["key1"] = "value1"
+    set_request_params(input_request_params)
+
+    BrpmAuto.setup(get_default_params)
+    request_params = BrpmAuto.request_params
+
+    expect(request_params).to have_key("key1")
+    expect(request_params["key1"]).to eql("value1")
+  end
+
+  it 'should resolve a tokenized param' do
+    input_request_params = {}
+    input_request_params["key1"] = "value1"
+    input_request_params["tokenized_key"] = "The value is rpm{key1}!"
+    set_request_params(input_request_params)
+
+    BrpmAuto.setup(get_default_params)
+    request_params = BrpmAuto.request_params
+
+    expect(request_params).to have_key("tokenized_key")
+    expect(request_params["tokenized_key"]).to eql("The value is value1!")
+  end
+
+  it 'should get a param by the get method' do
+    input_request_params = {}
+    input_request_params["key1"] = "value1"
+    set_request_params(input_request_params)
+
+    BrpmAuto.setup(get_default_params)
+    request_params = BrpmAuto.request_params
+
+    expect(request_params).to have_key("key1")
+    expect(request_params.get("key1")).to eql("value1")
+  end
+
+  it 'should add a param using []=' do
+    BrpmAuto.setup(get_default_params)
+    request_params = BrpmAuto.request_params
+
+    request_params["key1"] = "value1"
+
+    output_request_params = get_request_params
+
+    expect(output_request_params).to have_key("key1")
+    expect(output_request_params["key1"]).to eql("value1")
+  end
+
+  it 'should add a param by the add method' do
+    BrpmAuto.setup(get_default_params)
+    request_params = BrpmAuto.request_params
+
+    request_params.add("key1", "value1")
+
+    output_request_params = get_request_params
+
+    expect(output_request_params).to have_key("key1")
+    expect(output_request_params["key1"]).to eql("value1")
+  end
+
+  it 'should find or add a param' do
+    input_request_params = {}
+    input_request_params["key1"] = "value1"
+    set_request_params(input_request_params)
+
+    BrpmAuto.setup(get_default_params)
+    request_params = BrpmAuto.request_params
+
+    expect(request_params.find_or_add("key1", "value1-bis")).to eql("value1")
+    expect(request_params.count).to eql(1)
+
+    expect(request_params.find_or_add("key2", "value2")).to eql("value2")
+    expect(request_params.count).to eql(2)
+    expect(request_params["key2"]).to eql("value2")
+  end
+end
+
+

data/tests/server_yaml_spec.rb

@@ -0,0 +1,19 @@
+require_relative "spec_helper"
+
+describe 'Server yaml' do
+  before(:each) do
+    cleanup_request_params
+  end
+
+  it 'should get the parameters' do
+    input_params = get_default_params
+    input_params["home_dir"] = "#{File.dirname(__FILE__)}/customer_include"
+
+    BrpmAuto.setup(input_params)
+
+    params = BrpmAuto.params
+
+    expect(params).to have_key("key2")
+    expect(params["key2"]).to eql("value2")
+  end
+end

data/tests/spec_helper.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+require 'yaml'
+require_relative "../lib/brpm_auto"
+
+FileUtils.mkdir_p "#{ENV["BRPM_HOME"]}/modules" if ENV["BRPM_HOME"]
+FileUtils.mkdir_p "/tmp/brpm_content"
+
+def setup_brpm_auto
+  BrpmAuto.setup(get_default_params)
+end
+
+def get_default_params
+  params = {}
+  params['unit_test'] = 'true'
+  params['also_log_to_console'] = 'true'
+
+  params['brpm_url'] = 'http://brpm-content.pulsar-it.be:8088/brpm'
+  params['brpm_api_token'] = ENV["BRPM_API_TOKEN"]
+
+  params['output_dir'] = "/tmp/brpm_content"
+
+  params
+end
+
+def set_request_params(request_params)
+  File.open("/tmp/brpm_content/request_data.json", "w") do |file|
+    file.puts(request_params.to_json)
+  end
+end
+
+def get_request_params
+  if File.exist?("/tmp/brpm_content/request_data.json")
+    json = File.read("/tmp/brpm_content/request_data.json")
+    JSON.parse(json)
+  else
+    {}
+  end
+end
+
+def cleanup_request_params
+  request_params_file = "/tmp/brpm_content/request_data.json"
+  File.delete(request_params_file) if File.exist?(request_params_file)
+end
+
+def decrypt_string_with_prefix(input) # mocked method
+  return nil if input.nil? || !input.kind_of?(String)
+
+  input.gsub("_encrypted", "")
+end
+
+def create_brpm_file
+  if File.exists?("~/.brpm")
+    FileUtils.rm("~/.brpm")
+  end
+
+  params = get_default_params
+  brpm_params = {}
+  brpm_params["brpm_url"] = params["brpm_url"]
+  brpm_params["brpm_api_token"] = params["brpm_api_token"]
+
+  File.open(File.expand_path("~/.brpm"), "w") do |file|
+    file.puts(brpm_params.to_yaml)
+  end
+end

data/to_be_migrated/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

data/to_be_migrated/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/to_be_migrated/local_jirb.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+rlm_base_path = "/Users/brady/Documents/dev_rpm/brpm_brady/brpm/branches/rpm-sustaining/Portal"
+#rlm_base_path = "/opt/bmc/rlm4"
+script_support = "#{rlm_base_path}/lib/script_support"
+persist = "/Users/brady/Documents/dev_rpm/brpm_content/modules/framework"
+FileUtils.cd script_support, :verbose => true
+require "#{script_support}/ssh_script_header"
+
+input_file = "#{rlm_base_path}/public/automation_results/request/Sales-Billing/1304/step_3722/sshinput_6_1433379304.txt"
+
+script_params = params = load_input_params(input_file)
+Token = "a56d64cbcffcce91d306670489fa4cf51b53316c"
+
+require "#{persist}/brpm_framework.rb"
+@rest = BrpmRest.new(@rpm.params.brpm_url)

data/to_be_migrated/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
+