dtk-client 0.7.4.1 → 0.7.5

data/lib/commands/common/thor/task_status/refresh_mode.rb

@@ -0,0 +1,56 @@
+module DTK::Client
+  class TaskStatus
+    class RefreshMode < self
+      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
+              #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/commands/common/thor/task_status/snapshot_mode.rb

@@ -0,0 +1,11 @@
+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/commands/common/thor/task_status/stream_mode.rb

@@ -0,0 +1,31 @@
+require 'hirb'
+module DTK::Client
+  class TaskStatus
+    class StreamMode < self
+      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)
+        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/commands/common/thor/task_status/stream_mode/element.rb

@@ -0,0 +1,90 @@
+module DTK::Client; class TaskStatus::StreamMode
+  class Element
+    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__))
+    require File.expand_path('element/render',File.dirname(__FILE__))
+    include RenderMixin
+    
+    def initialize(response_element)
+      @response_element = response_element
+    end
+
+    def self.get_and_render_task_start(task_status_handle)
+      render_elements(TaskStart.get(task_status_handle))
+    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
+
+      stage = 1
+      task_end = false
+      until task_end do
+        elements = Stage.get(task_status_handle,stage)
+        if no_results_yet?(elements)
+          sleep wait
+          next
+        end
+        
+        render_elements(elements)
+        
+        if task_end?(elements)
+          task_end = true
+        else
+          stage += 1
+        end
+      end
+    end
+    
+    def render()
+      #TODO: stub
+      #TODO: make this nil and overwride all elements types to render
+      pp [:element,self.class,self]
+    end
+    
+    private
+    # opts will have
+    #   :start_index
+    #   :end_index
+    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)
+    end
+
+    def self.create_elements(response)
+      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)}
+    end
+    def self.create(response_element)
+      type = response_element['type'] 
+      case type && type.to_sym
+        when :task_start then TaskStart.new(response_element)
+        when :task_end   then TaskEnd.new(response_element)
+        when :stage      then Stage.new(response_element)
+        when :no_results then NoResults.new(response_element)
+        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
+    
+  end
+end; end

data/lib/commands/common/thor/task_status/stream_mode/element/no_results.rb

@@ -0,0 +1,10 @@
+module DTK::Client; class TaskStatus::StreamMode
+  class Element
+    class NoResults < self
+      def task_end?()
+        true
+      end
+    end
+  end
+end; end
+

data/lib/commands/common/thor/task_status/stream_mode/element/render.rb

@@ -0,0 +1,88 @@
+module DTK::Client; class TaskStatus::StreamMode
+  class Element
+    module RenderMixin
+    end
+  end
+end; end
+
+=begin
+      def task_status_old()
+        current_index = 1
+        last_printed_index = 0
+        success_indices = []
+        loop do
+          response = post_call(:form => :stream_form)
+          return response unless response.ok?
+          
+          current_tasks = response.data.select { |el| el['index'] == current_index }
+          main_task     = current_tasks.find { |el| el['sub_index'].nil? }
+          
+          # this means this is last tasks
+          unless main_task
+            print_succeeded_tasks(response.data, success_indices)
+            return Response::Ok.new()
+          end
+          
+          case main_task['status']
+          when 'executing'
+            if (last_printed_index != current_index)
+              OsUtil.clear_screen
+              print_succeeded_tasks(response.data, success_indices)
+              print_tasks(current_tasks)
+              last_printed_index = current_index
+            end
+          when 'succeeded'
+            success_indices << current_index
+            current_index  += 1
+          when nil
+            # ignore
+          else
+            errors = current_tasks.collect { |ct| ct['errors'] }.compact
+            error_msg = errors.collect { |err| err['message'] }.uniq.join(', ')
+            raise DtkError, "We've run into an error on task '#{main_task['type']}' status '#{main_task['status']}', error: #{error_msg}"
+          end
+          
+          sleep(5)
+        end
+      end
+      
+     private
+      def print_tasks(tasks)
+        hirb_options = { 
+          :headers => nil, 
+          :filters => [Proc.new { |a| append_to(25, a) }, 
+                       Proc.new { |a| append_to(15, a)}, 
+                       Proc.new { |a| append_to(15, a)}, 
+                       Proc.new { |a| append_to(8, a)}], 
+          :unicode => true, 
+          :description => false 
+        }
+
+        tasks.each do |task|
+          node_name = task['node'] ? task['node']['name'] : ''
+          
+          puts Hirb::Helpers::AutoTable.render([[task['type'], task['status'], node_name, task['duration'], parse_date(task['started_at']), parse_date(task['ended_at'])]], hirb_options)
+        end
+      end
+
+      def print_succeeded_tasks(tasks, success_indices)
+        succeeded_tasks = tasks.select { |task| success_indices.include?(task['index']) }
+        print_tasks(succeeded_tasks)
+      end
+
+      def parse_date(string_date)
+        string_date.nil? ? (' ' * 17) : DateTime.parse(string_date).strftime('%H:%M:%S %d/%m/%y')
+      end
+
+      def append_to(number_of_chars, value)
+        value ||= ''
+        value.strip!
+        appending_str = ' ' * (number_of_chars - value.size)
+        value.insert(0, appending_str)
+      end
+    end
+  end
+end
+
+=end
+

data/lib/commands/common/thor/task_status/stream_mode/element/stage.rb

@@ -0,0 +1,13 @@
+module DTK::Client; class TaskStatus::StreamMode
+  class Element
+    class Stage < self
+      def self.get(task_status_handle,stage_num)
+        get_stages(task_status_handle,stage_num,stage_num)
+      end
+
+      def self.get_stages(task_status_handle,start_stage_num,end_stage_num)
+        get_task_status_elements(task_status_handle,:stage,:start_index => start_stage_num, :end_index => end_stage_num)
+      end
+    end
+  end
+end; end

data/lib/commands/common/thor/task_status/stream_mode/element/task_end.rb

@@ -0,0 +1,10 @@
+module DTK::Client; class TaskStatus::StreamMode
+  class Element
+    class TaskEnd < self
+      def task_end?()
+        true
+      end
+    end
+  end
+end; end
+

data/lib/commands/common/thor/task_status/stream_mode/element/task_start.rb

@@ -0,0 +1,10 @@
+module DTK::Client; class TaskStatus::StreamMode
+  class Element
+    class TaskStart < self
+      def self.get(task_status_handle)
+        get_task_status_elements(task_status_handle,:task_start,:start_index => 0, :end_index => 0)
+      end
+    end
+  end
+end; end
+

data/lib/commands/thor/account.rb

@@ -33,7 +33,7 @@ module DTK::Client
       [response, key_exists_already]
     end
 
-    def self.add_key(path_to_key, name='dtk-client')
+    def self.add_key(path_to_key, first_registration=false, name='dtk-client')
       match, matched_username = nil, nil
 
       unless File.file?(path_to_key)
@@ -45,6 +45,7 @@ module DTK::Client
 
       post_body = { :rsa_pub_key => rsa_pub_key.chomp }
       post_body.merge!(:username => name.chomp) if name
+      post_body.merge!(:first_registration => first_registration)
 
       proper_response = nil
       response, key_exists_already = Account.internal_add_user_access("account/add_user_direct_access", post_body, 'service module')
@@ -58,7 +59,8 @@ module DTK::Client
         repo_manager_fingerprint,repo_manager_dns = response.data_ret_and_remove!(:repo_manager_fingerprint,:repo_manager_dns)
 
         SSHUtil.update_ssh_known_hosts(repo_manager_dns,repo_manager_fingerprint)
-        name ||= response.data["new_username"]
+        name = response.data["new_username"]
+
         OsUtil.print("SSH key '#{name}' added successfully!", :yellow)
 
       end
@@ -117,7 +119,7 @@ module DTK::Client
       name, path_to_key = context_params.retrieve_arguments([:option_1!, :option_2],method_argument_names)
       path_to_key ||= SSHUtil.default_rsa_pub_key_path()
 
-      response, matched, matched_username = Account.add_key(path_to_key, name)
+      response, matched, matched_username = Account.add_key(path_to_key, false, name)
 
       if matched
         DTK::Client::OsUtil.print("Provided SSH pub key has already been added.", :yellow)
@@ -127,8 +129,8 @@ module DTK::Client
         DTK::Client::Configurator.add_current_user_to_direct_access() if response.ok?
       end
 
-      if response.ok? && !response.data(:registered_with_repoman)
-        OsUtil.print("Warning: We were not able to register your key with remote catalog! Contact DTK team for more infromation.", :yellow)
+      if response.ok? && response.data(:repoman_registration_error)
+        OsUtil.print("Warning: We were not able to register your key with remote catalog! #{response.data(:repoman_registration_error)}", :yellow)
       end
 
       response.ok? ? nil : response
@@ -147,8 +149,8 @@ module DTK::Client
       response = post rest_url("account/remove_user_direct_access"), { :username => name.chomp }
       return response unless response.ok?
 
-      if response.ok? && !response.data(:unregistered_with_repoman)
-        OsUtil.print("Warning: We were not able to unregister your key with remote catalog!", :yellow)
+      if response.ok? && response.data(:repoman_registration_error)
+        OsUtil.print("Warning: We were not able to unregister your key with remote catalog! #{response.data(:repoman_registration_error)}", :yellow)
       end
 
       OsUtil.print("SSH key '#{name}' removed successfully!", :yellow)
@@ -171,7 +173,7 @@ module DTK::Client
     def set_catalog_credentials(context_params)
       creds = DTK::Client::Configurator.enter_catalog_credentials()
 
-      response = post rest_url("account/set_catalog_credentials"), { :username => creds[:username], :password => creds[:password] }
+      response = post rest_url("account/set_catalog_credentials"), { :username => creds[:username], :password => creds[:password], :validate => true }
       return response unless response.ok?
 
       OsUtil.print("Your catalog credentials have been set!", :yellow)

data/lib/commands/thor/assembly.rb

@@ -194,11 +194,14 @@ module DTK::Client
       :type => :string
     method_option :settings, :type => :string, :aliases => '-s'
     def stage(context_params)
-      assembly_template_id, name = context_params.retrieve_arguments([:assembly_id!, :option_1],method_argument_names)
+      assembly_template_id, service_module_id, name = context_params.retrieve_arguments([:assembly_id!, :service_module_id, :option_1],method_argument_names)
       post_body = {
         :assembly_id => assembly_template_id
       }
 
+      # special case when we need service module id
+      post_body[:service_module_id] = service_module_id if context_params.pure_cli_mode
+
       # using this to make sure cache will be invalidated after new assembly is created from other commands e.g.
       # 'assembly-create', 'install' etc.
       @@invalidate_map << :assembly
@@ -251,10 +254,14 @@ module DTK::Client
     method_option :settings, :type => :string, :aliases => '-s'
     def deploy(context_params)
       context_params.forward_options(options)
-      assembly_template_id, name = context_params.retrieve_arguments([:assembly_id!, :option_1],method_argument_names)
+      assembly_template_id, service_module_id, name = context_params.retrieve_arguments([:assembly_id!, :service_module_id, :option_1],method_argument_names)
       post_body = {
         :assembly_id => assembly_template_id
       }
+
+      # special case when we need service module id
+      post_body[:service_module_id] = service_module_id if context_params.pure_cli_mode
+
       if commit_msg = options["commit_msg"]
         post_body.merge!(:commit_msg => commit_msg)
       end

data/lib/commands/thor/component_module.rb

@@ -326,58 +326,6 @@ module DTK::Client
       list_collaborators_module_aux(context_params)
     end
 
-
-    #### end: commands to interact with remote repo ###
-
-    #### commands to manage workspace and versioning ###
-=begin
-    desc "COMPONENT-MODULE-NAME/ID create-version VERSION", "Snapshot current state of component module as a new version"
-    def create_version(context_params)
-      component_module_id,version = context_params.retrieve_arguments([:component_module_id!,:option_1!],method_argument_names)
-
-      post_body = {
-        :component_module_id => component_module_id,
-        :rsa_pub_key => SSHUtil.rsa_pub_key_content()
-      }
-      response = post rest_url("component_module/versions"), post_body
-      return response unless response.ok?
-      versions = (response.data.first && response.data.first['versions'])||Array.new
-      if versions.include?(version)
-        return Response::Error::Usage.new("Version #{version} exists already")
-      end
-
-      component_module_name = get_module_name(component_module_id)
-      module_location = OsUtil.module_location(:component_module,component_module_name,version)
-      if File.directory?(module_location)
-        return Response::Error::Usage.new("Target component module directory for version #{version} (#{module_location}) exists already; it must be deleted and this comamnd retried")
-      end
-
-      post_body = {
-        :component_module_id => component_module_id,
-        :version => version
-      }
-      response = post rest_url("component_module/create_new_version"), post_body
-      return response unless response.ok?
-
-      internal_trigger = omit_output = true
-      clone_aux(:component_module,component_module_id,version,internal_trigger,omit_output)
-    end
-=end
-=begin
-    desc "COMPONENT-MODULE-NAME/ID list-versions","List all versions associated with this component module."
-    def list_versions(context_params)
-      component_module_id = context_params.retrieve_arguments([:component_module_id!],method_argument_names)
-      post_body = {
-        :component_module_id => component_module_id,
-        :detail_to_include => ["remotes"],
-        :rsa_pub_key => SSHUtil.rsa_pub_key_content()
-      }
-      response = post rest_url("component_module/versions"), post_body
-
-      response.render_table(:module_version)
-    end
-=end
-
     ##
     #
     # internal_trigger: this flag means that other method (internal) has trigger this.