ripe 0.2.0 → 0.2.1

data/lib/ripe/blocks/working_block.rb

@@ -0,0 +1,101 @@
+module Ripe
+
+  module Blocks
+
+    ##
+    # This class represents a {Ripe::CLI::TaskCLI} that has been parametrized.
+    # In the block arborescence, {WorkingBlock}s are always leaf nodes.
+    #
+    # @see Ripe::CLI::TaskCLI
+    # @see Ripe::WorkerController::Preparer#prepare
+
+    class WorkingBlock < Block
+
+      ##
+      # @param filename [String] filename of the template file
+      # @param vars [Hash<Symbol, String>] key-value pairs
+
+      def initialize(filename, vars = {})
+        @filename = filename
+        super(File.basename(@filename), [], vars)
+      end
+
+      ##
+      # Return working block +parameters+ as a sequence of bash variable
+      # assignments.
+      #
+      # @return [String] sequence of bash variable assignments
+
+      def declarations
+        vars.map do |key, value|
+          lh = key.upcase
+          rh = value.is_a?(Array) ? "(\"#{value.join("\" \"")}\")" : "\"#{value}\""
+          "#{lh}=#{rh}"
+        end
+      end
+
+      ##
+      # (see Block#command)
+      #
+      # The resulting string contains the result of the application of
+      # parameters to the +task+ from which the {WorkingBlock} was defined.
+      #
+      # @see Ripe::DB::Task
+      # @see Ripe::DSL::TaskDSL
+
+      def command
+        <<-EOF.gsub(/^[ ]+/, '')
+
+        # <#{id}>
+
+        #{declarations.join("\n")}
+
+        exec 1>"$LOG" 2>&1
+
+        #{File.new(@filename).read}
+        echo "##.DONE.##"
+
+        # </#{id}>
+        EOF
+      end
+
+      ##
+      # (see Block#prune)
+      #
+      # A {WorkingBlock} will be pruned if its targets exists, unless the
+      # +protect+ parameter is set to +true+.
+
+      def prune(protect, depend)
+        targets_exist? && !protect ? nil : self
+      end
+
+      ##
+      # (see Block#targets_exist?)
+      #
+      # For {WorkingBlock}s, if there is so much as a single target -- a block
+      # variable starting with +output_+) that does not exist, return +false+.
+      # Otherwise, return +true+.
+
+      def targets_exist?
+        statuses = @vars.select { |key, _| !key[/^output_/].nil? }.values.flatten
+        targets_exist = statuses.map { |target| File.exists? target }.inject(:&)
+
+        # If there are no targets at all, then assume that all targets exist
+        targets_exist == nil ? true : targets_exist
+      end
+
+      ##
+      # (see Block#topology)
+      #
+      # Since a {WorkingBlock} is always a leaf node in the tree, the subtree
+      # starting at the leaf node only contains the {WorkingBlock}.
+
+      def topology
+        [@id]
+      end
+
+    end
+
+  end
+
+end

data/lib/ripe/cli.rb

@@ -0,0 +1,121 @@
+require 'ripl' # REPL
+require 'hirb' # Pretty output for +ActiveRecord+ objects
+require 'thor'
+
+require_relative '../ripe'
+
+include Ripe
+include Ripe::DB
+include Ripe::DSL
+
+module Ripe
+
+  ##
+  # This class represents the CLI interface to ripe.  The methods defined in
+  # this class are wrappers for the methods defined in +Ripe::Repo+ and
+  # +Ripe::WorkerController+.
+  #
+  # @see Ripe::Repo
+  # @see Ripe::WorkerController
+
+  class CLI < Thor
+
+    desc 'init', 'Initialize ripe repository'
+
+    ##
+    # Initialize ripe repository.
+    #
+    # @see Ripe::Repo#attach_or_create
+
+    def init
+      puts "Initialized ripe repository in #{Dir.pwd}"
+      repo = Repo.new
+      repo.attach_or_create
+    end
+
+
+
+
+
+    desc 'console', 'Launch ripe console'
+
+    ##
+    # Launch ripe console.  It is a REPL bound to the context of a
+    # +Ripe::WorkerController+ initialized in the working directory.
+
+    def console
+      repo = Repo.new
+      repo.attach
+
+      unless repo.has_repository?
+        abort "Cannot launch console: ripe repo not initialized"
+      end
+
+      # Do not send arguments to the REPL
+      ARGV.clear
+
+      Ripl.config[:prompt] = proc do
+        # This is the only place I could think of placing +Hirb#enable+.
+        Hirb.enable unless Hirb::View.enabled?
+        'ripe> '
+      end
+
+      # Launch the REPL session in the context of +WorkerController+.
+      Ripl.start :binding => repo.controller.instance_eval { binding }
+    end
+
+
+
+
+
+    desc 'prepare SAMPLES', 'Prepare jobs from template workflow'
+    option :workflow, :aliases => '-w', :type => :string, :required => true,
+      :desc => 'Workflow to be applied'
+    option :options, :aliases => '-o', :type => :string, :required => false,
+      :desc => 'Options', :default => ''
+    option :start, :aliases => '-s', :type => :boolean, :required => false,
+      :desc => 'Automatically submit the prepared jobs onto the compute cluster', :default => false
+
+    ##
+    # Prepare samples.
+    #
+    # @see Ripe::Repo#controller
+    # @see Ripe::WorkerController#prepare
+
+    def prepare(*samples)
+      repo = Repo.new
+      repo.attach
+
+      unless repo.has_repository?
+        abort 'Cannot launch console: ripe repo not initialized'
+      end
+
+      abort 'No samples specified.' if samples.length == 0
+
+      workers = repo.controller.prepare(options[:workflow], samples,
+                                        Helper.parse_cli_opts(options[:options]))
+
+      repo.controller.start(workers) if options[:start]
+    end
+
+
+
+
+
+    ##
+    # Retrieve ripe version.
+
+    desc 'version', 'Retrieve ripe version'
+    def version
+      puts "ripe version #{Ripe::VERSION}"
+    end
+
+
+
+
+
+  end
+
+end
+
+require_relative 'cli/helper.rb'

data/lib/ripe/cli/helper.rb

@@ -0,0 +1,31 @@
+module Ripe
+
+  class CLI
+
+    ##
+    # This class defines helper methods for +Ripe::CLI+.
+    #
+    # @see Ripe::CLI
+
+    class Helper
+
+      ##
+      # Parses a string representing a hash in the format of +a=1,b=2,c=3+ into a
+      # hash in the format of +{a: 1, b: 2, c: 3}+.
+      #
+      # @param options [String] a hash in the format of +a=1,b=2,c=3+
+      # @return [Hash] a hash in the format of +{a: 1, b: 2, c: 3}+
+
+      def self.parse_cli_opts(options)
+        params = options.split(/,/).map do |pair|
+          key, value = pair.split(/=/)
+          { key.to_sym => value }
+        end
+        params.inject(&:merge) || {}
+      end
+
+    end
+
+  end
+
+end

data/lib/ripe/db.rb

@@ -0,0 +1,7 @@
+require 'active_record'
+require 'fileutils'
+
+require_relative 'db/task'
+require_relative 'db/task_migration'
+require_relative 'db/worker'
+require_relative 'db/worker_migration'

data/lib/ripe/db/task.rb

@@ -0,0 +1,42 @@
+module Ripe
+
+  module DB
+
+    ##
+    # This class represents a +Task+ object in ripe's internal database. Its
+    # fields are defined by +Ripe::DB::TaskMigration+.
+    #
+    # @see Ripe::WorkerController
+
+    class Task < ActiveRecord::Base
+      belongs_to :worker
+
+      ##
+      # Return path to task directory, which is the same as worker directory.
+
+      def dir
+        "#{self.worker.dir}"
+      end
+
+      ##
+      # Return path to task-level combined +stdout+ and +stderr+ log.
+
+      def log
+        "#{self.dir}/#{self.id}.log"
+      end
+
+      ##
+      # Return path to task-level job script, which only includes the task at
+      # hand.  This script is never actually executed by ripe.
+      #
+      # @see Ripe::DB::Worker#sh
+
+      def sh
+        "#{self.dir}/#{self.id}.sh"
+      end
+
+    end
+
+  end
+
+end

data/lib/ripe/db/task_migration.rb

@@ -0,0 +1,33 @@
+module Ripe
+
+  module DB
+  
+    ##
+    # This class creates and destroys the +Task+ model in the internal
+    # database.
+
+    class TaskMigration < ActiveRecord::Migration
+
+      ##
+      # Create model in database.
+
+      def self.up
+        create_table :tasks do |t|
+          t.belongs_to :worker
+          t.string     :sample
+          t.string     :block
+        end
+      end
+
+      ##
+      # Destroy model in database.
+
+      def self.down
+        drop_table :tasks
+      end
+
+    end
+  
+  end
+
+end

data/lib/ripe/db/worker.rb

@@ -0,0 +1,64 @@
+module Ripe
+
+  module DB
+
+    ##
+    # This class represents a +Worker+ object in ripe's internal database. Its
+    # fields are defined by +Ripe::DB::WorkerMigration+.
+    #
+    # @see Ripe::WorkerController
+
+    class Worker < ActiveRecord::Base
+      has_many :tasks, dependent: :destroy
+
+      ##
+      # Return path to worker directory
+
+      def dir
+        "#{Repo::REPOSITORY_PATH}/workers/#{self.id}"
+      end
+
+      ##
+      # Return path to worker/job script, which includes all tasks defined in
+      # the worker.  This is the script that is actually executed when the
+      # worker is run.
+      #
+      # @see Ripe::DB::Task#sh
+
+      def sh
+        "#{self.dir}/job.sh"
+      end
+
+      ##
+      # Return path to the +stdout+ output of the job, which only exists after
+      # the job has been completed.
+
+      def stdout
+        "#{self.dir}/job.stdout"
+      end
+
+      ##
+      # Return path to the +stderr+ output of the job, which only exists after
+      # the job has been completed.
+
+      def stderr
+        "#{self.dir}/job.stderr"
+      end
+
+      # Automatically create worker directory upon object instantiation
+
+      after_create do
+        FileUtils.mkdir_p dir if !Dir.exists? dir
+      end
+
+      # Automatically remove worker directory upon object destruction
+
+      before_destroy do
+        FileUtils.rm_r dir if Dir.exists? dir
+      end
+
+    end
+
+  end
+
+end

data/lib/ripe/db/worker_migration.rb

@@ -0,0 +1,41 @@
+module Ripe
+
+  module DB
+
+    ##
+    # This class creates and destroys the +Worker+ model in the internal
+    # database.
+
+    class WorkerMigration < ActiveRecord::Migration
+
+      ##
+      # Create model in database.
+
+      def self.up
+        create_table :workers do |t|
+          t.string  :cpu_used
+          t.string  :exit_code
+          t.string  :handle
+          t.string  :host
+          t.string  :moab_id
+          t.string  :memory_used
+          t.integer :ppn
+          t.string  :queue
+          t.string  :time
+          t.string  :status, default: :unprepared
+          t.string  :walltime
+        end
+      end
+
+      ##
+      # Destroy model in database.
+
+      def self.down
+        drop_table :workers
+      end
+
+    end
+
+  end
+
+end