brpm_content_framework 0.1.55

data/transport/dispatch_base.rb

@@ -0,0 +1,345 @@
+# dispatch_base.rb
+#  Module for action dispatch common methods
+require 'digest/md5'
+
+DEFAULT_PARAMS_FILTER = "ENV_" if !defined?(DEFAULT_PARAMS_FILTER)
+STANDARD_PROPERTIES = ["SS_application", "SS_component", "SS_environment", "SS_component_version", "SS_request_number"]
+OS_PLATFORMS = {
+  "win" => {"name" => "Windows", "tmp_dir" => "/C/Windows/temp"},
+  "nix" => {"name" => "Unix", "tmp_dir" => "/tmp"},
+  "nux" => {"name" => "Linux", "tmp_dir" => "/tmp"}}
+
+
+class DispatchBase
+  # Initialize the class
+  #
+  # ==== Attributes
+  #
+  # * +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(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 1st argument"
+      options = compat_options 
+    end
+    @verbose = get_option(options, "verbose", false)
+    @output_dir = BrpmAuto.params.output_dir
+  end
+
+  # Builds a hash of properties to transfer to target
+  # 
+  # ==== Attributes
+  #
+  # * +keyword_filter+ - filter for params (param selected if filter included in key)
+  # * +strip_filter+ - removes filter text from resulting key
+  # ==== Returns
+  #
+  # hash of properties to transfer
+  #
+  def get_transfer_properties(keyword_filter = DEFAULT_PARAMS_FILTER, strip_filter = true)
+    result = {}
+    STANDARD_PROPERTIES.each{|prop| result[prop.gsub("SS_","RPM_")] = BrpmAuto.params[prop] }
+    BrpmAuto.params.each{|k,v| result[strip_filter ? k.gsub(keyword_filter,"") : k] = v if k.include?(keyword_filter) }
+    result
+  end
+
+  # Add BRPD-like params to transfer_properties
+  # 
+  # ==== Attributes
+  #
+  # * +props+ - the existing transfer properties hash
+  # * +payload_path+ - the path for any previously delivered content
+  # * +target_dir+ - the delivery directory on the target
+  # ==== Returns
+  #
+  # nothing - modifies passed property hash
+  #
+  def brpd_compatibility(props, payload_path = nil, servers = nil)
+     props["VL_CONTENT_PATH"] = payload_path if payload_path
+     props["VL_CONTENT_NAME"] = File.basename(payload_path)  if payload_path
+     props["VL_CHANNEL_ROOT"] = props["RPM_CHANNEL_ROOT"]
+     props["VL_DISPATCH_TARGET_HOST"] = servers.nil? ? get_server_list.keys[0] : servers.first[0]
+  end
+
+  # Add server properties to transfer properties
+  # 
+  # ==== Attributes
+  #
+  # * +props+ - the existing transfer properties hash
+  # * +servers+ - hash of server properties
+  # * +os_platform+ - os platform
+  # ==== Returns
+  #
+  # nothing - modifies passed property hash
+  #
+  def add_channel_properties(props, servers, os_platform = "win")
+     s_props = servers.first[1]
+     base_dir = s_props["CHANNEL_ROOT"] if s_props.has_key?("CHANNEL_ROOT")
+     base_dir ||= s_props["base_dir"] if s_props.has_key?("base_dir")
+     base_dir ||= OS_PLATFORMS[os_platform]["tmp_dir"]
+     props["RPM_CHANNEL_ROOT"] = base_dir
+  end
+  
+  # Removes carriage returns for unix compatibility
+  # Opens passed script path, modifies and saves file
+  # ==== Attributes
+  #
+  # * +os_platform+ - os platform
+  # * +script_file+ - path to script to modify
+  # * +contents+ - optional - if passed will replace the content in script_file
+  # ==== Returns
+  #
+  # path to modified script
+  #
+  def clean_line_breaks(os_platform, script_file, contents = nil)
+    return if os_platform =~ /win/
+    contents = File.open(script_file).read if contents.nil?
+    fil = File.open(script_file,"w+")
+    fil.puts contents.gsub("\r", "")
+    fil.flush
+    fil.close
+    script_file
+  end
+  
+  # Creates a temp file in output dir
+  # returns path to temp file
+  # ==== Attributes
+  #
+  # * +content+ - content for file
+  # * +options+ - hash of options, includes ext to force the file extension e.g. {"ext" => ".sql"}
+  # ==== Returns
+  #
+  # path to file
+  #
+  def make_temp_file(content, platform = "linux", options = {})
+    ext = get_option(options, "ext")
+    if ext == ""
+      ext = platform.downcase == "linux" ? ".sh" : ".bat"
+    end
+    file_path = File.join(BrpmAuto.params["SS_output_dir"],"shell_#{precision_timestamp}#{ext}")
+    fil = File.open(file_path, "w+")
+    fil.puts content
+    fil.flush
+    fil.close
+    file_path
+  end
+
+  # Builds the wrapper script for the target
+  # sets environment variables and call to run target script
+  # follows platform directives or shebang information
+  #
+  # ==== Attributes
+  #
+  # * +os_platform+ - os platform
+  # * +shebang+ - hash of processed shebang
+  # * +properties+ - hash of properties to become environment variables
+  # * +options+ - hash of optionss, includes script_target - what the wrapper will call 
+  # ==== Returns
+  #
+  # path to wrapper script
+  #
+  def build_wrapper_script(os_platform, shebang, properties, options = {})
+    msg = "Environment variables from BRPM"
+    wrapper = "srun_wrapper_#{precision_timestamp}"
+    alt_target = get_option(options,"script_target")
+    cmd = shebang["cmd"]
+    target = alt_target == "" ? File.basename(get_param("SS_script_file")) : alt_target
+    cmd = cmd.gsub("%%", target) if shebang["cmd"].end_with?("%%")
+    cmd = "#{cmd} #{target}" unless shebang["cmd"].end_with?("%%")
+    if os_platform =~ /win/
+      properties["RPM_CHANNEL_ROOT"] = dos_path(properties["RPM_CHANNEL_ROOT"])
+      properties["VL_CHANNEL_ROOT"] = properties["RPM_CHANNEL_ROOT"]
+      wrapper = "#{wrapper}.bat"
+      script = "@echo off\r\necho |hostname > junk.txt\r\nset /p HOST=<junk.txt\r\necho y|del junk.txt\r\n"
+      script += "echo ============== HOSTNAME: %HOST% ==============\r\n"
+      script += "echo #{msg} \r\n"
+      properties.each{|k,v| script += "set #{k}=#{v}\r\n" }
+      script += "echo Execute the file\r\n"
+      script += "cd %RPM_CHANNEL_ROOT%\r\n"
+      script += "#{cmd}\r\n"
+      script += "echo EXIT_CODE: %errorlevel%\r\n"
+      script += "timeout /t <5> /nobreak\r\n"
+      script += "echo y|del #{target}\r\n"
+    else
+      wrapper = "#{wrapper}.sh"
+      script = "echo \"============== HOSTNAME: `hostname` ==============\"\n"
+      script += "echo #{msg} \n"
+      properties.each{|k,v| script += "export #{k}=\"#{v}\"\n" }
+      script += "echo Execute the file\n"
+      script += "cd $RPM_CHANNEL_ROOT\n"
+      script += "#{cmd}\n"
+      script += "echo EXIT_CODE: $?\n"
+      script +=  "sleep 2\nrm -f #{target}"    
+    end
+    fil = File.open(File.join(@output_dir, wrapper),"w+")
+    fil.puts script
+    fil.flush
+    fil.close
+    File.join(@output_dir, wrapper)
+  end
+
+  # Builds the wrapper script for a single command
+  #
+  # ==== Attributes
+  #
+  # * +command+ - command to execute e.g. unzip
+  # * +os_platform+ - os platform
+  # * +source_path+ - path to source file (local)
+  # * +target_path+ - destination path on target server
+  # ==== Returns
+  #
+  # path to wrapper script
+  #
+  def create_command_wrapper(command, os_platform, source_path, target_path)
+    msg = "Environment variables from BRPM"
+    wrapper = "srun_wrapper_#{precision_timestamp}"
+    target = File.basename(source_path)
+    if os_platform =~ /win/
+      target_path = dos_path(target_path)
+      wrapper = "#{wrapper}.bat"
+      script = "@echo off\r\necho |hostname > junk.txt\r\nset /p HOST=<junk.txt\r\necho y | del junk.txt\r\n"
+      script += "echo ============== HOSTNAME: %HOST% ==============\r\n"
+      script += "echo #{msg} \r\n"
+      script += "set RPM_CHANNEL_ROOT=#{target_path}\r\n"
+      script += "echo Execute the file\r\n"
+      script += "cd %RPM_CHANNEL_ROOT%\r\n"
+      script += "#{command} #{target}\r\n"
+      script += "echo EXIT_CODE: %errorlevel%\r\n"
+      script += "timeout /t <5> /nobreak\r\n"
+      script += "echo y|del #{target}\r\n"
+    else
+      wrapper = "#{wrapper}.sh"
+      script = "echo \"============== HOSTNAME: `hostname` ==============\"\n"
+      script += "echo #{msg} \n"
+      script += "export RPM_CHANNEL_ROOT=\"#{target_path}\"\n"
+      script += "echo Execute the file\n"
+      script += "cd $RPM_CHANNEL_ROOT\n"
+      script += "#{command} #{target}\n"    
+      script += "echo EXIT_CODE: $?\n"
+      script += "sleep 2\nrm -f #{target}"    
+    end
+    fil = File.open(File.join(@output_dir, wrapper),"w+")
+    fil.puts script
+    fil.flush
+    fil.close
+    File.join(@output_dir, wrapper)
+  end
+
+  # Builds the list of files for deployment
+  #  assumes that there are 3 sources: version, path entry and uploads
+  # ==== Attributes
+  #
+  # * +p_obj+ - a handle to the current params object
+  # * +options+ - hash of options including:
+  #
+  # ==== Returns
+  #
+  # array of nsh paths
+  #
+  def get_artifact_paths(p_obj, options = {})
+    files_to_deploy = []
+    artifact_path = p_obj.get("step_version_artifact_url", nil)
+    artifact_paths = p_obj.split_nsh_path(artifact_path) unless artifact_path.nil?
+    path_server = artifact_path.nil? ? "" : artifact_paths[0]
+    version = p_obj.get("step_version")    
+    staging_server = p_obj.get("staging_server", path_server)
+    brpm_hostname = p_obj.get("SS_base_url").gsub(/^.*\:\/\//, "").gsub(/\:\d.*/, "")
+    files_to_deploy << p_obj.get_attachment_nsh_path(brpm_hostname, p_obj.get("Upload Action File")) unless p_obj.get("Upload Action File") == ""
+    files_to_deploy << p_obj.get_attachment_nsh_path(brpm_hostname, p_obj.uploadfile_1) unless p_obj.uploadfile_1 == ""
+    files_to_deploy << p_obj.get_attachment_nsh_path(brpm_hostname, p_obj.uploadfile_2) unless p_obj.uploadfile_2 == ""
+    entered_paths = p_obj.get("nsh_paths", p_obj.get("artifact_paths"))
+    if entered_paths != ""
+      staging_server = "none"
+      entered_paths.split(',').each do |path|
+        ans = p_obj.split_nsh_path(path)
+        staging_server = ans[0] if ans[0].length > 2
+        files_to_deploy << "//#{staging_server}#{ans[1].strip}" if ans[1].length > 2
+      end
+    end
+    unless artifact_path.nil?
+      staging_server = "none"
+      staging_server = artifact_paths[0] if artifact_paths[0].length > 2
+      if artifact_path.start_with?("//")
+        artifact_paths[1].split(',').each do |path|
+          staging = staging_server
+          ans = p_obj.split_nsh_path(path)
+          staging = ans[0] if ans[0].length > 2
+          files_to_deploy << "//#{staging}#{ans[1].strip}" if ans[1].length > 2
+        end
+      else
+        artifact_paths[1].split(',').each do |path|
+          files_to_deploy << path
+        end
+      end
+    end
+    files_to_deploy
+  end  
+  
+  # Packages files from local staging directory
+  # 
+  # ==== Attributes
+  #
+  # * +staging_path+ - path to files
+  # * +version+ - version to assign
+  # ==== Returns
+  #
+  # hash of instance_path and md5 - {"instance_path" => "", "md5" => ""}
+  def package_staged_artifacts(staging_path, version)
+    package_file = "package_#{version}.zip"
+    instance_path = File.join(staging_path, package_file)
+    staging_artifacts = Dir.entries(staging_path).reject{|k| [".",".."].include?(k) }
+    return {"instance_path" => "ERROR - no files in staging area", "md5" => ""} if staging_artifacts.size < 1
+    cmd = "cd #{staging_path} && zip -r #{package_file} *" unless Windows
+    result = execute_shell(cmd)
+    md5 = Digest::MD5.file(instance_path).hexdigest
+    {"instance_path" => instance_path, "md5" => md5, "manifest" => staging_artifacts}
+  end
+
+  # Return the name or dns of servers in a hash list
+  # if dns exists, uses that, otherwise, name
+  # ==== Attributes
+  #
+  # * +servers+ - standard servers hash
+  # ==== Returns
+  #
+  # * array of server dns's
+  # 
+  def server_dns_names(servers)
+    result = []
+    servers.each do |name,props|
+      if props["dns"].length < 3 || props["dns"].start_with?("http")
+        result << name
+      else
+        result << props["dns"]
+      end
+    end
+    result
+  end
+  
+  # Returns the short name for the os platform
+  # Send the OS
+  def os_platform(platform, abbrev = true)
+    result = "nux"
+    result = "nix" if platform.downcase =~ /nix/
+    result = "win" if platform.downcase =~ /win/
+    result = {"nux" => "unix", "nix" => "linux", "win" => "windows"}[result] unless abbrev
+    result
+  end
+
+  # Returns plaform information about the first server assigned
+  # (works on teh assumption that all assigned servers are similar!)
+  # ==== Returns
+  #
+  # * hash of server information {"server", "os", "channel_root"}
+  # 
+  def lead_server_info
+    servers = BrpmAuto.params.servers
+    cur = servers.keys.first
+    os = os_platform(servers[cur]["os_platform"], false)
+    channel_root = servers[cur].has_key?("CHANNEL_ROOT") ? servers[cur]["CHANNEL_ROOT"] : (os == "windows" ? "C:\\temp" : "/tmp")
+    server_info = {"server" => cur, "os" => os, "channel_root" => channel_root}
+  end
+    
+end

data/transport/dispatch_nsh.rb

@@ -0,0 +1,248 @@
+# dispatch_srun.rb
+#  Module for action dispatch with nsh protocol
+libDir = File.expand_path(File.dirname(__FILE__))
+require "#{libDir}/dispatch_base"
+
+
+class DispatchNSH < DispatchBase
+  # Initialize the class
+  #
+  # ==== Attributes
+  #
+  # * +nsh_object+ - handle to an NSH 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(nsh_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
+    @nsh = nsh_object
+    @verbose = get_option(options, "verbose", false)
+    @output_dir = BrpmAuto.params["SS_output_dir"]
+  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) 
+  # ==== Attributes
+  #
+  # * +script_file+ - the path to the script or the text of the script
+  # * +options+ - hash of options, includes: 
+  # * +-servers to override step servers
+  # * +-transfer_properties - the properties to push to the wrapper script
+  # * +-transfer_prefix - prefix to grab transfer properties from params 
+  #
+  # ==== 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")
+    loop_servers = get_option(options, "each_server")
+    transfer_properties = get_option(options, "transfer_properties",{})
+    keyword_items = get_keyword_items(content)
+    params_filter = get_option(keyword_items, "RPM_PARAMS_FILTER")
+    params_filter = get_option(options, "transfer_prefix", DEFAULT_PARAMS_FILTER)
+    transfer_properties.merge!(get_transfer_properties(params_filter, strip_prefix = true))
+    BrpmAuto.log "#----------- Executing Script on Remote Hosts -----------------#"
+    BrpmAuto.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 != ""
+      BrpmAuto.message_box "OS Platform: #{os_details["name"]}"
+      BrpmAuto.log "No servers selected for: #{os_details["name"]}" if servers.size == 0
+      next if servers.size == 0      
+      BrpmAuto.log "# #{os_details["name"]} - Targets: #{servers.inspect}"
+      BrpmAuto.log "# Setting Properties:"
+      add_channel_properties(transfer_properties, servers, os)
+      brpd_compatibility(transfer_properties, nil, servers)
+      transfer_properties.each{|k,v| BrpmAuto.log "\t#{k} => #{v}" }
+      shebang = read_shebang(os, content)
+      BrpmAuto.log "Shebang: #{shebang.inspect}"
+      wrapper_path = build_wrapper_script(os, shebang, transfer_properties, {"script_target" => File.basename(script_file)})
+      BrpmAuto.log "# Wrapper: #{wrapper_path}"
+      target_path = @nsh.nsh_path(transfer_properties["RPM_CHANNEL_ROOT"])
+      BrpmAuto.log "# Copying script to target: "
+      clean_line_breaks(os, script_file, content)
+      result = @nsh.ncp(server_dns_names(servers), script_file, target_path)
+      BrpmAuto.log result
+      BrpmAuto.log "# Executing script on target via wrapper:"
+      result = @nsh.script_exec(server_dns_names(servers), wrapper_path, target_path)
+      BrpmAuto.log result
+    end
+    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
+  # this method will separately resolve each server properties and execute in sequence
+  # note script may have keyword directives (see additional docs) 
+  # ==== Attributes
+  #
+  # * +script_file+ - the path to the script or the text of the script
+  # * +options+ - hash of options, includes: 
+  # * +-servers to override step servers
+  # * +-transfer_properties - the properties to push to the wrapper script
+  # * +-transfer_prefix - prefix to grab transfer properties from params 
+  # * +-strip_prefix - remove the prefix or leave it (true/false) 
+  #
+  # ==== Returns
+  #
+  # action output
+  #
+  def execute_script_per_server(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",{})
+    keyword_items = get_keyword_items(content)
+    params_filter = get_option(keyword_items, "RPM_PARAMS_FILTER")
+    params_filter = get_option(options, "transfer_prefix", DEFAULT_PARAMS_FILTER)
+    strip_prefix = get_option(options, "strip_prefix", true)
+    transfer_properties.merge!(get_transfer_properties(params_filter, strip_prefix))
+    BrpmAuto.log "#----------- Executing Script on Remote Hosts -----------------#"
+    BrpmAuto.log "# Script: #{script_file}"
+    result = "No servers to execute on"
+    grouped_result = []
+    # Loop through the platforms
+    OS_PLATFORMS.each do |os, os_details|
+      servers_list = BrpmAuto.params.get_servers_by_os_platform(os) if seed_servers == ""
+      servers_list = BrpmAuto.params.get_servers_by_os_platform(os, seed_servers) if seed_servers != ""
+      BrpmAuto.message_box "OS Platform: #{os_details["name"]}"
+      BrpmAuto.log "No servers selected for: #{os_details["name"]}" if servers_list.size == 0
+      next if servers_list.size == 0      
+      BrpmAuto.log "# #{os_details["name"]} - Targets: #{servers_list.inspect}"
+      servers_list.each do |item|
+        servers = {item[0] => item[1]}
+        BrpmAuto.log "#=> Endpoint: #{servers.keys[0]}"
+        BrpmAuto.log "# Setting Properties:"
+        add_channel_properties(transfer_properties, servers, os)
+        brpd_compatibility(transfer_properties, nil, servers)
+        transfer_properties.each{|k,v| BrpmAuto.log "\t#{k} => #{v}" }
+        shebang = read_shebang(os, content)
+        BrpmAuto.log "Shebang: #{shebang.inspect}"
+        wrapper_path = build_wrapper_script(os, shebang, transfer_properties, {"script_target" => File.basename(script_file)})
+        BrpmAuto.log "# Wrapper: #{wrapper_path}"
+        target_path = @nsh.nsh_path(transfer_properties["RPM_CHANNEL_ROOT"])
+        BrpmAuto.log "# Copying script to target: "
+        clean_line_breaks(os, script_file, content)
+        result = @nsh.ncp(server_dns_names(servers), script_file, target_path)
+        grouped_result << result
+        BrpmAuto.log result
+        BrpmAuto.log "# Executing script on target via wrapper:"
+        result = @nsh.script_exec(server_dns_names(servers), wrapper_path, target_path)
+        grouped_result << result
+        BrpmAuto.log result
+      end
+    end
+    grouped_result.join("\n")
+  end
+
+  # Copies remote files to a local staging repository
+  # 
+  # ==== Attributes
+  #
+  # * +file_list+ - array of nsh_paths
+  # * +options+ - hash of options, includes: version
+  # ==== Returns
+  #
+  # hash of instance_path and md5 - {"instance_path" => "", "md5" => ""}
+  #
+  def package_artifacts(file_list, options = {})
+    version = get_option(options, "version", "")
+    version = "#{get_param("SS_request_number")}_#{precision_timestamp}" if version == ""
+    staging_path = get_staging_dir(version, true)
+    BrpmAuto.message_box "Copying Files to Staging via NSH"
+    BrpmAuto.log "\t StagingPath: #{staging_path}"
+    file_list.each do |file_path|
+      BrpmAuto.log "\t #{file_path}"
+      result = @nsh.ncp(nil, @nsh.nsh_path(file_path), staging_path)
+      BrpmAuto.log "\tCopy Result: #{result}"
+    end
+    package_file = "package_#{version}.zip"
+    @nsh.package_staged_artifacts(staging_path, package_file)
+  end
+  
+  # Deploys a packaged instance based on staging info
+  # staging info is generated by the stage_files routine
+  # ==== Attributes
+  #
+  # * +staging_info+ - hash returned by stage_files 
+  # * +options+ - hash of options, includes allow_md5_mismatch(true/false) and target_path to override server channel_root
+  # ==== Returns
+  #
+  # action output
+  #
+  def deploy_package_instance(staging_info, options = {})
+    mismatch_ok = get_option(options, "allow_md5_mismatch", false)
+    target_path = get_option(options, "target_path")
+    seed_servers = get_option(options, "servers")
+    instance_path = staging_info["instance_path"]
+    BrpmAuto.message_box "Deploying Files to Targets via NSH"
+    return_result = {"payload_path" => "", "results" => "FAILURE"}
+    raise "Command_Failed: no artifacts staged in #{File.dirname(instance_path)}" if Dir.entries(File.dirname(instance_path)).size < 3
+    BrpmAuto.log "\t StagingArchive: #{instance_path}"
+    md5 = Digest::MD5.file(instance_path).hexdigest
+    md5_match = md5 == staging_info["md5"]
+    BrpmAuto.log "\t Checksum: expected: #{staging_info["md5"]} - actual: #{md5}#{md5_match ? " MATCHED" : " NO MATCH"}"
+    raise "Command_Failed: bad md5 checksum match" if !md5_match && !allow_md5_mismatch
+    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 != ""
+      BrpmAuto.message_box "OS Platform: #{os_details["name"]}"
+      BrpmAuto.log "No servers selected for: #{os_details["name"]}" if servers.size == 0
+      next if servers.size == 0
+      BrpmAuto.log "# #{os_details["name"]} - Targets: #{servers.inspect}"
+      target_path = @nsh.nsh_path(target_path) if target_path != ""
+      target_path = @nsh.nsh_path(servers.first[1].has_key?("CHANNEL_ROOT") ? servers.first[1]["CHANNEL_ROOT"] : os_details["tmp_dir"]) if target_path == ""
+      final_path = File.join(target_path, get_param("SS_run_key"))
+      return_result["payload_path"] = File.join(final_path)
+      result = @nsh.script_execute_body(server_dns_names(servers), "mkdir #{final_path}", target_path)
+      BrpmAuto.log result
+      BrpmAuto.log "# Deploying package on target:"
+      result = @nsh.ncp(server_dns_names(servers), instance_path, final_path)
+      BrpmAuto.log result
+      BrpmAuto.log "# Unzipping package on target:"
+      wrapper_path = create_command_wrapper("unzip -o", os, instance_path, final_path)
+      result = @nsh.script_exec(server_dns_names(servers), wrapper_path, final_path)
+      BrpmAuto.log result
+    end
+    result
+  end
+  
+  # Copies remote files to a local staging repository
+  #  
+  # ==== Attributes
+  #
+  # * +source+ - nsh path to source file
+  # * +destination+ - path to destination file
+  # * +options+ - hash of options 
+  #
+  def copy_file(source, destination, options = {})
+    BrpmAuto.message_box "Copying files via NSH"
+    BrpmAuto.log "\t Source: #{source}"
+    BrpmAuto.log "\t Destination: #{destination}"
+    result = @nsh.cp(source, destination)
+    BrpmAuto.log "\tCopy Result: #{result}"
+    result
+  end
+      
+end
+
+@rpm.log "Initializing nsh transport"
+baa_path = defined?(BAA_BASE_PATH) ? BAA_BASE_PATH : "/opt/bmc/bladelogic"
+nsh_path = "#{BAA_BASE_PATH}/NSH"
+@nsh = TransportNSH.new(nsh_path)
+@rpm.log "Path to nsh: #{nsh_path}"
+@transport = DispatchNSH.new(@nsh)