dtk-client 0.7.5 → 0.7.6

data/lib/task_status/stream_mode/element/hierarchical_task/steps/action.rb

@@ -0,0 +1,37 @@
+module DTK::Client; class TaskStatus::StreamMode::Element::HierarchicalTask
+  class Steps
+    class Action < self
+      def initialize(element, hash)
+        super
+        @action = hash['action'] || {}
+      end
+
+      def render_steps(steps)
+        steps.each { |step| step.render }
+      end
+
+      def render
+        if action_term = action_term?
+          render_line "ACTION: #{action_term}"
+        end
+      end
+      
+      private
+      
+      def action_term?
+        ret = ''
+        if node_term = node_term?
+          ret << "#{node_term}/"
+        end
+        if component_name = @action['component_name']
+          ret << component_name
+        end
+        if method_name = @action['method_name']
+          ret << ".#{method_name}"
+        end
+        ret.nil? ? nil : ret
+      end
+    end
+  end
+end; end
+

data/lib/task_status/stream_mode/element/hierarchical_task/steps/components.rb

@@ -0,0 +1,36 @@
+module DTK::Client; class TaskStatus::StreamMode::Element::HierarchicalTask
+  class Steps
+    class Components < self
+      def initialize(element, hash)
+        super
+        @component_names = (hash['components'] || []).map { |cmp| cmp['name'] }.compact
+      end
+
+      attr_reader :component_names
+
+      def render_steps(steps)
+        step = steps.first
+        if steps.size ==  1 and step.component_names.size == 1 
+          render_line "COMPONENT: #{step.component_term(step.component_names.first)}"
+        else
+          render_line 'COMPONENTS:'
+          steps.each do |step| 
+            step.component_names.each do |component_name|
+              render_line  step.component_term(component_name), :tabs => 1
+            end
+          end
+        end
+      end
+      
+      def component_term(component_name)
+        ret = ''
+        if node_term = node_term?
+          ret << "#{node_term}/"
+        end
+        ret << component_name
+        ret
+      end
+    end
+  end
+
+end; end

data/lib/task_status/stream_mode/element/hierarchical_task/steps/node_level.rb

@@ -0,0 +1,25 @@
+module DTK::Client; class TaskStatus::StreamMode::Element::HierarchicalTask
+  class Steps
+    class NodeLevel < self
+      def render_steps(steps)
+        render_line node_operation_line(steps)
+        steps.each { |step| step.render }
+      end
+      
+      def render
+        render_line node_term?, :tabs => 1
+      end
+
+      private
+
+      def node_operation_line(steps)
+        operation_term = @type
+        if steps.size > 1 and not operation_term =~ /s$/
+          operation_term += 's'
+        end
+        "OPERATION: #{operation_term}" 
+      end
+
+    end
+  end
+end; end

data/lib/task_status/stream_mode/element/hierarchical_task/steps.rb

@@ -0,0 +1,17 @@
+module DTK::Client; class TaskStatus::StreamMode::Element
+  class HierarchicalTask 
+    class Steps < self
+      require File.expand_path('steps/action', File.dirname(__FILE__))
+      require File.expand_path('steps/components', File.dirname(__FILE__))
+      require File.expand_path('steps/node_level', File.dirname(__FILE__))
+    
+      private
+
+      def self.render(element, stage_subtasks)
+        steps = base_subtasks(element, stage_subtasks, :stop_at_node_group => true)
+        return if steps.empty?
+        steps.first.render_steps(steps)
+      end
+    end
+  end
+end; end

data/lib/task_status/stream_mode/element/hierarchical_task.rb

@@ -0,0 +1,83 @@
+module DTK::Client; class TaskStatus::StreamMode::Element
+  class HierarchicalTask 
+    require File.expand_path('hierarchical_task/result', File.dirname(__FILE__))
+    require File.expand_path('hierarchical_task/steps', File.dirname(__FILE__))
+
+    def initialize(element, hash)
+      @type          = self.class.type(hash)
+      @element       = element
+      @node_name     = (hash['node'] || {})['name']
+      @is_node_group = self.class.has_node_group?(hash)
+    end
+
+    def self.render_results(element, stage_subtasks)
+      stage_subtasks && Results.render(element, stage_subtasks)
+    end
+
+    def self.render_steps(element, stage_subtasks)
+      stage_subtasks && Steps.render(element, stage_subtasks)
+    end
+
+    private
+
+
+    def self.base_subtasks(element, stage_subtasks, opts = {})
+      stage_subtasks.inject([]) do |a, subtask_hash|
+        if opts[:stop_at_node_group] and has_node_group?(subtask_hash)
+          a + [create(element, subtask_hash)]
+        elsif (subtask_hash['subtasks'] || []).empty?
+          a + [create(element, subtask_hash)]
+        else
+          a + base_subtasks(element, subtask_hash['subtasks'], opts)
+        end
+      end
+    end      
+
+    def self.create(element, hash)
+      stage_type_class(hash).new(element, hash)
+    end
+
+    def self.type(hash)
+      hash['executable_action_type']
+    end
+
+    def self.stage_type_class(hash) 
+      case type(hash)
+        when 'ComponentAction'
+          self::Action
+        when 'ConfigNode'
+          self::Components
+        else # they will be node level
+          self::NodeLevel
+      end
+    end
+    
+    def self.has_node_group?(subtask_hash)
+      subtask_hash['node'] and subtask_hash['node']['type'] == 'group'
+    end
+
+    def render_line(*args)
+      @element.render_line(*args)
+    end
+    
+    def render_empty_line
+      @element.render_empty_line
+    end
+
+    def render_node_term(opts = {})
+      if @node_name
+        if @is_node_group 
+          render_line("NODE-GROUP: #{@node_name}", opts)
+        else
+          render_line("NODE: #{@node_name}", opts)
+        end
+      end
+    end
+
+    def node_term?
+      if @node_name
+        @is_node_group ? "node-group:#{@node_name}" : @node_name
+      end
+    end
+  end
+end; end

data/lib/task_status/stream_mode/element/render.rb

@@ -0,0 +1,42 @@
+class DTK::Client::TaskStatus::StreamMode::Element
+  module RenderMixin
+    def render_line(msg, params = {})
+      if msg
+        print_to_console(@formatter.format(msg, params))
+        render_empty_line
+      end
+    end
+    
+    def render_start_time(started_at)
+      render_line(@formatter.start_time_msg?(started_at))
+    end
+    
+    def formatted_duration?
+      @formatter.formatted_duration?(field?(:duration))
+    end
+
+    def render_duration_line
+      render_line(@formatter.duration_msg?(field?(:duration)))
+    end
+  
+    def render_border
+      print_to_console(@formatter.border)
+      render_empty_line
+    end     
+    
+    def render_empty_line
+      render_empty_lines(1)
+    end
+    
+    def render_empty_lines(num_empty_lines = 1)
+      print_to_console("\n" * num_empty_lines)
+    end
+
+    private
+
+    def print_to_console(string)
+      #TODO: stub
+      STDOUT << string
+    end
+  end
+end

data/lib/task_status/stream_mode/element/stage/render.rb

@@ -0,0 +1,59 @@
+class DTK::Client::TaskStatus::StreamMode::Element::Stage
+  module Render
+    module Mixin
+      def render
+        render_start unless @just_render and @just_render != :start
+        render_end unless @just_render and @just_render != :end
+      end
+      
+      private
+      
+      def render_start
+        if @ignore_stage_level_info
+          render_stage_steps field?(:subtasks)
+          render_start_time field?(:started_at)
+        else
+          render_border
+          render_line line__stage_heading?
+          render_start_time field?(:started_at)
+          render_stage_steps field?(:subtasks)
+        end
+      end
+      
+      def render_end
+        render_line line__status
+        render_duration_line
+        render_stage_results field?(:subtasks)
+        unless @ignore_stage_level_info
+          render_border
+          render_empty_line
+        end
+      end
+      
+      def line__stage_heading?
+        stage_num  = field?(:position)
+        stage_name = stage_name?
+        
+        unless stage_num.nil? and stage_name.nil?
+          msg = 'STAGE'
+          if stage_num  = field?(:position)
+            msg << " #{stage_num.to_s}"
+          end
+          
+          if stage_name = stage_name?
+            msg << ": #{stage_name}"
+          end
+          msg
+        end
+      end
+      
+      def line__status
+        "STATUS: #{field?(:status) || 'UNKNOWN'}"
+      end
+      
+      def stage_name?
+        field?(:display_name)
+      end
+    end
+  end
+end

data/lib/task_status/stream_mode/element/stage.rb

@@ -0,0 +1,67 @@
+module DTK::Client; class TaskStatus::StreamMode
+  class Element
+    class Stage < self
+      require File.expand_path('stage/render', File.dirname(__FILE__))
+      include Render::Mixin
+
+      def initialize(response_element, opts = {})
+        super
+        @just_render = opts[:just_render]
+      end
+      
+      # opts has
+      #   :wait - amount to wait if get no results (required)
+      def self.get_and_render_stages(task_status_handle, opts = {})
+        unless wait = opts[:wait]
+          raise DtkError::Client, "opts[:wait] must be set"
+        end
+        
+        cursor = Cursor.new
+        until cursor.task_end? do
+          elements = get_single_stage(task_status_handle, cursor.stage, {:wait_for => cursor.wait_for}.merge(opts))
+          if no_results_yet?(elements)
+            sleep wait
+            next
+          end
+          render_elements(elements)
+          cursor.advance!(task_end?(elements))
+        end
+      end
+    
+      class Cursor
+        def initialize
+          @stage    = 1
+          @wait_for = :start
+          @task_end = false
+        end
+        attr_reader :stage, :wait_for
+        def task_end?
+          @task_end
+        end
+        def advance!(task_end)
+          unless @task_end = task_end
+            if @wait_for == :start
+              @wait_for = :end
+            else
+              @stage += 1
+              @wait_for = :start
+            end
+          end
+        end
+      end
+      
+      def self.get_single_stage(task_status_handle, stage_num, opts = {})
+        get_stages(task_status_handle, stage_num, stage_num, opts)
+      end
+      
+      def self.get_stages(task_status_handle, start_stage_num, end_stage_num, opts = {})
+        opts_get = {
+          :start_index => start_stage_num, 
+          :end_index   => end_stage_num
+        }.merge(opts)
+        get_task_status_elements(task_status_handle, :stage, opts_get)
+      end
+      
+    end
+  end
+end; end

data/lib/task_status/stream_mode/element/task_end.rb

@@ -0,0 +1,19 @@
+module DTK::Client; class TaskStatus::StreamMode
+  class Element
+    class TaskEnd < self
+      def task_end?()
+        true
+      end
+
+      def render
+        return if @ignore_stage_level_info
+        msg = "end: '#{field?(:display_name) || 'Workflow'}'"
+        if duration = formatted_duration?
+          msg << " (total duration: #{duration})"
+        end
+        render_line msg, :bracket => true
+      end
+    end
+  end
+end; end
+

data/lib/task_status/stream_mode/element/task_start.rb

@@ -0,0 +1,21 @@
+module DTK::Client; class TaskStatus::StreamMode
+  class Element
+    class TaskStart < self
+      def self.get(task_status_handle, opts = {})
+        opts_get = {
+          :start_index => 0,
+          :end_index   => 0
+        }.merge(opts)
+        get_task_status_elements(task_status_handle, :task_start, opts_get)
+      end
+
+      def render
+        return if @ignore_stage_level_info
+        msg = "start '#{field?(:display_name) || 'Workflow'}'"
+        render_line msg, :bracket => true, :started_at => field?(:started_at)
+        render_empty_lines 2
+      end
+    end
+  end
+end; end
+

data/lib/task_status/stream_mode/element.rb

@@ -0,0 +1,85 @@
+module DTK::Client; class TaskStatus::StreamMode
+  class Element
+    require File.expand_path('element/format', File.dirname(__FILE__))
+    require File.expand_path('element/render', File.dirname(__FILE__))
+    require File.expand_path('element/hierarchical_task', File.dirname(__FILE__))
+    require File.expand_path('element/task_start', File.dirname(__FILE__))
+    require File.expand_path('element/task_end', File.dirname(__FILE__))
+    require File.expand_path('element/stage', File.dirname(__FILE__))
+    require File.expand_path('element/no_results', File.dirname(__FILE__))
+    include RenderMixin
+
+    def initialize(response_element, opts = {})
+      @response_element    = response_element
+      @formatter          = Format.new(response_element['type'])
+      @ignore_stage_level_info = opts[:ignore_stage_level_info]
+    end
+
+    def self.get_and_render_task_start(task_status_handle, opts = {})
+      render_elements(TaskStart.get(task_status_handle, opts))
+    end
+
+    def self.get_and_render_stages(task_status_handle, opts = {})
+      Stage.get_and_render_stages(task_status_handle, opts)
+    end
+
+    private
+
+    # opts will have
+    #   :start_index
+    #   :end_index
+    # opts can have
+    #   :ignore_stage_level_info - Boolean
+    def self.get_task_status_elements(task_status_handle, element_type, opts = {})
+      response =  task_status_handle.post_call(opts.merge(:form => :stream_form))
+      create_elements(response, opts)
+    end
+
+    # opts can have
+    #   :ignore_stage_level_info - Boolean
+    def self.create_elements(response, opts = {})
+      response_elements = response.data
+      unless response_elements.kind_of?(Array)
+        raise DtkError::Client.new("Unexpected that response.data no at array")
+      end
+      response_elements.map { |el| create(el, opts) }
+    end
+    def self.create(response_element, opts)
+      type = response_element['type'] 
+      case type && type.to_sym
+        when :task_start  then TaskStart.new(response_element, opts)
+        when :task_end    then TaskEnd.new(response_element, opts)
+        when :stage       then Stage.new(response_element, opts)
+        when :stage_start then Stage.new(response_element, {:just_render => :start}.merge(opts))
+        when :stage_end   then Stage.new(response_element, {:just_render => :end}.merge(opts))
+        when :no_results  then NoResults.new(response_element, opts)
+        else              raise DtkError::Client.new("Unexpected element type '#{type}'")
+      end
+    end
+    
+    def self.task_end?(elements)
+      elements.empty? or elements.last.kind_of?(TaskEnd)
+    end
+    
+    def self.no_results_yet?(elements)
+      elements.find{|el|el.kind_of?(NoResults)}
+    end
+
+    def self.render_elements(elements)
+      elements.each{ |el| el.render }
+    end
+
+    def render_stage_steps(subtasks)
+      HierarchicalTask.render_steps(self, subtasks)
+    end
+
+    def render_stage_results(subtasks)
+      HierarchicalTask.render_results(self, subtasks)
+    end
+
+    def field?(field)
+      @response_element[field.to_s]
+    end
+  end
+end; end
+

data/lib/{commands/common/thor/task_status → task_status}/stream_mode.rb

@@ -2,11 +2,11 @@ require 'hirb'
 module DTK::Client
   class TaskStatus
     class StreamMode < self
-      require File.expand_path('stream_mode/element',File.dirname(__FILE__))
+      require File.expand_path('stream_mode/element', File.dirname(__FILE__))
 
-      def get_and_render()
-        Element.get_and_render_task_start(self)
-        Element.get_and_render_stages(self,:wait => WaitWhenNoResults)
+      def get_and_render(opts = {})
+        Element.get_and_render_task_start(self, opts)
+        Element.get_and_render_stages(self, {:wait => WaitWhenNoResults}.merge(opts))
         Response::Ok.new()
       end
 
@@ -22,7 +22,7 @@ module DTK::Client
       #    start_index: START_INDEX
       #    end_index: END_INDEX
       # convention is start_position = 0 and end_position = 0 means top level task with start time 
-      def post_body(opts={})
+      def post_body(opts = {})
         ret = super(opts)
         ret.merge(:start_index => opts[:start_index], :end_index => opts[:end_index])
       end

data/lib/{commands/common/thor/task_status.rb → task_status.rb}

@@ -1,26 +1,26 @@
 module DTK::Client
   module TaskStatusMixin
-    def task_status_aux(mode, object_id, object_type, opts={})
+    def task_status_aux(mode, object_id, object_type, opts = {})
       case mode
         when :refresh
-          TaskStatus::RefreshMode.new(self,mode,object_id,object_type).task_status(opts)
+          TaskStatus::RefreshMode.new(self, mode, object_id, object_type).task_status(opts)
         when :snapshot 
-          TaskStatus::SnapshotMode.new(self,mode,object_id,object_type).task_status(opts)
+          TaskStatus::SnapshotMode.new(self, mode, object_id, object_type).task_status(opts)
         when :stream  
           assembly_or_workspace_id = object_id
           task_status_stream(assembly_or_workspace_id)
         else
-          legal_modes = [:refresh,:snapshot,:stream]
+          legal_modes = [:refresh, :snapshot, :stream]
           raise DtkError::Usage.new("Illegal mode '#{mode}'; legal modes are: #{legal_modes.join(', ')}")
       end
     end
 
-    def task_status_stream(assembly_or_workspace_id)
-      TaskStatus::StreamMode.new(self,:stream,assembly_or_workspace_id,:assembly).get_and_render()
+    def task_status_stream(assembly_or_workspace_id, opts = {})
+      TaskStatus::StreamMode.new(self, :stream, assembly_or_workspace_id, :assembly).get_and_render(opts)
     end
 
     def list_task_info_aux(object_type, object_id)
-      response = TaskStatus.new(self,object_id,object_type).post_call(:form => :list)
+      response = TaskStatus.new(self, object_id, object_type).post_call(:form => :list)
       unless response.ok?
         DtkError.raise_error(response)
       end
@@ -31,11 +31,11 @@ module DTK::Client
 
   dtk_require_common_commands('thor/base_command_helper')
   class TaskStatus < BaseCommandHelper
-    require File.expand_path('task_status/snapshot_mode',File.dirname(__FILE__))
-    require File.expand_path('task_status/refresh_mode',File.dirname(__FILE__))
-    require File.expand_path('task_status/stream_mode',File.dirname(__FILE__))
+    require File.expand_path('task_status/snapshot_mode', File.dirname(__FILE__))
+    require File.expand_path('task_status/refresh_mode', File.dirname(__FILE__))
+    require File.expand_path('task_status/stream_mode', File.dirname(__FILE__))
 
-    def initialize(command,mode,object_id,object_type)
+    def initialize(command, mode, object_id, object_type)
       super(command)
       @mode        = mode
       @object_id   = object_id
@@ -43,14 +43,17 @@ module DTK::Client
     end
 
     private
-    def post_body(opts={})
+
+    def post_body(opts = {})
       id_field = "#{@object_type}_id".to_sym
       PostBody.new(
         id_field                => @object_id,
         :form?                  => opts[:form],
+        :wait_for?              => opts[:wait_for],
         :summarize_node_groups? => opts[:summarize]
      )
     end
+
     def post_call(opts={})
       response = post rest_url("#{@object_type}/task_status"), post_body(opts)
       unless response.ok?

data/lib/util/os_util.rb

@@ -241,6 +241,14 @@ module DTK
           puts colorize(message, color)
         end
 
+        def print_warning(message)
+          print(message, :yellow)
+        end
+
+        def print_deprecate_message(message)
+          print_warning(message)
+        end
+
         # Public block, method will suspend STDOUT, STDERR in body of it
         #
         # Example