dtk-shell 0.10.0

data/lib/task_status.rb

@@ -0,0 +1,83 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  module TaskStatusMixin
+    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)
+        when :snapshot 
+          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]
+          raise DtkError::Usage.new("Illegal mode '#{mode}'; legal modes are: #{legal_modes.join(', ')}")
+      end
+    end
+
+    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)
+      unless response.ok?
+        DtkError.raise_error(response)
+      end
+      response.override_command_class("list_task")
+      puts response.render_data
+    end
+  end
+
+  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__))
+
+    def initialize(command, mode, object_id, object_type)
+      super(command)
+      @mode        = mode
+      @object_id   = object_id
+      @object_type = object_type
+    end
+
+    private
+
+    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?
+        DtkError.raise_error(response)
+      end
+      response
+    end
+
+  end
+end

data/lib/task_status/refresh_mode.rb

@@ -0,0 +1,77 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class TaskStatus
+    class RefreshMode < self
+      DEBUG_SLEEP_TIME = DTK::Configuration.get(:debug_task_frequency)
+
+      def task_status(opts={})
+        begin
+          response = nil
+          loop do
+            response = post_call(opts)
+            return response unless response.ok?
+            
+            # stop pulling when top level task succeds, fails or timeout
+            if response and response.data and response.data.first
+              return response if response.data.first["change_context"]
+              #TODO: may fix in server, but now top can have non executing state but a concurrent branch can execute; so
+              #chanding bloew for time being
+              #break unless response.data.first["status"].eql? "executing"
+              # TODO: There is bug where we do not see executing status on start so we have to wait until at
+              # least one 'successed' has been found
+              
+              top_task_failed = response.data.first['status'].eql?('failed')
+              is_pending   = (response.data.select {|r|r["status"].nil? }).size > 0
+              is_executing = (response.data.select {|r|r["status"].eql? "executing"}).size > 0
+              is_failed    = (response.data.select {|r|r["status"].eql? "failed"}).size > 0
+              is_cancelled = response.data.first["status"].eql?("cancelled")
+              
+              # commented out because of DTK-1804
+              # when some of the converge tasks fail, stop task-status --wait and set task status to '' for remaining tasks which are not executed
+              # if is_failed
+                # response.data.each {|r| (r["status"] = "") if r["status"].eql?("executing")}
+              # is_cancelled = true
+              # end
+              is_cancelled = true if top_task_failed
+              
+              unless (is_executing || is_pending) && !is_cancelled
+                system('clear')
+                response.print_error_table = true
+                response.render_table(:task_status)
+                return response
+              end
+            end
+            
+            response.render_table(:task_status)
+            system('clear')
+            response.render_data(true)
+            
+            Console.wait_animation("Watching '#{@object_type}' task status [ #{DEBUG_SLEEP_TIME} seconds refresh ] ", DEBUG_SLEEP_TIME)
+          end
+          rescue Interrupt => e
+          puts ""
+          # this tells rest of the flow to skip rendering of this response
+          response.skip_render = true unless response.nil?
+        end
+
+      end
+    end
+  end
+end
+

data/lib/task_status/snapshot_mode.rb

@@ -0,0 +1,28 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class TaskStatus
+    class SnapshotMode < self
+      def task_status(opts={})
+        response = post_call(opts)
+        response.print_error_table = true
+        response.render_table(:task_status)
+      end
+    end
+  end
+end

data/lib/task_status/stream_mode.rb

@@ -0,0 +1,48 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'hirb'
+module DTK::Client
+  class TaskStatus
+    class StreamMode < self
+      require File.expand_path('stream_mode/element', File.dirname(__FILE__))
+
+      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
+
+      WaitWhenNoResults = 5 #in seconds
+      # making this public for this class and its children
+      def post_call(*args)
+        super
+      end
+
+      private
+      
+      # This uses a cursor based interface to the server
+      #    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 = {})
+        ret = super(opts)
+        ret.merge(:start_index => opts[:start_index], :end_index => opts[:end_index])
+      end
+    end
+  end
+end

data/lib/task_status/stream_mode/element.rb

@@ -0,0 +1,101 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+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/task_status/stream_mode/element/format.rb

@@ -0,0 +1,101 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+class DTK::Client::TaskStatus::StreamMode::Element
+  class Format < ::Hash
+    Settings = {
+      :task_start => {
+      },
+      :task_end => {
+      },
+      :stage => {
+      },
+      :stage_start => {
+        :border_symbol      => '=',
+      },
+      :stage_end => {
+        :border_symbol      => '-',
+      },
+      :default => {
+        :border_symbol      => '=',
+        :border_size        => 60,
+        :bracket_symbol     => '=',
+        :bracket_size       => 25,
+        :duration_accuracy  => 1, # how many decimal places accuracy
+        :include_start_time => true,
+        :tab_size           => 2, # how many spaces each tab has
+      }
+    }
+    
+    def initialize(type)
+      super()
+      @type = type && type.to_sym
+      replace(Settings[:default].merge(Settings[@type] || {}))
+    end
+      
+    def format(msg, params = {})
+      aug_msg = augment(msg, params)
+      params[:bracket] ? bracket(aug_msg) : aug_msg
+    end
+    
+    def border
+      border_symbol = self[:border_symbol]
+      border_size    = self[:border_size]
+      "#{border_symbol * border_size}"
+    end
+    
+    def start_time_msg?(started_at)
+      if started_at
+        "TIME START: #{started_at}"
+      end
+    end
+
+    def formatted_duration?(duration)
+      if duration
+        "#{duration.round(self[:duration_accuracy])}s"
+      end
+    end
+
+    def duration_msg?(duration)
+      if formatted_duration = formatted_duration?(duration)
+        "DURATION: #{formatted_duration}"
+      end
+    end
+
+    private
+    
+    def bracket(aug_msg)
+      bracket_symbol = self[:bracket_symbol]
+      bracket_size    = self[:bracket_size]
+      "#{bracket_symbol * bracket_size} #{aug_msg} #{bracket_symbol * bracket_size}"
+    end
+    
+    def augment(msg, params = {})
+      msg_prefix = ''
+      started_at = params[:started_at]
+      if started_at and self[:include_start_time]
+        msg_prefix << "#{started_at} "
+      end
+      ret = "#{msg_prefix}#{msg}"
+      if  tabs = params[:tabs]
+        ident = ' ' * (tabs * self[:tab_size])
+        ret = ret.split("\n").map { |line| "#{ident}#{line}" }.join("\n") 
+      end
+      ret
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+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