arvados-cli 0.1.pre.20130710100340

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ffeaddc17c759549a44729941c40ed19396d8633
+  data.tar.gz: 5225f2e77dac7c297bbf184497fb142266f5c402
+SHA512:
+  metadata.gz: f6b86d6ced3521ea24ccab2d84c26b3615e6a592a2dcbd531e4176e9e391bbea687357348ae9de6006021d9b33838fa00da3c3bde451e66c9b4b2ea57375e16b
+  data.tar.gz: eb33bd729c869e18e16ce80b68015499f5b87b2166cd2fb7f357ab94b92ccacd4b7c4d2b0040ee940522a2059ac31dbb86a2d14f6a8d2a728dafce3dc3fe54e9

data/bin/arv

@@ -0,0 +1,198 @@
+#!/usr/bin/env ruby
+
+# Arvados cli client
+#
+# Ward Vandewege <ward@clinicalfuture.com>
+
+if RUBY_VERSION < '1.9.3' then
+  abort <<-EOS
+#{$0.gsub(/^\.\//,'')} requires Ruby version 1.9.3 or higher.
+  EOS
+end
+
+ENV['ARVADOS_API_VERSION'] ||= 'v1'
+
+if not ENV.include?('ARVADOS_API_HOST') or not ENV.include?('ARVADOS_API_TOKEN') then
+  abort <<-EOS
+ARVADOS_API_HOST and ARVADOS_API_TOKEN need to be defined as environment variables.
+  EOS
+end
+
+begin
+  require 'rubygems'
+  require 'google/api_client'
+  require 'json'
+  require 'pp'
+  require 'trollop'
+  require 'andand'
+  require 'oj'
+  require 'active_support/inflector'
+rescue LoadError
+  abort <<-EOS
+
+Please install all required gems: 
+
+  gem install google-api-client json trollop andand oj activesupport
+
+  EOS
+end
+
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.irregular 'specimen', 'specimens'
+  inflect.irregular 'human', 'humans'
+end
+
+module Kernel
+  def suppress_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    return result
+  end
+end
+
+# do this if you're testing with a dev server and you don't care about SSL certificate checks:
+if ENV['ARVADOS_API_HOST_INSECURE']
+  suppress_warnings { OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE }
+end
+
+class Google::APIClient
+ def discovery_document(api, version)
+  api = api.to_s
+  return @discovery_documents["#{api}:#{version}"] ||= (begin
+    response = self.execute!(
+      :http_method => :get,
+      :uri => self.discovery_uri(api, version),
+      :authenticated => false
+    )
+    response.body.class == String ? JSON.parse(response.body) : response.body
+  end)
+ end
+end
+
+client = Google::APIClient.new(:host => ENV['ARVADOS_API_HOST'], :application_name => 'arvados-cli', :application_version => '1.0')
+arvados = client.discovered_api('arvados', ENV['ARVADOS_API_VERSION'])
+
+def to_boolean(s)
+  !!(s =~ /^(true|t|yes|y|1)$/i)
+end
+
+def parse_arguments(discovery_document)
+  resource_types = Array.new()
+  resource_types << '--help'
+  discovery_document["resources"].each do |k,v|
+    resource_types << k.singularize
+  end
+
+  global_opts = Trollop::options do
+    banner "arvados cli client"
+    opt :dry_run, "Don't actually do anything", :short => "-n"
+    opt :verbose, "Print some things on stderr", :short => "-v"
+    opt :uuid, "Return the UUIDs of the objects in the response, one per line (default)", :short => nil
+    opt :json, "Return the entire response received from the API server, as a JSON object", :short => "-j"
+    opt :human, "Return the response received from the API server, as a JSON object with whitespace added for human consumption", :short => "-h"
+    opt :pretty, "Synonym of --human", :short => nil
+    stop_on resource_types
+  end
+  
+  # get the subcommand
+  resource_arg = ARGV.shift
+  if resource_types.include?(resource_arg) and resource_arg != '--help' then
+    # subcommand exists
+    # Now see if the method supplied exists
+    method = ARGV.shift
+    if discovery_document["resources"][resource_arg.pluralize]["methods"].include?(method) then
+      # method exists. Collect arguments.
+      discovered_params = discovery_document["resources"][resource_arg.pluralize]["methods"][method]["parameters"]
+      method_opts = Trollop::options do
+        discovered_params.each do |k,v|
+          opts = Hash.new()
+          opts[:type] = v["type"].to_sym if v.include?("type")
+          if [:datetime, :text, :object].index opts[:type]
+            opts[:type] = :string                       # else trollop bork
+          end
+          opts[:default] = v["default"] if v.include?("default")
+          opts[:default] = v["default"].to_i if opts[:type] == :integer
+          opts[:default] = to_boolean(v["default"]) if opts[:type] == :boolean
+          opts[:required] = true if v.include?("required") and v["required"]
+          description = ''
+          description = '  ' + v["description"] if v.include?("description")
+          opt k.to_sym, description, opts
+        end
+      end
+      discovered_params.each do |k,v|
+        if v["type"] == "object" and method_opts.has_key? k
+          method_opts[k] = JSON.parse method_opts[k]
+        end
+      end
+    else
+      banner = "\nThis resource type supports the following methods:\n\n"
+      discovery_document["resources"][resource_arg.pluralize]["methods"].each do |k,v|
+        description = ''
+        description = '  ' + v["description"] if v.include?("description")
+        banner += "   #{sprintf("%20s",k)}#{description}\n"
+      end
+      banner += "\n"
+
+      STDERR.puts banner
+  
+      if not method.nil? and method != '--help' then 
+        Trollop::die "Unknown method #{method.to_s} for command #{resource_arg.to_s}"
+      else
+        exit 255
+      end
+
+    end
+    
+  else
+    banner = "\nThis Arvados instance supports the following resource types:\n\n"
+    discovery_document["resources"].each do |k,v|
+      description = ''
+      if discovery_document["schemas"].include?(k.singularize.capitalize) and 
+         discovery_document["schemas"][k.singularize.capitalize].include?('description') then
+        description = '  ' + discovery_document["schemas"][k.singularize.capitalize]["description"]
+      end
+      banner += "   #{sprintf("%30s",k.singularize)}#{description}\n"
+    end
+    banner += "\n"
+
+    STDERR.puts banner
+
+    if not resource_arg.nil? and resource_arg != '--help' then 
+      Trollop::die "Unknown resource type #{resource_arg.inspect}"
+    else
+      exit 255
+    end
+  end
+
+  return resource_arg.pluralize, method, method_opts, global_opts, ARGV
+end
+
+controller, method, method_opts, global_opts, remaining_opts = parse_arguments(arvados.discovery_document)
+
+api_method = 'arvados.' + controller + '.' + method
+
+if global_opts[:dry_run]
+  if global_opts[:verbose]
+    $stderr.puts "#{api_method} #{method_opts.inspect}"
+  end
+  exit
+end
+
+result = client.execute :api_method => eval(api_method), :parameters => { :api_token => ENV['ARVADOS_API_TOKEN'] }.merge(method_opts), :authenticated => false
+results = JSON.parse result.body
+
+if results["errors"] then
+  abort "Error: #{results["errors"][0]}"
+end
+
+if global_opts[:human] or global_opts[:pretty] then
+  puts Oj.dump(results, :indent => 1)
+elsif global_opts[:json] then
+  puts Oj.dump(results)
+elsif results["items"] and results["kind"].match /list$/i
+  results['items'].each do |i| puts i['uuid'] end
+else
+  puts results['uuid']
+end

data/bin/wh-run-pipeline-instance

@@ -0,0 +1,538 @@
+#!/usr/bin/env ruby
+
+# == Synopsis
+#
+#  wh-run-pipeline-instance --template pipeline-template-uuid [options] [--] [parameters]
+#  wh-run-pipeline-instance --instance pipeline-instance-uuid [options]
+#
+# Satisfy a pipeline template by finding or submitting a mapreduce job
+# for each pipeline component.
+#
+# == Options
+#
+# [--template uuid] Use the specified pipeline template.
+#
+# [--instance uuid] Use the specified pipeline instance.
+#
+# [-n, --dry-run] Do not start any new jobs or wait for existing jobs
+#                 to finish. Just find out whether jobs are finished,
+#                 queued, or running for each component
+#
+# [--create-only] Do not try to satisfy any components. Just create an
+#                 instance, print its UUID to stdout, and exit.
+#
+# [--no-wait] Make only as much progress as possible without entering
+#             a sleep/poll loop.
+#
+# [--debug] Print extra debugging information on stderr.
+#
+# [--debug-level N] Increase amount of debugging information. Default
+#                   1, possible range 0..3.
+#
+# [--status-text path] Print plain text status report to a file or
+#                      fifo. Default: /dev/stdout
+#
+# [--status-json path] Print JSON status report to a file or
+#                      fifo. Default: /dev/null
+#
+# == Parameters
+#
+# [param_name=param_value]
+#
+# [param_name param_value] Set (or override) the default value for
+#                          every parameter with the given name.
+#
+# [component_name::param_name=param_value]
+# [component_name::param_name param_value]
+# [--component_name::param_name=param_value]
+# [--component_name::param_name param_value] Set the value of a
+#                                            parameter for a single
+#                                            component.
+#
+class WhRunPipelineInstance
+end
+
+$application_version = 1.0
+
+if RUBY_VERSION < '1.9.3' then
+  abort <<-EOS
+#{$0.gsub(/^\.\//,'')} requires Ruby version 1.9.3 or higher.
+  EOS
+end
+
+$arvados_api_version = ENV['ARVADOS_API_VERSION'] || 'v1'
+$arvados_api_host = ENV['ARVADOS_API_HOST'] or
+  abort "#{$0}: fatal: ARVADOS_API_HOST environment variable not set."
+$arvados_api_token = ENV['ARVADOS_API_TOKEN'] or
+  abort "#{$0}: fatal: ARVADOS_API_TOKEN environment variable not set."
+
+begin
+  require 'rubygems'
+  require 'google/api_client'
+  require 'json'
+  require 'pp'
+  require 'trollop'
+rescue LoadError
+  abort <<-EOS
+#{$0}: fatal: some runtime dependencies are missing.
+Try: gem install pp google-api-client json trollop
+  EOS
+end
+
+def debuglog(message, verbosity=1)
+  $stderr.puts "#{File.split($0).last} #{$$}: #{message}" if $debuglevel >= verbosity
+end
+
+module Kernel
+  def suppress_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    return result
+  end
+end
+
+if $arvados_api_host.match /local/
+  # You probably don't care about SSL certificate checks if you're
+  # testing with a dev server.
+  suppress_warnings { OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE }
+end
+
+class Google::APIClient
+  def discovery_document(api, version)
+    api = api.to_s
+    return @discovery_documents["#{api}:#{version}"] ||=
+      begin
+        response = self.execute!(
+                                 :http_method => :get,
+                                 :uri => self.discovery_uri(api, version),
+                                 :authenticated => false
+                                 )
+        response.body.class == String ? JSON.parse(response.body) : response.body
+      end
+  end
+end
+
+
+# Parse command line options (the kind that control the behavior of
+# this program, that is, not the pipeline component parameters).
+
+p = Trollop::Parser.new do
+  opt(:dry_run,
+      "Do not start any new jobs or wait for existing jobs to finish. Just find out whether jobs are finished, queued, or running for each component.",
+      :type => :boolean,
+      :short => :n)
+  opt(:status_text,
+      "Store plain text status in given file.",
+      :short => :none,
+      :type => :string,
+      :default => '/dev/stdout')
+  opt(:status_json,
+      "Store json-formatted pipeline in given file.",
+      :short => :none,
+      :type => :string,
+      :default => '/dev/null')
+  opt(:no_wait,
+      "Do not wait for jobs to finish. Just look up status, submit new jobs if needed, and exit.",
+      :short => :none,
+      :type => :boolean)
+  opt(:debug,
+      "Print extra debugging information on stderr.",
+      :type => :boolean)
+  opt(:debug_level,
+      "Set debug verbosity level.",
+      :short => :none,
+      :type => :integer)
+  opt(:template,
+      "UUID of pipeline template.",
+      :short => :none,
+      :type => :string)
+  opt(:instance,
+      "UUID of pipeline instance.",
+      :short => :none,
+      :type => :string)
+  opt(:create_only,
+      "Do not try to satisfy any components. Just create a pipeline instance and output its UUID.",
+      :short => :none,
+      :type => :boolean)
+  stop_on [:'--']
+end
+$options = Trollop::with_standard_exception_handling p do
+  p.parse ARGV
+end
+$debuglevel = $options[:debug_level] || ($options[:debug] && 1) || 0
+
+if $options[:instance]
+  if $options[:template] or $options[:create_only]
+    abort "#{$0}: syntax error: --instance cannot be combined with --template or --create-only."
+  end
+elsif not $options[:template]
+  abort "#{$0}: syntax error: you must supply a --template or --instance."
+end
+
+# Set up the API client.
+
+$client ||= Google::APIClient.
+  new(:host => $arvados_api_host,
+      :application_name => File.split($0).last,
+      :application_version => $application_version.to_s)
+$arvados = $client.discovered_api('arvados', $arvados_api_version)
+
+
+class PipelineInstance
+  def self.find(uuid)
+    result = $client.execute(:api_method => $arvados.pipeline_instances.get,
+                             :parameters => {
+                               :api_token => ENV['ARVADOS_API_TOKEN'],
+                               :uuid => uuid
+                             },
+                             :authenticated => false)
+    j = JSON.parse result.body, :symbolize_names => true
+    unless j.is_a? Hash and j[:uuid]
+      debuglog "Failed to get pipeline_instance: #{j[:errors] rescue nil}", 0
+      nil
+    else
+      debuglog "Retrieved pipeline_instance #{j[:uuid]}"
+      self.new(j)
+    end
+  end
+  def self.create(attributes)
+    result = $client.execute(:api_method => $arvados.pipeline_instances.create,
+                             :parameters => {
+                               :api_token => ENV['ARVADOS_API_TOKEN'],
+                               :pipeline_instance => attributes.to_json
+                             },
+                             :authenticated => false)
+    j = JSON.parse result.body, :symbolize_names => true
+    unless j.is_a? Hash and j[:uuid]
+      abort "Failed to create pipeline_instance: #{j[:errors] rescue nil} #{j.inspect}"
+    end
+    debuglog "Created pipeline instance: #{j[:uuid]}"
+    self.new(j)
+  end
+  def save
+    result = $client.execute(:api_method => $arvados.pipeline_instances.update,
+                             :parameters => {
+                               :api_token => ENV['ARVADOS_API_TOKEN'],
+                               :uuid => @pi[:uuid],
+                               :pipeline_instance => @attributes_to_update.to_json
+                             },
+                             :authenticated => false)
+    j = JSON.parse result.body, :symbolize_names => true
+    unless j.is_a? Hash and j[:uuid]
+      debuglog "Failed to save pipeline_instance: #{j[:errors] rescue nil}", 0
+      nil
+    else
+      @attributes_to_update = {}
+      @pi = j
+    end
+  end
+  def []=(x,y)
+    @attributes_to_update[x] = y
+    @pi[x] = y
+  end
+  def [](x)
+    @pi[x]
+  end
+  protected
+  def initialize(j)
+    @attributes_to_update = {}
+    @pi = j
+  end
+end
+
+class JobCache
+  def self.get(uuid)
+    @cache ||= {}
+    result = $client.execute(:api_method => $arvados.jobs.get,
+                             :parameters => {
+                               :api_token => ENV['ARVADOS_API_TOKEN'],
+                               :uuid => uuid
+                             },
+                             :authenticated => false)
+    @cache[uuid] = JSON.parse result.body, :symbolize_names => true
+  end
+  def self.where(conditions)
+    result = $client.execute(:api_method => $arvados.jobs.list,
+                             :parameters => {
+                               :api_token => ENV['ARVADOS_API_TOKEN'],
+                               :limit => 10000,
+                               :where => conditions.to_json
+                             },
+                             :authenticated => false)
+    list = JSON.parse result.body, :symbolize_names => true
+    if list and list[:items].is_a? Array
+      list[:items]
+    else
+      []
+    end
+  end
+  def self.create(attributes)
+    @cache ||= {}
+    result = $client.execute(:api_method => $arvados.jobs.create,
+                             :parameters => {
+                               :api_token => ENV['ARVADOS_API_TOKEN'],
+                               :job => attributes.to_json
+                             },
+                             :authenticated => false)
+    j = JSON.parse result.body, :symbolize_names => true
+    if j.is_a? Hash and j[:uuid]
+      @cache[j[:uuid]] = j
+    else
+      debuglog "create job: #{j[:errors] rescue nil}"
+      nil
+    end
+  end
+end
+
+class WhRunPipelineInstance
+  attr_reader :instance
+
+  def initialize(_options)
+    @options = _options
+  end
+
+  def fetch_template(template_uuid)
+    result = $client.execute(:api_method => $arvados.pipeline_templates.get,
+                             :parameters => {
+                               :api_token => ENV['ARVADOS_API_TOKEN'],
+                               :uuid => template_uuid
+                             },
+                             :authenticated => false)
+    @template = JSON.parse result.body, :symbolize_names => true
+    if !@template[:uuid]
+      abort "#{$0}: fatal: failed to retrieve pipeline template #{template_uuid} #{@template[:errors].inspect rescue nil}"
+    end
+    self
+  end
+
+  def fetch_instance(instance_uuid)
+    @instance = PipelineInstance.find(instance_uuid)
+    @template = @instance
+    self
+  end
+
+  def apply_parameters(params_args)
+    params_args.shift if params_args[0] == '--'
+    params = {}
+    while !params_args.empty?
+      if (re = params_args[0].match /^(--)?([^-].*?)=(.)/)
+        params[re[2]] = re[3]
+        params_args.shift
+      elsif params_args.size > 1
+        param = params_args.shift.sub /^--/, ''
+        params[param] = params_args.shift
+      else
+        abort "Syntax error: I do not know what to do with arg \"#{params_args[0]}\""
+      end
+    end
+
+    @components = @template[:components].dup
+
+    errors = []
+    @components.each do |componentname, component|
+      component[:script_parameters].each do |parametername, parameter|
+        parameter = { :value => parameter } unless parameter.is_a? Hash
+        value =
+          (params["#{componentname}::#{parametername}"] ||
+           parameter[:value] ||
+           (parameter[:output_of].nil? &&
+            (params[parametername.to_s] ||
+             parameter[:default])) ||
+           nil)
+        if value.nil? and
+            ![false,'false',0,'0'].index parameter[:required]
+          if parameter[:output_of]
+            next
+          end
+          errors << [componentname, parametername, "required parameter is missing"]
+        end
+        debuglog "parameter #{componentname}::#{parametername} == #{value}"
+        component[:script_parameters][parametername] = value
+      end
+    end
+    if !errors.empty?
+      abort "Errors:\n#{errors.collect { |c,p,e| "#{c}::#{p} - #{e}\n" }.join ""}"
+    end
+    debuglog "options=" + @options.pretty_inspect
+    self
+  end
+
+  def setup_instance
+    @instance ||= PipelineInstance.
+      create(:components => @components,
+             :pipeline_template_uuid => @template[:uuid],
+             :active => true)
+    self
+  end
+
+  def run
+    moretodo = true
+    while moretodo
+      moretodo = false
+      @components.each do |cname, c|
+        job = nil
+        if !c[:job] and
+            c[:script_parameters].select { |pname, p| p.is_a? Hash }.empty?
+          # Job is fully specified (all parameter values are present) but
+          # no particular job has been found.
+
+          debuglog "component #{cname} ready to satisfy."
+
+          c.delete :wait
+          second_place_job = nil # satisfies component, but not finished yet
+          JobCache.where(:script => c[:script],
+                         :script_parameters => c[:script_parameters],
+                         :script_version_descends_from => c[:script_version_descends_from]).
+            each do |candidate_job|
+            candidate_params_downcase = Hash[candidate_job[:script_parameters].
+                                             map { |k,v| [k.downcase,v] }]
+            c_params_downcase = Hash[c[:script_parameters].
+                                     map { |k,v| [k.downcase,v] }]
+
+            debuglog "component #{cname} considering job #{candidate_job[:uuid]} version #{candidate_job[:script_version]} parameters #{candidate_params_downcase.inspect}", 3
+
+            unless candidate_params_downcase == c_params_downcase
+              next
+            end
+
+            unless candidate_job[:success] || candidate_job[:running] ||
+                (!candidate_job[:started_at] && !candidate_job[:cancelled_at])
+              debuglog "component #{cname} would be satisfied by job #{candidate_job[:uuid]} if it were running or successful.", 2
+              next
+            end
+
+            if candidate_job[:success]
+              job = candidate_job
+              debuglog "component #{cname} satisfied by job #{job[:uuid]} version #{job[:script_version]}"
+              c[:job] = job
+            else
+              second_place_job ||= candidate_job
+            end
+            break
+          end
+          if not c[:job] and second_place_job
+            job = second_place_job
+            debuglog "component #{cname} satisfied by job #{job[:uuid]} version #{job[:script_version]}"
+            c[:job] = job
+          end
+          if not c[:job]
+            debuglog "component #{cname} not satisfied by any existing job."
+            if !@options[:dry_run]
+              debuglog "component #{cname} new job."
+              job = JobCache.create(:script => c[:script],
+                                    :script_parameters => c[:script_parameters],
+                                    :resource_limits => c[:resource_limits] || {},
+                                    :script_version => c[:script_version] || 'master')
+              if job
+                debuglog "component #{cname} new job #{job[:uuid]}"
+                c[:job] = job
+              else
+                debuglog "component #{cname} new job failed: #{job[:errors]}"
+              end
+            end
+          end
+        else
+          c[:wait] = true
+        end
+        if c[:job] and c[:job][:uuid]
+          if not c[:job][:finished_at] and not c[:job][:cancelled_at]
+            c[:job] = JobCache.get(c[:job][:uuid])
+          end
+          if c[:job][:success]
+            # Populate script_parameters of other components waiting for
+            # this job
+            @components.each do |c2name, c2|
+              c2[:script_parameters].each do |pname, p|
+                if p.is_a? Hash and p[:output_of] == cname.to_s
+                  debuglog "parameter #{c2name}::#{pname} == #{c[:job][:output]}"
+                  c2[:script_parameters][pname] = c[:job][:output]
+                end
+              end
+            end
+          elsif c[:job][:running] ||
+              (!c[:job][:started_at] && !c[:job][:cancelled_at])
+            moretodo ||= !@options[:no_wait]
+          elsif c[:job][:cancelled_at]
+            debuglog "component #{cname} job #{c[:job][:uuid]} cancelled."
+          end
+        end
+      end
+      @instance[:components] = @components
+      @instance[:active] = moretodo
+      report_status
+      sleep 10 if moretodo
+    end
+    @instance[:success] = @components.reject { |cname,c| c[:job] and c[:job][:success] }.empty?
+    @instance.save
+  end
+
+  def cleanup
+    if @instance
+      @instance[:active] = false
+      @instance.save
+    end
+  end
+
+  def uuid
+    @instance[:uuid]
+  end
+
+  protected
+
+  def report_status
+    @instance.save
+
+    if @options[:status_json] != '/dev/null'
+      File.open(@options[:status_json], 'w') do |f|
+        f.puts @components.pretty_inspect
+      end
+    end
+
+    if @options[:status_text] != '/dev/null'
+      File.open(@options[:status_text], 'w') do |f|
+        f.puts "#{Time.now} -- pipeline_instance #{@instance[:uuid]}"
+        namewidth = @components.collect { |cname, c| cname.size }.max
+        @components.each do |cname, c|
+          jstatus = if !c[:job]
+                      "-"
+                    elsif c[:job][:running]
+                      "#{c[:job][:tasks_summary].inspect}"
+                    elsif c[:job][:success]
+                      c[:job][:output]
+                    elsif c[:job][:cancelled_at]
+                      "cancelled #{c[:job][:cancelled_at]}"
+                    elsif c[:job][:finished_at]
+                      "failed #{c[:job][:finished_at]}"
+                    elsif c[:job][:started_at]
+                      "started #{c[:job][:started_at]}"
+                    else
+                      "queued #{c[:job][:created_at]}"
+                    end
+          f.puts "#{cname.to_s.ljust namewidth} #{c[:job] ? c[:job][:uuid] : '-'.ljust(27)} #{jstatus}"
+        end
+      end
+    end
+  end
+end
+
+runner = WhRunPipelineInstance.new($options)
+begin
+  if $options[:template]
+    runner.fetch_template($options[:template])
+  else
+    runner.fetch_instance($options[:instance])
+  end
+  runner.apply_parameters(p.leftovers)
+  runner.setup_instance
+  if $options[:create_only]
+    runner.instance.save
+    puts runner.instance[:uuid]
+  else
+    runner.run
+  end
+rescue Exception => e
+  runner.cleanup
+  raise e
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: arvados-cli
+version: !ruby/object:Gem::Version
+  version: 0.1.pre.20130710100340
+platform: ruby
+authors:
+- Arvados Authors
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-api-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.7.7
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: andand
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.3
+description: This is the Arvados SDK CLI gem, git revision b10a80d5726f25e7284bf4d5f039f1e3fef83b34
+email: gem-dev@clinicalfuture.com
+executables:
+- arv
+- wh-run-pipeline-instance
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/arv
+- bin/wh-run-pipeline-instance
+homepage: http://arvados.org
+licenses:
+- Apache License, Version 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Arvados SDK CLI
+test_files: []