brpm_content 0.1.16

data/modules/framework/tests/customer_include/config/customer_include.rb

@@ -0,0 +1,10 @@
+def get_customer_include_params
+  params = {}
+  params["key1"] = "value1"
+
+  params
+end
+
+def my_custom_method(a, b)
+  a + b
+end

data/modules/framework/tests/customer_include/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
+key2: "value2"

data/modules/framework/tests/customer_include_spec.rb

@@ -0,0 +1,29 @@
+require_relative "spec_helper"
+
+describe 'Customer include' 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("key1")
+    expect(params["key1"]).to eql("value1")
+  end
+
+  it 'should execute a custom method' do
+    input_params = get_default_params
+    input_params["home_dir"] = "#{File.dirname(__FILE__)}/customer_include"
+
+    BrpmAuto.setup(input_params)
+
+    expect(defined?(my_custom_method)).to eql("method")
+    expect(my_custom_method("a", "b")).to eql("ab")
+  end
+end

data/modules/framework/tests/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/modules/framework/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/modules/framework/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/modules/framework/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/modules/framework/tests/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+require_relative "../brpm_auto"
+
+FileUtils.mkdir_p "/tmp/brpm_content"
+
+def setup_brpm_auto
+  BrpmAuto.setup(get_default_params)
+end
+
+def get_default_params
+  params = {}
+  params['also_log_to_console'] = 'true'
+  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

data/modules/framework/transport/dispatch_baa.rb

@@ -0,0 +1,355 @@
+# dispatch_srun.rb
+#  Module for action dispatch with nsh protocol
+libDir = File.expand_path(File.dirname(__FILE__))
+require "#{libDir}/dispatch_base"
+
+
+class DispatchBAA < DispatchBase
+  # Initialize the class
+  #
+  # ==== Attributes
+  #
+  # * +baa_object+ - handle to an BAA object
+  # * +options+ - hash of options to use, send "output_file" to point to the logging file
+  # * +test_mode+ - true/false to simulate commands instead of running them
+  #
+  def initialize(baa_object, options = {}, compat_options = {})
+    self.extend Utilities
+    if options.has_key?("SS_output_dir")
+      BrpmAuto.log "Load for this class has changed, no longer necessary to send params as 2nd argument"
+      options = compat_options 
+    end
+    @baa = baa_object
+    @verbose = get_option(options, "verbose", false)
+    @output_dir = get_param("SS_output_dir")
+  end
+    
+  # Packages passed references in BAA using a component template
+  # --- note: artifacts all need to reside on the same server
+  # --- note: end a directory path with a / or it will be treated as a file
+  
+  # ==== Attributes
+  #
+  # * +artifact_list+ - array of file/nsh paths
+  # * +group_path+ - path in Blade to store package
+  # * +artifacts+ - array of file/nsh paths
+  # * +options+ - hash of options, includes:
+  #    package_name - to override default package name (component_request_id_version),
+  #    group_path - to override default group_path (app/version/component),
+  #    transfer_properties - hash of properties to transfer
+  #    version - to override use of component version
+  #
+  # ==== Returns
+  #
+  # * hash - {package_id, status, template_db_key, stagin_server}
+  def package_artifacts(artifact_list, options = {})
+    version = get_option(options,"version", get_param("step_version"))
+    package_name = get_option(options, "package_name", default_item_name(version))
+    group_path = get_option(options, "group_path", default_group_path(version))
+    transfer_properties = get_option(options, "transfer_properties", {})
+    path_property_name = get_option(options, "BAA_PATH_PROPERTY", "BAA_BASE_PATH")
+    path_property_value = get_option(transfer_properties, path_property_name, nil)
+    path_property = "#{path_property_name}=#{path_property_value}"
+    message_box "Packaging Files via BAA"
+    log "\t StagingPath: #{group_path}"
+    result = {"status" => "ERROR", "group_path" => group_path, "package_name" => package_name}
+    artifact_hash = {}
+    artifact_list.each{|l| artifact_hash[l] = l.end_with?("/") ? "directory" : "file" }
+    pair = split_nsh_path(artifact_hash.keys.first)
+    raise "Command_Failed: no staging server in artifacts" if pair[0].length < 2
+    staging_server = pair[0]
+    result["staging_server"] = staging_server
+    group_id = @baa.ensure_group_path(group_path, "Template")
+    templates_in_path = @baa.get_group_items(group_path, "Template", true, options)
+    cur_templates = templates_in_path.map{|l| l["name"] }
+    if cur_templates.include?(package_name)
+      log "#=> Component Template exists: #{package_name}"
+      template_id = templates_in_path[cur_templates.index(package_name)]["dbKey"]
+    else # Create a new one
+      log "#=> Create Component Template: #{package_name}"
+      template_id = @baa.create_empty_template(package_name, group_id)
+      log "\tApplying properties...to template with id #{template_id}" if transfer_properties.size > 0
+      template_id = @baa.set_template_properties(package_name, group_path, transfer_properties) if transfer_properties.size > 0
+    end
+    log "\tAdd content to template #{template_id}\nPath property: #{path_property}"
+    template_options = {}
+    template_options["path_property"] = path_property unless path_property_value.nil?
+    template_id = @baa.add_template_content(template_id, artifact_hash, template_options)
+    result["template_db_key"] = template_id
+    raise "Command_Failed: #{template_id}" if template_id.start_with?("ERROR")
+    log "#=> Create component package: #{staging_server}\n"
+    depot_group_id = @baa.ensure_group_path(group_path, "BlPackage")
+    package_id = @baa.create_component_package(package_name, depot_group_id, template_id, staging_server)
+    raise "Command_Failed: #{package_id}" if package_id.start_with?("ERROR")
+    result["status"] = "SUCCESS"
+    result["path_property"] = path_property unless path_property_value.nil?
+    result["package_id"] = package_id
+    result["instance_path"] = "#{group_path}/#{package_name}"
+    result["md5"] = "000"
+    result
+  end
+  
+  # Deploys an existing Package in BAA to target servers
+  #
+  # ==== Attributes
+  #
+  # * +package_id+ - id of existing package
+  # * +options+ - hash of options, includes:
+  #    job_name - to override the default job name,
+  #    group_path - to override the default group path,
+  #    execute_now - (true/false to execute the job immediately default - true),
+  #    transfer_properties (hash of name/values to set),
+  #    version - to override use of component version
+  #
+  # ==== Returns
+  #
+  # * hash of job results, includes - job_run_id, job_status
+  def deploy_package_instance(package_info, options = {})
+    package_id = package_info["package_id"]
+    path_property = get_option(package_info,"path_property", nil)
+    version = get_option(options,"version", get_param("SS_component_version"))
+    execute_now = get_option(options,"execute_now", true)
+    job_base_name = get_option(options, "job_name", default_item_name(version))
+    group_path = get_option(options, "group_path", default_group_path(version, true))
+    transfer_properties = get_option(options, "transfer_properties", {})
+    unless path_property.nil?
+      package_property = path_property.split("=")[0]
+      deploy_property = "#{package_property}_DEPLOY"
+      log "\t No corresponding deploy property for #{package_property} (should be #{deploy_property})", "WARN" if !transfer_properties.has_key?(deploy_property)
+      transfer_properties[package_property] = transfer_properties[deploy_property] if transfer_properties.has_key?(deploy_property)
+    end
+    message_box "Packaging Files via BAA"
+    log "\t StagingPath: #{group_path}"
+    result = {"status" => "ERROR", "results" => "", "group_path" => group_path, "job_names" => []}
+    raise "ERROR: No servers found" if get_server_list.empty?
+    log "\tBuilding group path..."
+    job_group_id = @baa.ensure_group_path(group_path, "Jobs")
+    # Loop through the platforms
+    OS_PLATFORMS.each do |os, os_details|
+      servers = BrpmAuto.params.get_servers_by_os_platform(os)
+      message_box "OS Platform: #{os_details["name"]}"
+      log "No servers selected for: #{os_details["name"]}" if servers.size == 0
+      next if servers.size == 0
+      job_name = "#{job_base_name}_#{os}"
+      result["job_names"] << job_name
+      log "#=> Building Job from Package:\n\tGroup: #{group_path}\n\tPackage: #{package_id}"
+      log "# #{os_details["name"]} - Targets: #{servers.inspect}"
+      targets = @baa.baa_soap_map_server_names_to_rest_uri(server_dns_names(servers))
+      log "\tCreating package job..."
+      cur_jobs = @baa.execute_cli_command("Job","listAllByGroup",[group_path])
+      if cur_jobs.split("\n").include?(job_name)
+        log "\tJob Exists: deleting..."
+        ans = @baa.execute_cli_command("DeployJob","deleteJobByGroupAndName",[group_path, job_name])
+      end
+      job_db_key = @baa.create_package_job(job_name, job_group_id, package_id, server_dns_names(servers))
+      if job_db_key.start_with?("ERROR")
+        log job_db_key
+        raise "Command_Failed: job creation failed"
+      end
+      result["job_db_key"] = job_db_key
+      result["status"] = "JOB_CREATED_SUCCESSFULLY"
+      log "\tApplying properties..."
+      prop_results = @baa.set_job_properties(job_name, group_path, transfer_properties)
+      result["property_results"] = prop_results
+      if execute_now
+        log "#=> Executing Job"
+        execute_results = @baa.execute_job_with_results(job_db_key, result)
+        result["results"] += "#{os} - #{execute_results}"
+        execute_results.each{|k,v| log("#{k}: #{v}")}
+      end
+    end
+    result
+  end
+
+  # Creates an NSH Script Job in BAA to target servers
+  #
+  # ==== Attributes
+  #
+  # * +script_name+ - name of nsh script
+  # * +script_group+ - path in depot to script
+  # * +job_params+ - array of params (in order) for script job
+  # * +options+ - hash of options, includes: execute_now,
+  #    num_par_proces (max parallel processes), 
+  #    target_type (servers/groups),
+  #    job_name - to override the default job name,
+  #    group_path - to override the default group path,
+  #    version - to override use of component version
+  #
+  # ==== Returns
+  #
+  # * hash of job results, includes - job_run_id, job_status
+  def create_nsh_script_job(script_name, script_group, job_params, options = {})
+    result = {"status" => "ERROR"}
+    job_type = "NSHScriptJob"
+    version = get_option(options,"version", get_param("SS_component_version"))
+    targets = get_option(options, "servers")
+    if targets == ""
+      servers = get_server_list 
+      targets = server_dns_names(servers)
+    end
+    script_group = "/#{script_group}" unless script_group.start_with?("/")
+    num_par_procs = get_option(options,"num_par_procs", 50)
+    execute_now = get_option(options,"execute_now", false)
+    target_type = get_option(options,"target_type", "servers")
+    job_name = get_option(options, "job_name", default_item_name)
+    group_path = get_option(options, "group_path", default_group_path(version, true))
+    log "\tBuilding group path..."
+    job_group_id = @baa.ensure_group_path(group_path, "Jobs")
+    args = [
+      group_path, #jobGroup
+      job_name,  #jobName
+      "Script job from automation", #description
+      script_group,
+      script_name,
+      num_par_procs # number of parallel processes
+      ]
+    ss_job_key = @baa.execute_cli_command(job_type,"createNSHScriptJob",args)
+    raise "Command_Failed: cannot create job: #{ss_job_key}" if ss_job_key.include?("ERROR")
+    log "Created: #{job_name} in group: #{group_path}"
+    #targets.collect!{|k| k.gsub(/^\//,"/Servers/") unless k.start_with?("/Servers") }
+    #c. Make the call to addTargetGroup (should be a new method)
+    if targets.is_a?(String) || targets.size < 2
+      method_call = target_type == "servers" ? "addTargetServer" : "addTargetGroup"
+      servers = targets.first if targets.is_a?(Array)
+    else
+      method_call = target_type == "servers" ? "addTargetServers" : "addTargetGroups" 
+      servers = targets.join(",")
+    end
+    ss_job_key = @baa.execute_cli_command("Job", method_call,
+            [
+              ss_job_key,       #jobName
+              servers     #comma separated list of groups
+            ]) 
+    raise "Command_Failed: cannot add targets: #{ss_job_key}" if ss_job_key.include?("ERROR")
+    if execute_now
+      param_result = @baa.set_nsh_script_params(job_name, group_path, job_params, false)
+      raise "Command_Failed: cannot set job parameters: #{param_result}" if param_result.include?("ERROR")
+      execute_result = @baa.execute_job_with_results(param_result["job_db_key"], result)
+      raise "Command_Failed: cannot execute job: #{execute_result.inspect}" if execute_result["status"].include?("ERROR")
+    end
+    result["job_db_key"] = ss_job_key
+    result["status"] = "SUCCESS"
+    result
+  end
+  
+  # Wrapper to run a shell action
+  # opens passed script path, or executes passed text
+  # processes the script in erb first to allow param substitution
+  # note script may have keyword directives (see additional docs) 
+  # uses BAA_FRAMEWORK_NSH_SCRIPT to locate the nsh_script
+  # ==== Attributes
+  #
+  # * +script_file+ - the path to the script or the text of the script
+  # * +options+ - hash of options, includes: 
+  #    servers - to override step servers
+  #    version - to override use of component version
+  #    nsh_script_name - name of nsh_script to call
+  #    nsh_script_group - group path of nsh script
+  # ==== Returns
+  #
+  # action output
+  #
+  def execute_script(script_file, options = {})
+    # get the body of the action
+    content = File.open(script_file).read
+    seed_servers = get_option(options, "servers")
+    transfer_properties = get_option(options, "transfer_properties",{})
+    nsh_script_group = get_option(options, "nsh_script_group")
+    nsh_script_name = get_option(options, "nsh_script_name")
+    version = get_option(options,"version", get_param("SS_component_version"))
+    group_path = get_option(options, "group_path", default_group_path(version, true))
+    job_name = get_option(options, "job_name", default_item_name)
+    if nsh_script_name == "" && defined?(BAA_FRAMEWORK_NSH_SCRIPT)
+      log "Using BAA_FRAMEWORK_NSH_SCRIPT defined in customer_include"
+      nsh_script_group = File.dirname(BAA_FRAMEWORK_NSH_SCRIPT)
+      nsh_script_name = File.basename(BAA_FRAMEWORK_NSH_SCRIPT)
+    else
+      raise "Command_Failed: BAA_FRAMEWORK_NSH_SCRIPT must be defined in customer_include.rb"
+    end    
+    keyword_items = get_keyword_items(content)
+    log "\tBuilding group path..."
+    job_group_id = @baa.ensure_group_path(group_path, "Jobs")
+    params_filter = keyword_items.has_key?("RPM_PARAMS_FILTER") ? keyword_items["RPM_PARAMS_FILTER"] : DEFAULT_PARAMS_FILTER
+    transfer_properties.merge!(get_transfer_properties(params_filter, strip_prefix = true))
+    log "#----------- Executing Script on Remote Hosts -----------------#"
+    log "# Script: #{script_file}"
+    result = "No servers to execute on"
+    # Loop through the platforms
+    OS_PLATFORMS.each do |os, os_details|
+      servers = BrpmAuto.params.get_servers_by_os_platform(os) if seed_servers == ""
+      servers = BrpmAuto.params.get_servers_by_os_platform(os, seed_servers) if seed_servers != ""
+      message_box "OS Platform: #{os_details["name"]}"
+      log "No servers selected for: #{os_details["name"]}" if servers.size == 0
+      next if servers.size == 0
+      log "# #{os_details["name"]} - Targets: #{servers.inspect}"
+      log "# Setting Properties:"
+      add_channel_properties(transfer_properties, servers, os)
+      brpd_compatibility(transfer_properties)
+      transfer_properties.each{|k,v| log "\t#{k} => #{v}" }
+      shebang = read_shebang(os, content)
+      log "Shebang: #{shebang.inspect}"
+      wrapper_path = build_wrapper_script(os, shebang, transfer_properties, {"script_target" => File.basename(script_file)})
+      log "# Wrapper: #{wrapper_path}"
+      target_path = @baa.nsh_path(transfer_properties["RPM_CHANNEL_ROOT"])
+      log "# Copying script to target: "
+      clean_line_breaks(os, script_file, content)
+      files_to_deploy = ["//#{BAA_RPM_HOSTNAME}#{script_file}", "//#{BAA_RPM_HOSTNAME}#{wrapper_path}"]
+      result = @baa.create_file_deploy_job(job_name, group_path, files_to_deploy, target_path, server_dns_names(servers), {"execute_now" => true})
+      result.each{|k,v| log("#{k}: #{v}") }
+      log "# Executing script on target via wrapper:"
+      job_params = [@params["SS_application"], 
+        @params["SS_component"], 
+        @params["SS_environment"], 
+        @params["SS_component_version"],
+        @params["request_id"],
+        target_path,
+        File.basename(wrapper_path)
+        ]
+      result = create_nsh_script_job(nsh_script_name, nsh_script_group, job_params, {"servers" => server_dns_names(servers), "execute_now" => true})
+      result.each{|k,v| log("#{k}: #{v}") }
+    end
+    result
+  end
+  
+  # Creates a group path for BAA storage
+  # optionally uses BAA_BASE_GROUP from customer_include, otherwise "BRPM"
+  #
+  # ==== Attributes
+  #
+  # * +version+ - version name
+  # * +deploy+ - true if path is for deploy and hence needs environment tag
+  #
+  # ==== Returns
+  #
+  # * group_path string
+  def default_group_path(version = nil, deploy = false)
+    base_grp = defined?(BAA_BASE_GROUP) ? BAA_BASE_GROUP : "BRPM"
+    version = precision_timestamp if version.nil? || version == ""
+    result = "/#{base_grp}/#{get_param("SS_application")}/#{version}/#{get_param("SS_component")}"
+    result.gsub!(version,"#{version}/#{get_param("SS_environment")}") if deploy
+    result
+  end
+  
+  # Creates a unique item name for BAA storage
+  #
+  # ==== Attributes
+  #
+  # * +version+ - version name
+  #
+  # ==== Returns
+  #
+  # * item name string
+  def default_item_name(version = nil)
+    version = precision_timestamp if version.nil? || version == ""
+    "#{get_param("SS_component")}_nsh_#{get_param("request_id")}_#{version}"
+  end
+
+end
+
+require "#{@params["SS_script_support_path"]}/baa_utilities"
+@rpm.log "Initializing BAA transport"
+baa_path = defined?(BAA_BASE_PATH) ? BAA_BASE_PATH : "/opt/bmc/bladelogic"
+baa_url = defined?(SS_integration_dns) ? SS_integration_dns : "http://unknownBladelogicServerSetIntegration"
+@baa = TransportBAA.new(baa_url)
+@rpm.log "Path to BAA: #{BAA_BASE_PATH}"
+@transport = DispatchBAA.new(@baa)