dtk-client 0.7.4.1 → 0.7.5

data/lib/commands/common/thor/base_command_helper.rb

@@ -0,0 +1,42 @@
+module DTK::Client
+  class BaseCommandHelper
+    def initialize(command,context_params=nil)
+      @command        = command
+      @context_params = context_params
+      @options        = command.options
+    end
+
+    def print_external_dependencies(external_dependencies, location)
+      ambiguous        = external_dependencies["ambiguous"]||[]
+      amb_sorted       = ambiguous.map { |k,v| "#{k.split('/').last} (#{v.join(', ')})" }
+      inconsistent     = external_dependencies["inconsistent"]||[]
+      possibly_missing = external_dependencies["possibly_missing"]||[]
+
+      OsUtil.print("There are inconsistent module dependencies mentioned #{location}: #{inconsistent.join(', ')}", :red) unless inconsistent.empty?
+      OsUtil.print("There are missing module dependencies mentioned #{location}: #{possibly_missing.join(', ')}", :yellow) unless possibly_missing.empty?
+      OsUtil.print("There are ambiguous module dependencies mentioned #{location}: '#{amb_sorted.join(', ')}'. One of the namespaces should be selected by editing the module_refs file", :yellow) if ambiguous && !ambiguous.empty?
+    end
+
+   private
+    def context_params()
+      @context_params ||  raise(DtkError, "[ERROR] @context_params is nil")
+    end
+
+    def retrieve_arguments(mapping, method_info = nil)
+      context_params.retrieve_arguments(mapping, method_info || @command.method_argument_names)
+    end
+
+    def get_namespace_and_name(*args)
+      @command.get_namespace_and_name(*args)
+    end
+
+    def rest_url(*args)
+      @command.rest_url(*args)
+    end
+
+    def post(*args)
+      @command.post(*args)
+    end
+
+  end
+end

data/lib/commands/common/thor/clone.rb

@@ -1,7 +1,7 @@
 dtk_require_common_commands('thor/common')
 module DTK::Client
   module CloneMixin
-    extend Console
+    extend ::DTK::Client::Console
     include CommonMixin
     ##
     #

data/lib/commands/common/thor/module.rb

@@ -21,36 +21,9 @@ DEFAULT_COMMIT_MSG = "Initial commit."
 PULL_CATALOGS = ["dtkn"]
 
 module DTK::Client
+  dtk_require_common_commands('thor/base_command_helper')
   class CommonModule
     dtk_require_common_commands('thor/module/import')
-
-    def initialize(command,context_params)
-      @command        = command
-      @context_params = context_params
-      @options        = command.options
-    end
-
-    def print_external_dependencies(external_dependencies, location)
-      ambiguous        = external_dependencies["ambiguous"]||[]
-      amb_sorted       = ambiguous.map { |k,v| "#{k.split('/').last} (#{v.join(', ')})" }
-      inconsistent     = external_dependencies["inconsistent"]||[]
-      possibly_missing = external_dependencies["possibly_missing"]||[]
-
-      OsUtil.print("There are inconsistent module dependencies mentioned #{location}: #{inconsistent.join(', ')}", :red) unless inconsistent.empty?
-      OsUtil.print("There are missing module dependencies mentioned #{location}: #{possibly_missing.join(', ')}", :yellow) unless possibly_missing.empty?
-      OsUtil.print("There are ambiguous module dependencies mentioned #{location}: '#{amb_sorted.join(', ')}'. One of the namespaces should be selected by editing the module_refs file", :yellow) if ambiguous && !ambiguous.empty?
-    end
-
-   private
-    # TODO: when we do this for other areas we can move these things up and use as common classes
-    # helpers
-    def retrieve_arguments(mapping, method_info = nil)
-      @context_params.retrieve_arguments(mapping, method_info || @command.method_argument_names)
-    end
-
-    def get_namespace_and_name(*args)
-      @command.get_namespace_and_name(*args)
-    end
   end
 
   module ModuleMixin
@@ -157,7 +130,7 @@ module DTK::Client
       unless method_opts[:no_error_msg]
         msg = "Module '#{module_name}' "
         if version then msg << "version #{version} has been deleted"
-        else  msg << "has been deleted"; end
+        else msg << "has been deleted"; end
         OsUtil.print(msg, :yellow)
       end
 
@@ -166,9 +139,9 @@ module DTK::Client
 
     def set_attribute_module_aux(context_params)
       if context_params.is_there_identifier?(:attribute)
-        mapping = [REQ_MODULE_ID,:attribute_id!, :option_1]
+        mapping = [REQ_MODULE_ID, :attribute_id!, :option_1]
       else
-        mapping = [REQ_MODULE_ID,:option_1!,:option_2]
+        mapping = [REQ_MODULE_ID, :option_1!, :option_2]
       end
 
       module_id, attribute_id, value = context_params.retrieve_arguments(mapping, method_argument_names)
@@ -181,13 +154,13 @@ module DTK::Client
         "#{module_type}_id".to_sym => module_id
       }
 
-      post rest_url("attribute/set"), post_body
+      post rest_url('attribute/set'), post_body
     end
 
-    def push_module_aux(context_params, internal_trigger=false, opts={})
+    def push_module_aux(context_params, internal_trigger = false, opts = {})
       module_type = get_module_type(context_params)
-      module_id, module_name = context_params.retrieve_arguments([REQ_MODULE_ID, "#{module_type}_name".to_sym],method_argument_names)
-      version = options["version"]
+      module_id, module_name = context_params.retrieve_arguments([REQ_MODULE_ID, "#{module_type}_name".to_sym], method_argument_names)
+      version = options['version']
 
       module_location = OsUtil.module_location(module_type, module_name, version)
 
@@ -196,8 +169,8 @@ module DTK::Client
       opts.merge!(:force => options.force?)
 
       reparse_aux(module_location)
-      push_clone_changes_aux(module_type.to_sym, module_id, version, options["message"]||DEFAULT_COMMIT_MSG, internal_trigger, opts)
-     end
+      push_clone_changes_aux(module_type.to_sym, module_id, version, options['message'] || DEFAULT_COMMIT_MSG, internal_trigger, opts)
+    end
 
     def create_test_module_aux(context_params)
       test_module_name = context_params.retrieve_arguments([:option_1!], method_argument_names)
@@ -209,10 +182,10 @@ module DTK::Client
       create_response = import(context_params)
 
       unless create_response.ok?
-        error_msg = create_response['errors'].select { |er| er['message'].include? "cannot be created since it exists already" }
+        error_msg = create_response['errors'].select { |er| er['message'].include? 'cannot be created since it exists already' }
         if error_msg.empty?
           # If server response is not ok and module does not exist on server, delete cloned module, invoke delete method
-          delete(context_params,:force_delete => true, :no_error_msg => true)
+          delete(context_params, :force_delete => true, :no_error_msg => true)
         end
 
         # remove temp directory
@@ -227,13 +200,13 @@ module DTK::Client
     end
 
     def import_module_aux(context_params)
-      CommonModule::Import.new(self,context_params).from_file()
+      CommonModule::Import.new(self, context_params).from_file()
     end
 
     def install_module_aux(context_params)
       create_missing_clone_dirs()
       resolve_direct_access(::DTK::Client::Configurator.check_direct_access)
-      remote_module_name, version = context_params.retrieve_arguments([:option_1!, :option_2],method_argument_names)
+      remote_module_name, version = context_params.retrieve_arguments([:option_1!, :option_2], method_argument_names)
       # in case of auto-import via service import, we skip cloning to speed up a process
       skip_cloning = context_params.get_forwarded_options()['skip_cloning'] if context_params.get_forwarded_options()
       do_not_raise = context_params.get_forwarded_options()[:do_not_raise] if context_params.get_forwarded_options()
@@ -241,40 +214,44 @@ module DTK::Client
       module_type  = get_module_type(context_params)
 
       # ignore_component_error = context_params.get_forwarded_options()[:ignore_component_error]||options.ignore? if context_params.get_forwarded_options()
-      ignore_component_error = context_params.get_forwarded_options() ? context_params.get_forwarded_options()[:ignore_component_error] : options.ignore?
+      ignore_component_error = context_params.get_forwarded_options().empty? ? options.ignore? : context_params.get_forwarded_options()[:ignore_component_error]
       additional_message     = context_params.get_forwarded_options()[:additional_message] if context_params.get_forwarded_options()
 
-      remote_namespace, local_module_name = get_namespace_and_name(remote_module_name,':')
+      remote_namespace, local_module_name = get_namespace_and_name(remote_module_name, ':')
 
       if clone_dir = Helper(:git_repo).local_clone_dir_exists?(module_type.to_sym, local_module_name, :namespace => remote_namespace, :version => version)
-        message = "Module's directory (#{clone_dir}) exists on client. To install this needs to be renamed or removed"
-        message += ". To ignore this conflict and use existing component module please use -i switch (install REMOTE-SERVICE-NAME -i)." if additional_message
+        message = "Module's directory (#{clone_dir}) exists on client. To install this needs to be renamed or removed."
+        # message += '. To ignore this conflict and use existing component module please use -i switch (install REMOTE-SERVICE-NAME -i).' if additional_message
 
         raise DtkError, message unless ignore_component_error
       end
 
       post_body = {
-        :remote_module_name => remote_module_name.sub(':','/'),
+        :remote_module_name => remote_module_name.sub(':', '/'),
         :local_module_name => local_module_name,
         :rsa_pub_key => SSHUtil.rsa_pub_key_content()
       }
       post_body.merge!(:do_not_raise => do_not_raise) if do_not_raise
       post_body.merge!(:ignore_component_error => ignore_component_error) if ignore_component_error
       post_body.merge!(:additional_message => additional_message) if additional_message
+      post_body.merge!(:skip_auto_install => skip_ainstall) if skip_ainstall
 
       response = post rest_url("#{module_type}/import"), post_body
-      are_there_warnings = RemoteDependencyUtil.print_dependency_warnings(response)
+
+      # print permission warnings and then check for other warnings
+      are_there_warnings = RemoteDependencyUtil.check_permission_warnings(response)
+      are_there_warnings ||= RemoteDependencyUtil.print_dependency_warnings(response, nil, :ignore_permission_warnings => true)
 
       # prompt to see if user is ready to continue with warnings/errors
       if are_there_warnings
-        return false unless Console.confirmation_prompt("Do you still want to proceed with import"+'?')
+        return false unless Console.confirmation_prompt('Do you still want to proceed with import' + '?')
       end
 
       # case when we need to import additional components
-      if (response.ok? && !skip_ainstall && (missing_components = response.data(:missing_module_components)))
+      if response.ok? && !skip_ainstall && (missing_components = response.data(:missing_module_components))
         required_components = response.data(:required_modules)
-        opts = {:do_not_raise=>true}
-        module_opts = ignore_component_error ? opts.merge(:ignore_component_error => true) : opts.merge(:additional_message=>true)
+        opts = { :do_not_raise => true }
+        module_opts = ignore_component_error ? opts.merge(:ignore_component_error => true) : opts.merge(:additional_message => true)
         module_opts.merge!(:update_none => true) if options.update_none?
 
         continue = trigger_module_auto_import(missing_components, required_components, module_opts)
@@ -286,11 +263,10 @@ module DTK::Client
         response = post rest_url("#{module_type}/import"), post_body
 
         # we set skip cloning since it is already done by import
-        puts " Done"
+        puts ' Done'
       end
 
-      return response if(!response.ok? || response.data(:does_not_exist))
-      # module_name,repo_url,branch,version = response.data(:module_name, :repo_url, :workspace_branch, :version)
+      return response if !response.ok? || response.data(:does_not_exist)
       module_id, module_name, namespace, repo_url, branch, version = response.data(:module_id, :module_name, :namespace, :repo_url, :workspace_branch, :version)
 
       if error = response.data(:dsl_parse_error)
@@ -309,13 +285,13 @@ module DTK::Client
 
     def delete_from_catalog_aux(context_params)
       module_type        = get_module_type(context_params)
-      remote_module_name = context_params.retrieve_arguments([:option_1!],method_argument_names)
+      remote_module_name = context_params.retrieve_arguments([:option_1!], method_argument_names)
 
       # remote_module_name can be namespace:name or namespace/name
       remote_namespace, remote_module_name = get_namespace_and_name(remote_module_name, ':')
 
       unless options.force? || options.confirmed?
-        return unless Console.confirmation_prompt("Are you sure you want to delete remote #{module_type} '#{remote_namespace.nil? ? '' : remote_namespace+'/'}#{remote_module_name}' and all items contained in it"+'?')
+        return unless Console.confirmation_prompt("Are you sure you want to delete remote #{module_type} '#{remote_namespace.nil? ? '' : remote_namespace + '/'}#{remote_module_name}' and all items contained in it" + '?')
       end
 
       post_body = {
@@ -330,7 +306,7 @@ module DTK::Client
 
     def publish_module_aux(context_params)
       module_type  = get_module_type(context_params)
-      module_id, input_remote_name = context_params.retrieve_arguments([REQ_MODULE_ID, :option_1],method_argument_names)
+      module_id, input_remote_name = context_params.retrieve_arguments([REQ_MODULE_ID, :option_1], method_argument_names)
 
       post_body = {
         "#{module_type}_id".to_sym => module_id,
@@ -354,6 +330,7 @@ module DTK::Client
       version      = options.version
       module_type  = get_module_type(context_params)
       skip_recursive_pull = context_params.get_forwarded_options()[:skip_recursive_pull]
+      ignore_dependency_merge_conflict = context_params.get_forwarded_options()[:skip_recursive_pull]
 
       raise DtkValidationError, "You have to provide valid catalog to pull changes from! Valid catalogs: #{PULL_CATALOGS}" unless catalog
 
@@ -365,9 +342,11 @@ module DTK::Client
           :force               => options.force?,
           :version             => version,
           :remote_namespace    => options.namespace,
-          :skip_recursive_pull => skip_recursive_pull
+          :skip_recursive_pull => skip_recursive_pull,
+          :ignore_dependency_merge_conflict => ignore_dependency_merge_conflict
         }
 
+        opts.merge!(:do_not_raise => true) if (context_params.get_forwarded_options()||{})[:do_not_raise]
         response = pull_from_remote_aux(module_type.to_sym, module_id, opts)
         return response unless response.ok?
 

data/lib/commands/common/thor/module/import.rb

@@ -4,7 +4,7 @@ dtk_require_from_base("command_helper")
 
 module DTK::Client
   class CommonModule
-    class Import < self
+    class Import < BaseCommandHelper
       include CommandBase
       include CommandHelperMixin
       include PushCloneChangesMixin

data/lib/commands/common/thor/pull_from_remote.rb

@@ -34,7 +34,7 @@ module DTK::Client
         unless rsa_pub_key
           raise DtkError,"No File found at (#{path_to_key}). Path is wrong or it is necessary to generate the public rsa key (e.g., run ssh-keygen -t rsa)"
         end
-        opts_perform_locally = remote_params.merge(:full_module_name => full_module_name, :force => opts[:force])
+        opts_perform_locally = remote_params.merge(:full_module_name => full_module_name, :force => opts[:force], :do_not_raise => opts[:do_not_raise], :ignore_dependency_merge_conflict => opts[:ignore_dependency_merge_conflict])
         PullFromRemote.perform_locally(self,module_type,module_id,module_name,opts_perform_locally)
       else
         # TODO: see if this works correctly
@@ -47,10 +47,11 @@ module DTK::Client
     ##
     #
     # module_type: will be :component_module or :service_module
-    def import_module_component_dependencies(module_type, module_id, remote_namespace=nil)
+    def import_module_component_dependencies(module_type, module_id, remote_namespace = nil)
       response = resolve_pull_from_remote_on_server(module_type, module_id, remote_namespace)
 
       print "Resolving dependencies please wait ... "
+      RemoteDependencyUtil.check_permission_warnings(response)
 
       # install them all!
       if (response.ok? && !(missing_components = response.data(:missing_modules)).empty?)
@@ -91,21 +92,15 @@ module DTK::Client
         response = cmd_obj.Helper(:git_repo).pull_changes(module_type,module_name,opts)
 
         # return response unless response.ok?
-        if (response.data[:diffs].nil? || response.data[:diffs].empty?)
-          puts "No changes to pull from remote."
+        if custom_message = response.data[:custom_message]
+          puts custom_message
+        elsif (response.data[:diffs].nil? || response.data[:diffs].empty?)
+          puts "No changes to pull from remote." unless response['errors']
         else
           puts "Changes pulled from remote"
         end
 
         return response
-
-        # removing this for now, because we will use push-clone-changes as part of pull-from-remote command
-        # post_body = {
-        #   id_field(module_type) => module_id,
-        #   :commit_sha => response.data[:commit_sha],
-        #   :json_diffs => JSON.generate(response.data[:diffs])
-        # }
-        # post rest_url("#{module_type}/update_model_from_clone"), post_body
       end
 
       def self.perform_on_server(cmd_obj,module_type,module_id,module_name,remote_params)

data/lib/commands/common/thor/purge_clone.rb

@@ -1,6 +1,6 @@
 module DTK::Client
   module PurgeCloneMixin
-    def purge_clone_aux(module_type,opts={})
+    def purge_clone_aux(module_type, opts = {})
       module_name = opts[:module_name]
       version = opts[:version]
       opts_module_loc = (opts[:assembly_module] ? {:assembly_module => opts[:assembly_module]} : Hash.new)

data/lib/commands/common/thor/push_clone_changes.rb

@@ -16,7 +16,7 @@ module DTK::Client
 
       unless File.directory?(module_location)
         return if opts[:skip_cloning]
-        if Console.confirmation_prompt("Push not possible, module '#{module_name}#{version && "-#{version}"}' has not been cloned. Would you like to clone module now"+'?')
+        if opts[:force_clone] || Console.confirmation_prompt("Push not possible, module '#{module_name}#{version && "-#{version}"}' has not been cloned. Would you like to clone module now"+'?')
           clone_aux(module_type, module_id, version, true, true, opts)
         else
           return
@@ -32,12 +32,14 @@ module DTK::Client
       repo_obj   = response.data(:repo_obj)
       json_diffs = JSON.generate(response.data(:diffs))
       post_body  = get_workspace_branch_info_post_body(module_type, module_id, version, opts).merge(:json_diffs => json_diffs, :commit_sha => commit_sha)
+
       post_body.merge!(:modification_type => opts[:modification_type]) if opts[:modification_type]
       post_body.merge!(:force_parse => true) if options['force-parse'] || opts[:force_parse]
       post_body.merge!(:update_from_includes => true) if opts[:update_from_includes]
       post_body.merge!(:service_instance_module => true) if opts[:service_instance_module]
       post_body.merge!(:current_branch_sha => opts[:current_branch_sha]) if opts[:current_branch_sha]
       post_body.merge!(:force => opts[:force]) if opts[:force]
+      post_body.merge!(:task_action => opts[:task_action]) if opts[:task_action]
 
       if opts[:set_parsed_false]
         post_body.merge!(:set_parsed_false => true)

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

@@ -1,86 +1,63 @@
 module DTK::Client
   module TaskStatusMixin
-    def task_status_aux(id,type,opts={})
-        if opts[:wait]
-          # there will be infinite loop until intereputed with CTRL+C
-          begin
-            response = nil
-            loop do 
-              response = task_status_aux_post(id,type,opts)
-              raise DTK::Client::DtkError, "[ERROR] #{response['errors'].first['message']}." if response["status"].eql?('notok')
-
-              # 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 '#{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
+    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
-          response = task_status_aux_post(id,type,opts)
-          response.print_error_table = true
-          response.render_table(:task_status)
-        end
+          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()
+    end
 
-      def list_task_info_aux(type, id)
-        id_sym = "#{type}_id".to_sym
-        post_body = {
-          id_sym => id,
-          :format => :list
-        }
-        response = post rest_url("#{type}/task_status"), post_body
-        
-        raise DTK::Client::DtkError, "[SERVER ERROR] #{response['errors'].first['message']}." if response["status"].eql?('notok')
-           
-        response.override_command_class("list_task")
-        puts response.render_data
+    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__))
 
-     private
-      def task_status_aux_post(id,type,opts={})
-        id_field = "#{type}_id".to_sym
-        post_body_hash = {
-          id_field                => id,
-          :format                 => :table,
-          :summarize_node_groups? => opts[:summarize]
-        }
-        post rest_url("#{type}/task_status"), PostBody.new(post_body_hash)
+    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],
+        :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