lib/paraduct/runner.rb in paraduct-0.0.1.beta3 vs lib/paraduct/runner.rb in paraduct-0.0.1.beta4

@@ -1,50 +1,79 @@
 module Paraduct
   require "open3"
 
-  class ProcessError < StandardError
-    attr_reader :status
+  class Runner
+    attr_reader :script, :params, :base_job_dir
 
-    # @param message [String] stdout and stderr
-    # @param status  [Process::Status]
-    def initialize(message, status)
-      super(message)
-      @status = status
+    # @param args
+    # @option args :script [String, Array<String>] script file, script(s)
+    # @option args :params [Hash{String => String}] key is capitalized and value is quoted (ex. foo=1 => FOO="1" )
+    # @option args :base_job_dir [String]
+    def initialize(args={})
+      @script       = args[:script]
+      @params       = args[:params]
+      @base_job_dir = args[:base_job_dir]
     end
-  end
 
-  class Runner
+    def setup_dir
+      FileUtils.mkdir_p(job_dir) unless job_dir.exist?
+      self.class.copy_recursive(Paraduct.config.root_dir, job_dir)
+      Dir.chdir(job_dir)
+    end
+
     # run script with params
-    # @param script [String, Array<String>] script file, script(s)
-    # @param params [Hash{String => String}] key is capitalized and value is quoted (ex. foo=1 => FOO="1" )
     # @return [String] stdout
     # @raise [Paraduct::ProcessError] command exited error status
-    def self.perform(script, params)
-      variable_string = capitalize_keys(params).map{ |key, value| %(export #{key}="#{value}";) }.join(" ")
+    def perform
+      variable_string = key_capitalized_params.map{ |key, value| %(export #{key}="#{value}";) }.join(" ")
 
-      Array.wrap(script).inject("") do |stdout, command|
+      Array.wrap(@script).inject("") do |stdout, command|
         stdout << run_command("#{variable_string} #{command}")
         stdout
       end
     end
 
-    def self.parameterized_job_dir(base_job_dir, params)
-      dir_name = capitalize_keys(params).map{ |key, value| "#{key}_#{value}" }.join("_")
-      Pathname(base_job_dir).join(dir_name)
+    def job_dir
+      Pathname(@base_job_dir).join(job_name)
     end
 
-    def self.run_command(command)
-      stdout, stderr, status = Open3.capture3(command)
-      raise ProcessError.new("#{stdout}\n#{stderr}", status) unless status.success?
-      stdout
+    def job_name
+      key_capitalized_params.map { |key, value| "#{key}_#{value}" }.join("_")
     end
-    private_class_method :run_command
 
+    def key_capitalized_params
+      self.class.capitalize_keys(@params)
+    end
+
+    def formatted_params
+      @params.map{ |key, value| "#{key}=#{value}" }.join(", ")
+    end
+
+    # @param source_dir      [Pathname]
+    # @param destination_dir [Pathname]
+    def self.copy_recursive(source_dir, destination_dir)
+      FileUtils.mkdir_p(destination_dir)
+      source_dir.children.each do |source_child_dir|
+        begin
+          FileUtils.cp_r(source_child_dir, destination_dir)
+        rescue ArgumentError => e
+          # TODO: refactoring
+          raise unless e.message =~ /^cannot copy directory .+ to itself /
+        end
+      end
+    end
+
     def self.capitalize_keys(params)
       params.inject({}) do |res, (key, value)|
         res[key.upcase] = value
         res
       end
     end
-    private_class_method :capitalize_keys
+
+    private
+    def run_command(command)
+      stdout, stderr, status = Open3.capture3(command)
+      raise Paraduct::ProcessError.new("#{stdout}\n#{stderr}", status) unless status.success?
+      stdout
+    end
   end
 end