dtk-client 0.10.4 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43813c96b0c40e8459d6668ca71bd0b8db38958f
-  data.tar.gz: ab8249e25eb9242e7b09f45b68b834e5c059764c
+  metadata.gz: 770b6fa7ab8687c5275c4acce3eaa5cae52a330c
+  data.tar.gz: 745309e408b3d4fa06175f4cdb82d665afd22c7b
 SHA512:
-  metadata.gz: 4dbb96de07e1c8ca3f6721b15151196e91f52444b002aef643fedd7aad32e494d2db00d499a807abc474909d7374d1256861fe90b03e2d1ad8a63e9d665651ba
-  data.tar.gz: abc0b3255033efc1ad9ee47e99eab523e25f4226732ae837de6c36cb1b9bbe99dd696d021ee18f46aa4518392f09997cb83aa809c283eb3040d6ee4f629fba85
+  metadata.gz: 5d614db5a69af9d464e21ec16f4c78209e2061c3dbd97c2b4890928c87b457aa5d2822860c3ae3c27c97b29889b729ea96199ac34b2390878989450f121f4881
+  data.tar.gz: 8be6f20053599b04e50d144b7de3b8a58a6f5cb9e5c0cd6de8fcdea60d39c86cf5045d8da5e6c529e0024ce177edbd34ab686472d55b719c35ff7b1d2da9c7a3

data/lib/cli/command/account/add_ssh_key.rb

@@ -21,7 +21,6 @@ module DTK::Client
       subcommand_def 'add-ssh-key' do |c|
         c.arg Token::Arg.keypair_name
         command_body c, 'add-ssh-key', 'Adds SSH key for current user' do |sc|
-          sc.flag Token.directory_path
           sc.action do |_global_options, options, args|
             directory_path = options[:directory_path]
             name           = args[0]

data/lib/cli/command/account/delete_ssh_key.rb

@@ -21,7 +21,6 @@ module DTK::Client
       subcommand_def 'delete-ssh-key' do |c|
         c.arg Token::Arg.keypair_name
         command_body c, 'delete-ssh-key', 'Deletes SSH key for current user' do |sc|
-          sc.flag Token.directory_path
           sc.switch Token.skip_prompt
           sc.action do |_global_options, options, args|
             skip_prompt    = options[:skip_prompt]

data/lib/cli/command/module/delete_from_remote.rb

@@ -23,10 +23,16 @@ module DTK::Client
         command_body c, 'delete-from-remote', 'Delete module from the DTK remote catalog (DTKN)' do |sc|
           sc.flag Token.version
           sc.switch Token.skip_prompt
+          sc.switch Token.force
 
           sc.action do |_global_options, options, args|
             module_ref = module_ref_object_from_options_or_context?(:module_ref => args[0], :version => options[:version])
-            Operation::Module.delete_from_remote(:module_ref => module_ref, :skip_prompt => options[:skip_prompt])
+            operation_args = {
+              :module_ref  => module_ref,
+              :skip_prompt => options[:skip_prompt],
+              :force       => options[:force]
+            }
+            Operation::Module.delete_from_remote(operation_args)
           end
         end
       end

data/lib/cli/command/module/pull_dtkn.rb

@@ -21,10 +21,18 @@ module DTK::Client
       subcommand_def 'pull-dtkn' do |c|
         command_body c, 'pull-dtkn', 'Pull content from repo manager to client module directory and push to server' do |sc|
           sc.flag Token.directory_path, :desc => 'Absolute or relative path to module directory containing content to update; not need if in the module directory'
+          sc.switch Token.skip_prompt
           sc.action do |_global_options, options, _args|
             module_ref = module_ref_object_from_options_or_context(options)
-            Operation::Module.pull_dtkn(:module_ref => module_ref, :base_dsl_file_obj => @base_dsl_file_obj)
-            Operation::Module.push(:module_ref => module_ref, :base_dsl_file_obj => @base_dsl_file_obj, :directory_path => options[:directory_path], :method => "pulled")
+            operation_args = {
+              :module_ref          => module_ref,
+              :base_dsl_file_obj   => @base_dsl_file_obj,
+              :has_directory_param => !options["d"].nil?,
+              :directory_path      => options[:directory_path],
+              :skip_prompt         => options[:skip_prompt]
+            }
+            Operation::Module.pull_dtkn(operation_args)
+            Operation::Module.push(operation_args.merge(:method => "pulled"))
           end
         end
       end

data/lib/cli/runner.rb

@@ -44,10 +44,31 @@ module DTK::Client
       end
       
       private
-      
+
+      CONNECTION_RETRIES = 20
+      SLEEP_BETWEEN_RETRIES = 1
       def self.raise_error_if_invalid_connection
-        connection = Session.get_connection
-        raise Error::InvalidConnection.new(connection) if connection.connection_error?
+        connection_retries = connection_retries()
+        count = 0
+        while count < connection_retries 
+          connection = Session.get_connection(count == 0 ? {} : { reset: true })
+          return unless connection.connection_error?
+          if connection.connection_refused_error_code?
+            sleep SLEEP_BETWEEN_RETRIES
+            count += 1
+          else
+            raise Error::InvalidConnection.new(connection)
+          end
+        end
+        raise Error::InvalidConnection.new(connection)
+      end
+
+      def self.connection_retries
+        ret = 
+          if env_val = ENV['DTK_CONNECTION_RETRIES']
+            env_val.to_i rescue nil  
+          end
+        ret || CONNECTION_RETRIES
       end
 
       def self.render_response(response_obj)

data/lib/cli/version.rb

@@ -18,7 +18,7 @@
 module DTK
   module Client
     module CLI
-      VERSION="0.10.4"
+      VERSION="0.10.5"
     end
   end
 end

data/lib/client/config/default.conf

@@ -10,8 +10,6 @@ auto_commit_changes=false       # autocommit for modules
 verbose_rest_calls=false        # logging of REST calls
 
 service_instance_location=service
-module_location=component-modules
-service_location=service-modules
 assembly_module_base_location=assemblies
 backups_location=backups
 

data/lib/client/conn.rb

@@ -67,10 +67,6 @@ module DTK::Client
       check_and_wrap_response { json_parse_if_needed(post_raw(url,post_body,{:content_type => 'avro/binary'})) }
     end
 
-    def connection_error?
-      !@connection_error.nil?
-    end
-    
     ##
     # Method will warn user that connection could not be established. User should check configuration
     # to make sure that connection is properly set.
@@ -84,14 +80,25 @@ module DTK::Client
       printf "%15s %s\n", "Password:", "#{creds[:password] ? creds[:password].gsub(/./,'*') : 'No password set'}"
       puts   "==================================================================="
       
-      if connection_error['errors'].first['errors']
-        error_code = self.connection_error['errors'].first['errors'].first['code']
+      if error_code =  error_code?
         OsUtil.print_error("Error code: #{error_code}")
       end
     end
+
+    def connection_error?
+      !connection_error.nil?
+    end
+
+    def connection_refused_error_code?
+      error_code? == 'connection_refused'
+    end
     
     private
 
+    def error_code?
+      connection_error['errors'].first['code'] rescue nil
+    end
+
     REST_VERSION = 'v1'
     REST_PREFIX = "rest/api/#{REST_VERSION}"
     # REST_PREFIX = "rest"
@@ -149,7 +156,7 @@ module DTK::Client
         @cookies = response.cookies
       end
     end
-    
+
     def logout
       response = get_raw rest_url('auth/logout')
       # TODO: see if response can be nil

data/lib/client/error/subclasses.rb

@@ -86,7 +86,7 @@ module DTK::Client
         @bad_connection = bad_connection
       end
       def print_warning
-        @bad_connection.print_warning
+        @bad_connection.print_warning if @bad_connection
       end
     end
     

data/lib/client/git_repo/adapter/git_gem.rb

@@ -26,10 +26,39 @@ module DTK::Client
       extend ErrorHandler::Mixin
       
       attr_accessor :git_repo
+
+      # Monkey patch the git merge method
+      # to allow passing the --allow-unrelated-histories flag
+      # more info: http://stackoverflow.com/questions/37937984/git-refusing-to-merge-unrelated-histories
+      class ::Git::Base
+        def merge(branch, message = 'merge', opts = {})
+          self.lib.merge(branch, message, opts)
+        end
+
+        def rev_list(sha)
+          self.lib.rev_list(sha)
+        end
+      end
+
+      class ::Git::Lib
+        def merge(branch, message = nil, opts = {})
+          arr_opts = []
+          arr_opts << '--allow-unrelated-histories' if opts[:allow_unrelated_histories]
+          arr_opts << '-m' << message if message
+          arr_opts += [branch]
+          command('merge', arr_opts)
+        end
+
+        def rev_list(sha)
+          arr_opts = [sha]
+          command('rev-list', arr_opts)
+        end
+      end
       
       # opts can have keys
       #  :branch
       def initialize(repo_dir, opts = {})
+        @repo_dir = repo_dir
         @git_repo = ::Git.init(repo_dir)
         # If we want to log Git interaction
         # @git_repo = ::Git.init(repo_dir, :log => Logger.new(STDOUT))
@@ -80,7 +109,7 @@ module DTK::Client
       end
 
       def merge(branch_to_merge_from)
-        @git_repo.merge(branch_to_merge_from)
+        @git_repo.merge(branch_to_merge_from, 'merge', :allow_unrelated_histories => allow_unrelated_histories?)
       end
 
       def status
@@ -121,7 +150,24 @@ module DTK::Client
       def reset_soft(sha)
         @git_repo.reset(sha)
       end
-        
+
+      def reset_hard(sha)
+        @git_repo.reset_hard(sha)
+      end
+
+      def revparse(sha_or_string)
+        @git_repo.revparse(sha_or_string)
+      end
+
+      def rev_list(base_sha)
+        @git_repo.rev_list(base_sha)
+      end
+
+      def local_ahead(base_sha, remote_sha)
+        results = @git_repo.rev_list(base_sha)
+        !results.split("\n").grep(remote_sha).empty?
+      end
+
       def stage_changes()
         handle_git_error do
           @git_repo.add(untracked())
@@ -150,7 +196,9 @@ module DTK::Client
       end
 
       def add_all
-        @git_repo.add(:all => true)
+        # Cannot use '@git_repo.add(:all => true)' because this only works if pwd is base git repo
+        fully_qualified_repo_dir = (@repo_dir =~ /^\// ? @repo_dir : File.join(Dir.pwd, @repo_dir))
+        @git_repo.add(fully_qualified_repo_dir, :all => true )
       end
 
       def is_there_remote?(remote_name)
@@ -232,6 +280,13 @@ module DTK::Client
         "DTK Commit from client"
       end
 
+      def allow_unrelated_histories?
+        git_version_output = `git --version`
+        git_version = git_version_output.split.last
+        # --allow-unrelated_histories was introduced in git 2.9
+        Gem::Version.new(git_version) >= Gem::Version.new('2.9.0')
+      end
+
     end
   end
 end

data/lib/client/git_repo.rb

@@ -28,9 +28,12 @@ module DTK::Client
     # opts can have keys
     #  :branch
     def initialize(repo_dir, opts = {})
+      @repo_dir    = repo_dir
       @git_adapter = git_adapter_class.new(repo_dir, opts)
     end
 
+    attr_reader :repo_dir
+
     def self.clone(repo_url, target_path, branch)
       git_adapter_class.clone(repo_url, target_path, branch)
     end
@@ -146,6 +149,26 @@ module DTK::Client
       @git_adapter.reset_soft(sha)
     end
 
+    def reset_hard(sha)
+      @git_adapter.reset_hard(sha)
+    end
+
+    def revparse(string)
+      @git_adapter.revparse(string)
+    end
+
+    def rev_list(base_sha)
+      @git_adapter.rev_list(base_sha)
+    end
+
+    def local_ahead(base_sha, remote_sha)
+      @git_adapter.local_ahead(base_sha, remote_sha)
+    end
+
+    def add_all
+      @git_adapter.add_all
+    end
+
     def all_branches
       @git_adapter.all_branches
     end

data/lib/client/load_source/component_info.rb

@@ -20,8 +20,10 @@ module DTK::Client
     class ComponentInfo < self
       def fetch_and_cache_info
         fetch_remote
-        merge_from_remote
-        transform_from_component_info
+        unless local_ahead?.data('local_ahead')
+          merge_from_remote
+          transform_from_component_info
+        end
       end
 
       def fetch_info

data/lib/client/load_source/service_info.rb

@@ -20,8 +20,10 @@ module DTK::Client
     class ServiceInfo < self
       def fetch_and_cache_info
         fetch_remote
-        merge_from_remote
-        transform_from_service_info
+        unless local_ahead?.data('local_ahead')
+          merge_from_remote
+          transform_from_service_info
+        end
       end
 
       def fetch_info

data/lib/client/load_source.rb

@@ -111,6 +111,11 @@ module DTK::Client
       git_repo_operation.merge_from_dtkn_remote(git_repo_args)
     end
 
+    def local_ahead?
+      git_repo_args = common_git_repo_args.merge(:remote_branch => git_repo_remote_branch, :no_commit => true)
+      git_repo_operation.local_ahead?(git_repo_args)
+    end
+
     def self.stage_and_commit(target_repo_dir, commit_msg = nil)
       git_repo_args = {
         :repo_dir          => target_repo_dir,

data/lib/client/operation/client_module_dir/git_repo/internal/dtkn.rb

@@ -51,6 +51,11 @@ module DTK::Client
           Internal.merge(@repo, merge_from_ref, :no_commit => opts[:no_commit])
         end
 
+        def local_ahead?(remote_branch, opts = {})
+          merge_from_ref = "#{remote_name}/#{remote_branch}"
+          Internal.local_ahead?(@repo, merge_from_ref, :no_commit => opts[:no_commit])
+        end
+
         private
 
         # TODO: These constants used in Internal; Deprecate GIT_REMOTE amd LOCAL_BRANCH for remote_name and local_branch

data/lib/client/operation/client_module_dir/git_repo/internal.rb

@@ -61,10 +61,11 @@ module DTK::Client
           repo.head_commit_sha
         end
 
-        def self.checkout_branch__return_repo(repo_dir, local_branch, opts = {})
-          repo = create_empty_git_repo?(repo_dir, :branch => local_branch)
-          repo.checkout(local_branch)
-          repo
+        def self.local_ahead?(repo, merge_from_ref, opts = {})
+          base_sha = repo.head_commit_sha
+          remote_branch = repo.all_branches.remote.find { |r| "#{r.remote}/#{r.name}" == merge_from_ref }
+          remote_sha = remote_branch.gcommit.sha
+          repo.local_ahead(base_sha, remote_sha)
         end
 
         # opts can have keys:
@@ -251,7 +252,7 @@ module DTK::Client
           service_instance = args.required(:service_instance)
           path             = args.required(:path)
           content          = args.required(:content)
-          checkout_branch(service_instance, branch) do
+          checkout_branch_on_service_instance(service_instance, branch) do
             File.open(qualified_path(service_instance, path), 'w') { |f| f.write(content) }
           end
         end
@@ -261,7 +262,7 @@ module DTK::Client
           branch           = args.required(:branch)
           service_instance = args.required(:service_instance)
           path             = args.required(:path)
-          checkout_branch(service_instance, branch) do
+          checkout_branch_on_service_instance(service_instance, branch) do
             qualified_path = qualified_path(service_instance, path)
             if File.exists?(qualified_path)
               File.open(qualified_path, 'r').read
@@ -301,18 +302,29 @@ module DTK::Client
           "#{repo_dir}/#{relative_path}"
         end
 
+        def self.checkout_branch_on_service_instance(service_instance, branch, &body)
+          repo = git_repo.new(ret_base_path(:service, service_instance), :branch => branch)
+          checkout_branch_in_repo(repo, branch, &block)
+        end
+
         CHECKOUT_LOCK = Mutex.new
-        def self.checkout_branch(service_instance, branch, &body)
+        # opts can have keys
+        #   :current_branch
+        def self.checkout_branch(repo, branch_to_checkout, opts = {}, &block)
           ret = nil
           CHECKOUT_LOCK.synchronize do
-            repo = git_repo.new(ret_base_path(:service, service_instance), :branch => branch)
-            current_branch = repo.current_branch.name
-            if current_branch == branch
-              ret = yield
+            current_branch = opts[:current_branch] || repo.current_branch.name
+            if current_branch == branch_to_checkout
+              ret = reset_if_error(repo, branch_to_checkout) { yield }
             else
+              #TODO: DTK-2922: temporary fix until can solve problem described in note below
+              unless repo.repo_dir == Dir.pwd
+                raise Error::Usage, "This command must be invoked from the base module directory '#{repo.repo_dir}'"
+              end
+
               begin
-                repo.checkout(branch) 
-                ret = yield
+                repo.checkout(branch_to_checkout) 
+                ret = reset_if_error(repo, branch_to_checkout) { yield }
               ensure
                 repo.checkout(current_branch)
               end
@@ -321,6 +333,31 @@ module DTK::Client
           ret
         end
 
+        #TODO: DTK-2922: tried below for above; it worked aside from fact that dircetory is empty and have to step down and step up
+        # Dir.chdir is done to avoid case where current directory does not exist in branch checking out
+        # Dir.chdir(repo.repo_dir) do
+        #   begin
+        #     repo.checkout(branch_to_checkout) 
+        #     ret = reset_if_error(repo, branch_to_checkout) { yield }
+        #   ensure
+        #     repo.checkout(current_branch)
+        #   end
+        # end
+
+        def self.reset_if_error(repo, branch, &block)
+          ret = nil
+          begin
+            sha_before_operations =  repo.revparse(branch)
+            ret = yield
+          rescue => e
+            # reset to enable checkout of another branch
+            repo.add_all
+            repo.reset_hard(sha_before_operations)
+            raise e
+          end
+          ret
+        end
+
       end
     end
   end

data/lib/client/operation/client_module_dir/git_repo.rb

@@ -72,7 +72,29 @@ module DTK::Client
         end
       end
 
+      # The retries are put in to avoid race condition when the keys are not yet in repo manager gitolite
+      DEFAULT_NUM_DTKN_FETCH_RETRIES = 20
+      SLEEP_BETWEEN_RETRIES = 1
       def self.fetch_dtkn_remote(args)
+        if num_retries = ENV['NUM_DTKN_FETCH_RETRIES']
+          num_retries = num_retries.to_i rescue nil
+        end
+        num_retries ||= DEFAULT_NUM_DTKN_FETCH_RETRIES
+        ret = nil
+        while num_retries > 0
+          num_retries -= 1
+          begin
+            if ret = fetch_dtkn_remote_single_try(args)
+              return ret
+            end
+          rescue => e
+            fail e if num_retries == 0
+          end
+        end
+        ret # should not be reached
+      end
+
+      def self.fetch_dtkn_remote_single_try(args)
         wrap_operation(args) do |args|
           repo_with_remote = repo_with_dtkn_remote(args)
 
@@ -80,6 +102,7 @@ module DTK::Client
           response_data_hash
         end
       end
+      private_class_method :fetch_dtkn_remote_single_try
 
       def self.merge_from_dtkn_remote(args)
         wrap_operation(args) do |args|
@@ -91,11 +114,34 @@ module DTK::Client
         end
       end
 
-      def self.checkout_branch__return_repo(args)
+      def self.local_ahead?(args)
         wrap_operation(args) do |args|
-          repo_dir     = args.required(:repo_dir)
-          local_branch = args.required(:local_branch)
-          response_data_hash(:repo => Internal.checkout_branch__return_repo(repo_dir, local_branch))
+          remote_branch = args.required(:remote_branch)
+          no_commit     = args[:no_commit]
+          repo_with_remote  = repo_with_dtkn_remote(args)
+
+          response_data_hash(:local_ahead => repo_with_remote.local_ahead?(remote_branch, :no_commit => no_commit))
+        end
+      end
+
+      def self.create_empty_git_repo?(args)
+        wrap_operation(args) do |args|
+          repo_dir = args.required(:repo_dir)
+          branch   = args.required(:branch)
+
+          response_data_hash(:repo => Internal.create_empty_git_repo?(repo_dir, :branch => branch))
+        end
+      end
+
+      # The arg repo wil have a branch. This funbctio checks that out and when finished goes back to current_branch
+      def self.checkout_branch(args, &block)
+        wrap_operation(args) do |args|
+          repo               = args.required(:repo)
+          current_branch     = args.required(:current_branch)
+          branch_to_checkout = args.required(:branch_to_checkout)
+
+          Internal.checkout_branch(repo, branch_to_checkout, :current_branch => current_branch, &block)
+          response_data_hash
         end
       end
 

data/lib/client/operation/client_module_dir.rb

@@ -115,6 +115,7 @@ module DTK::Client
       end
 
       def self.create_file_with_content(file_path, content)
+        FileUtils.mkdir_p(File.dirname(file_path))
         File.open(file_path, 'w') { |f| f << content }
       end
     
@@ -123,8 +124,6 @@ module DTK::Client
       def self.base_path(type)
         path =
           case type.to_sym
-          when :service_module then Config[:service_location]
-          when :component_module then Config[:module_location]
           when :service then Config[:instance_location]
           else raise Error, "Unexpected type (#{type}) when determining base path"
           end

data/lib/client/operation/module/delete_from_remote.rb

@@ -29,7 +29,7 @@ module DTK::Client
       def self.execute(args = Args.new)
         wrap_operation(args) do |args|
           module_ref  = args.required(:module_ref)
-          new('dtkn', module_ref).delete_from_remote(:skip_prompt => args[:skip_prompt])
+          new('dtkn', module_ref).delete_from_remote(:skip_prompt => args[:skip_prompt], :force => args[:force])
         end
       end
       
@@ -38,6 +38,7 @@ module DTK::Client
           :module_name => module_ref.module_name,
           :namespace   => module_ref.namespace,
           :rsa_pub_key => SSHUtil.rsa_pub_key_content,
+          :force?      => opts[:force]
         )
 
         unless version = module_ref.version

data/lib/client/operation/module/install/dependent_modules/component_dependency_tree.rb

@@ -95,6 +95,14 @@ module DTK::Client; class Operation::Module
         end
 
         dependencies = convert_to_module_refs_array(response)
+
+        # to avoid cases where dependency can have itself as dependency (stack level too deep) we remove it from dependencies
+        # think we will not need this when we have unified module (instead of component and service modules)
+        if @module_ref.is_base_module?
+          matching = dependencies.find{ |dep| (dep.module_name == module_name) && (dep.namespace == namespace) && (dep.version == version) }
+          dependencies.delete(matching)
+        end
+
         @cache.add!(@module_ref, dependencies)
         dependencies
       end

data/lib/client/operation/module/install/dependent_modules/component_module.rb

@@ -45,6 +45,7 @@ module DTK::Client; class Operation::Module
       end
 
       def query_if_component_module_is_installed?
+        # TODO: :type => :component_module is for legacy; once we get past having legacy can change to :common_module
         module_version_exists?(@module_ref, :type => :component_module)
       end
 
@@ -59,15 +60,13 @@ module DTK::Client; class Operation::Module
           :namespace   => namespace,
           :rsa_pub_key => SSHUtil.rsa_pub_key_content,
           :version?    => version,
-          :full_module_name => full_module_name,
-          :json_diffs  => ""
+          :force       => true # TODO: hardwired
         }
-        response = rest_post "#{BaseRoute}/pull_component_module_from_remote", PostBody.new(post_body)
+        response = rest_post "#{BaseRoute}/pull_component_info_from_remote", PostBody.new(post_body)
 
-        if custom_message = response.data[:custom_message]
-          OsUtil.print(custom_message)
-        elsif (response.data[:diffs].nil? || response.data[:diffs].empty?)
-          OsUtil.print("No changes to pull from remote.", :yellow) unless response['errors']
+        if (response.data(:diffs) || {}).empty?
+#          OsUtil.print("No changes to pull from remote.", :yellow) unless response['errors']
+          OsUtil.print("No changes to pull from remote.", :yellow) 
         else
           OsUtil.print("Changes pulled from remote", :green)
         end

data/lib/client/operation/module/install/dependent_modules.rb

@@ -32,6 +32,7 @@ module DTK::Client
         @component_module_refs = component_module_refs 
         @print_helper          = PrintHelper.new(:module_ref => @base_module_ref, :source => :remote)
         @prompt_helper         = PromptHelper.new(:update_all => opts[:skip_prompt], :update_none => opts[:update_none])
+        @opts                  = opts
       end
       private :initialize
 
@@ -44,7 +45,12 @@ module DTK::Client
         @print_helper.print_getting_dependencies
         unified_module_refs = get_unified_dependent_module_refs
         unless unified_module_refs.empty?
-          @print_helper.print_installing_dependencies
+          case @opts[:mode]
+          when 'pull'
+            @print_helper.print_pulling_dependencies
+          else
+            @print_helper.print_installing_dependencies
+          end
           unified_module_refs.each do |module_ref|
             # Using unless module_ref.is_base_module? because Base component module is installed when base is installed
             ComponentModule.install_or_pull?(module_ref, @prompt_helper, @print_helper) unless module_ref.is_base_module?

data/lib/client/operation/module/install/print_helper.rb

@@ -44,6 +44,10 @@ module DTK::Client; class Operation::Module
         print_continuation "Installing base module '#{pretty_print_module}' from #{source_term}", :color => :yellow
       end
 
+      def print_continuation_pulling_base_module
+        print_continuation "Pulling base module '#{pretty_print_module}' from #{source_term}", :color => :yellow
+      end
+
       def print_continuation_pulling_dependency_update
         print_continuation "Pulling update to dependent module '#{pretty_print_module}'"
       end
@@ -62,6 +66,10 @@ module DTK::Client; class Operation::Module
         OsUtil.print_info("Installing dependent modules from #{Term::DTKN_CATALOG} #{Term::CONTINUATION}")
       end
 
+      def print_pulling_dependencies
+        OsUtil.print_info("Pulling dependent modules from #{Term::DTKN_CATALOG} #{Term::CONTINUATION}")
+      end
+
       def print_using_installed_dependent_module
         OsUtil.print("Using installed dependent module '#{pretty_print_module}'")
       end
@@ -70,6 +78,10 @@ module DTK::Client; class Operation::Module
         OsUtil.print_warning("Terminated installation of module '#{pretty_print_module}'")
       end
 
+      def print_terminated_pulling
+        OsUtil.print_warning("Terminated pulling of module '#{pretty_print_module}'")
+      end
+
       def print_done_message
         OsUtil.print('Done.', :yellow)
       end

data/lib/client/operation/module/pull_dtkn.rb

@@ -26,20 +26,31 @@ module DTK::Client
         @target_repo_dir   = directory_path || base_dsl_file_obj.parent_dir
         @version           = version # if nil wil be dynamically updated
         @base_dsl_file_obj = base_dsl_file_obj
+        @parsed_module     = base_dsl_file_obj.parse_content(:common_module_summary)
+        @print_helper      = Install::PrintHelper.new(:module_ref => module_ref, :source => :remote)
       end
       private :initialize
 
       def self.execute(args = Args.new)
         wrap_operation(args) do |args|
-          module_ref        = args.required(:module_ref)
-          version           = args[:version] || module_ref.version
-          base_dsl_file_obj = args[:base_dsl_file_obj]
-          directory_path    = args[:directory_path]
-          new('dtkn', module_ref, directory_path, version, base_dsl_file_obj).pull_dtkn
+          module_ref          = args.required(:module_ref)
+          base_dsl_file_obj   = args.required(:base_dsl_file_obj)
+          version             = args[:version] || module_ref.version
+          directory_path      = args[:directory_path]
+          has_directory_param = args[:has_directory_param]
+          skip_prompt         = args[:skip_prompt]
+
+          if has_directory_param
+            file_obj = base_dsl_file_obj.raise_error_if_no_content_flag(:module_ref)
+          else
+            file_obj = base_dsl_file_obj.raise_error_if_no_content
+          end
+
+          new('dtkn', module_ref, directory_path, version, file_obj).pull_dtkn(:skip_prompt => skip_prompt)
         end
       end
       
-      def pull_dtkn
+      def pull_dtkn(opts = {})
         # TODO: DTK-2765: not sure if we need module to exist on server to do push-dtkn
         unless module_version_exists?(@module_ref, :type => :common_module)
           raise Error::Usage, "Module #{@module_ref.print_form} does not exist on server"
@@ -65,10 +76,48 @@ module DTK::Client
           @module_ref.version = @version
         end
 
+        unless dependent_modules.empty?
+          begin
+            Install::DependentModules.install(@module_ref, dependent_modules, :skip_prompt => opts[:skip_prompt], :mode => 'pull')
+            # Install::DependentModules.install(@module_ref, dependent_modules, :skip_prompt => false, :mode => 'pull')
+          rescue Install::TerminateInstall
+            @print_helper.print_terminated_pulling
+            return nil
+          end
+        end
+
+        @print_helper.print_continuation_pulling_base_module
         LoadSource.fetch_transform_and_merge(remote_module_info, self, :stage_and_commit_steps => true)
+
         nil
       end
 
+      private
+
+      def dependent_modules
+        @dependent_modules ||= compute_dependent_modules
+      end
+
+      def compute_dependent_modules
+        base_component_module_found = false
+        ret = (@parsed_module.val(:DependentModules) || []).map do |parsed_module_ref|
+          dep_module_name = parsed_module_ref.req(:ModuleName)
+          dep_namespace   = parsed_module_ref.req(:Namespace)
+          dep_version     = parsed_module_ref.val(:ModuleVersion)
+          if is_base_module = (dep_module_name == @module_ref.module_name)
+            # This is for legacy modules
+            base_component_module_found = true
+          end
+          Install::ModuleRef.new(:namespace => dep_namespace, :module_name => dep_module_name, :version => dep_version, :is_base_module => is_base_module)
+        end
+        unless base_component_module_found
+          if module_version_exists?(@module_ref, :type => :component_module)
+            ret << Install::ModuleRef.new(:namespace => @module_ref.namespace, :module_name => @module_ref.module_name, :version => @module_ref.version, :is_base_module => true)
+          end
+        end
+        ret
+      end
+
     end
   end
 end

data/lib/client/operation/module/push.rb

@@ -66,8 +66,6 @@ module DTK::Client
             end
             response = rest_post("#{BaseRoute}/update_from_repo", post_body.merge(:skip_missing_check => true))
           end
-          # TODO: DTK-2786; uncomment out to see what diffs is returning for different examples of what is deleted, added or modified before push
-          # pp [:debug_diffs, response.data(:diffs)]
           print = process_semantic_diffs(response.data(:diffs), method)
 
           # if diffs is nil then indicate no diffs, otherwise render diffs in yaml

data/lib/client/operation/module/push_dtkn/convert_source/component_info.rb

@@ -22,6 +22,7 @@ module DTK::Client
         # attr_reader :parsed_common_module
 
         def transform_info
+          fetch_remote
           transform_to_component_info
         end
         

data/lib/client/operation/module/push_dtkn/convert_source/service_info.rb

@@ -20,6 +20,7 @@ module DTK::Client
     class ConvertSource
       class ServiceInfo < self
         def transform_info
+          fetch_remote
           transform_to_service_info
         end
 

data/lib/client/operation/module/push_dtkn/convert_source.rb

@@ -33,14 +33,14 @@ module DTK::Client; class Operation::Module
       def self.transform_and_commit(remote_module_info, parent)
         target_repo_dir      = parent.target_repo_dir
         parsed_common_module = parent.base_dsl_file_obj.parse_content(:common_module)
-        local_branch         = Operation::ClientModuleDir::GitRepo.current_branch(:path => target_repo_dir).data(:branch)
+        current_branch         = Operation::ClientModuleDir::GitRepo.current_branch(:path => target_repo_dir).data(:branch)
 
         if service_info = remote_module_info.data(:service_info)
-          transform_service_info(target_repo_dir, parent, service_info, parsed_common_module, local_branch)
+          transform_service_info(target_repo_dir, parent, service_info, parsed_common_module, current_branch)
         end
 
         if component_info = remote_module_info.data(:component_info)
-          transform_component_info(target_repo_dir, parent, component_info, parsed_common_module, local_branch)
+          transform_component_info(target_repo_dir, parent, component_info, parsed_common_module, current_branch)
         end
       end
 
@@ -48,27 +48,29 @@ module DTK::Client; class Operation::Module
         new(transform_helper, info_type, remote_repo_url, parent).transform_info
       end
 
-      def self.transform_service_info(target_repo_dir, parent, service_info, parsed_common_module, local_branch = 'master')
+      def self.transform_service_info(target_repo_dir, parent, service_info, parsed_common_module, current_branch)
         transform_helper = ServiceAndComponentInfo::TransformTo.new(target_repo_dir, parent.module_ref, parent.version, parsed_common_module)
         service_file_path__content_array = ServiceInfo.transform_info(transform_helper, service_info['remote_repo_url'], parent)
 
-        repo = checkout_branch__return_repo(target_repo_dir, "remotes/dtkn/master").data(:repo)
-        FileUtils.mkdir_p("#{target_repo_dir}/assemblies") unless File.exists?("#{target_repo_dir}/assemblies")
-
-        args = [transform_helper, ServiceInfo.info_type, service_info['remote_repo_url'], parent]
-        service_file_path__content_array.each { |file| Operation::ClientModuleDir.create_file_with_content("#{service_file_path(target_repo_dir, file, *args)}", file[:content]) }
-
-        commit_and_push_to_remote(repo, target_repo_dir, "master", "dtkn", local_branch)
+        create_and_checkout_branch?(current_branch, target_repo_dir, "remotes/dtkn/master") do |repo|
+          FileUtils.mkdir_p("#{target_repo_dir}/assemblies") unless File.exists?("#{target_repo_dir}/assemblies")
+          
+          args = [transform_helper, ServiceInfo.info_type, service_info['remote_repo_url'], parent]
+          service_file_path__content_array.each { |file| Operation::ClientModuleDir.create_file_with_content("#{service_file_path(target_repo_dir, file, *args)}", file[:content]) }
+          
+          commit_and_push_to_remote(repo, target_repo_dir, "master", "dtkn")
+        end
       end
 
-      def self.transform_component_info(target_repo_dir, parent, component_info, parsed_common_module, local_branch = 'master')
+      def self.transform_component_info(target_repo_dir, parent, component_info, parsed_common_module, current_branch)
         transform_helper = ServiceAndComponentInfo::TransformTo.new(target_repo_dir, parent.module_ref, parent.version, parsed_common_module)
         component_file_path__content_array = ComponentInfo.transform_info(transform_helper, component_info['remote_repo_url'], parent)
 
-        repo = checkout_branch__return_repo(target_repo_dir, "remotes/dtkn-component-info/master").data(:repo)
-        component_file_path__content_array.each { |file| Operation::ClientModuleDir.create_file_with_content("#{file_path(target_repo_dir, file)}", file[:content]) }
+        create_and_checkout_branch?(current_branch, target_repo_dir, "remotes/dtkn-component-info/master") do |repo|
+          component_file_path__content_array.each { |file| Operation::ClientModuleDir.create_file_with_content("#{file_path(target_repo_dir, file)}", file[:content]) }
 
-        commit_and_push_to_remote(repo, target_repo_dir, "master", "dtkn-component-info", local_branch)
+          commit_and_push_to_remote(repo, target_repo_dir, "master", "dtkn-component-info")
+        end
       end
       
       private
@@ -103,18 +105,33 @@ module DTK::Client; class Operation::Module
         "#{target_repo_dir}/assemblies/#{assembly_name}/assembly.yaml"
       end
 
-      def self.checkout_branch__return_repo(target_repo_dir, branch)
-        git_repo_args = {
-          :repo_dir     => target_repo_dir,
-          :local_branch => branch
+      def fetch_remote
+        git_repo_args = common_git_repo_args.merge(:add_remote => @remote_repo_url)
+        git_repo_operation.fetch_dtkn_remote(git_repo_args)
+      end
+
+      def common_git_repo_args
+         {
+          :info_type => @info_type,
+          :repo_dir  => @target_repo_dir
+        }
+      end
+
+      def self.create_and_checkout_branch?(current_branch, target_repo_dir, branch_to_checkout, &body)
+        repo = git_repo_operation.create_empty_git_repo?(:repo_dir => target_repo_dir, :branch => branch_to_checkout).data(:repo)
+
+        checkout_branch_args = {
+          :repo => repo, 
+          :current_branch => current_branch,
+          :branch_to_checkout => branch_to_checkout
         }
-        git_repo_operation.checkout_branch__return_repo(git_repo_args)
+
+        git_repo_operation.checkout_branch(checkout_branch_args) { body.call(repo) }
       end
 
-      def self.commit_and_push_to_remote(repo, target_repo_dir, branch, remote, local_branch)
+      def self.commit_and_push_to_remote(repo, target_repo_dir, branch, remote)
         repo.stage_and_commit("Add auto-generated files from push-dtkn")
         repo.push_from_cached_branch(remote, branch, { :force => true })
-        repo.checkout(local_branch)
       end
 
       def self.stage_and_commit(target_repo_dir, commit_msg = nil)

data/lib/client/operation/service/ssh.rb

@@ -56,7 +56,7 @@ module DTK::Client
         response = rest_get("#{BaseRoute}/#{service_instance}/info")
 
         unless node_info = response.data(:nodes).find{ |node| node_name == node['display_name'] }
-          raise Error::Usage, "Cannot find info about node with id '#{node_id}'"
+          raise Error::Usage, "The node '#{node_name}' does not exist"
         end
 
         data            = {}

data/lib/client/session.rb

@@ -31,7 +31,10 @@ module DTK::Client
       @conn = Conn.new
     end
     
-    def self.get_connection
+    # opts can have keys
+    #  :reset
+    def self.get_connection(opts = {})
+      instance.conn = Conn.new if opts[:reset]
       instance.conn
     end
     

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dtk-client
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.10.5
 platform: ruby
 authors:
 - Reactor8
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-06 00:00:00.000000000 Z
+date: 2017-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dtk-common-core
@@ -380,7 +380,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: DTK CLI client for DTK server interaction.